算法之简单选择排序和堆排序

void print(int a[], int n ,int i）
{
   cout<<"第"<<i+1 <<"趟 : ";
   for(int j= 0; j<8; j++)
   {
　　cout<<a[j] <<" ";
   }
　cout<<endl;
}
/*** 数组的最小值 ** @return int 数组的键值 */
int SelectMinKey(int a[], int n, int i)
{
   int k = i;
   for(int j=i+1 ;j< n; ++j)
   {
      if(a[k] > a[j]) k = j;
　}
　return k;
}
/*** 选择排序 **/
void selectSort(int a[], int n)
{
   int key, tmp;
　　for(int i = 0; i< n; ++i)
　　{
　　　　key = SelectMinKey(a, n,i);
　　　　//选择最小的元素
　　　　 if(key != i)
　　　　　{
　　　　　　　tmp = a[i]; a[i] = a[key]; a[key] = tmp;
　　　　　　　//最小元素与第i位置元素互换 }
　　　　　　　print(a, n , i);
　　　　　}
　　}
int main()
{
　　int a[8] = {3,1,5,7,2,4,9,6};
　　cout<<"初始值：";
　　for(int j= 0; j<8; j++)
　　{
　　　　cout<<a[j] <<" ";
　　}
　　cout<<endl<<endl;
　　selectSort(a, 8); print(a,8,8);  
}

void SelectSort(int r[],int n) 
{
     int i ,j , min ,max, tmp;
    for (i=1 ;i <= n/2;i++) 
   {  
       // 做不超过n/2趟选择排序 
       min = i; max = i ; //分别记录最大和最小关键字记录位置
       for (j= i+1; j<= n-i; j++) 
      {
           if (r[j] > r[max])
          { 
    max = j ; continue ; 
          }  
           if (r[j]< r[min]) 
         { 
    min = j ; 
         }   
      }  
       //该交换操作还可分情况讨论以提高效率
      tmp = r[i-1]; r[i-1] = r[min]; r[min] = tmp;
      tmp = r[n-i]; r[n-i] = r[max]; r[max] = tmp; 
  } 
}

void print(int a[], int n)
{  
    for(int j= 0; j<n; j++)
   {  
        cout<<a[j] <<"  ";  
    }  
    cout<<endl;  
}  

/*已知H[s…m]除了H[s] 外均满足堆的定义 
 * 调整H[s],使其成为大顶堆.即将对第s个结点为根的子树筛选,  
 * 
 * @param H是待调整的堆数组 
 * @param s是待调整的数组元素的位置 
 * @param length是数组的长度 */  
void HeapAdjust(int H[],int s, int length)  
{  
    int tmp  = H[s];  
    int child = 2*s+1; //左孩子结点的位置。(i+1 为当前调整结点的右孩子结点的位置)  
    while (child < length)
    {  
        if(child+1 <length && H[child]<H[child+1])
        { 
            // 如果右孩子大于左孩子(找到比当前待调整结点大的孩子结点)  
            ++child ;  
        }  
        if(H[s]<H[child]) 
       {  
            // 如果较大的子结点大于父结点  
            H[s] = H[child]; // 那么把较大的子结点往上移动，替换它的父结点  
            s = child;       // 重新设置s ,即待调整的下一个结点的位置  
            child = 2*s+1;  
        }  
        else 
       {            
        // 如果当前待调整结点大于它的左右孩子，则不需要调整，直接退出  
             break;  
        }  
        H[s] = tmp;         // 当前待调整的结点放到比其大的孩子结点位置上  
    }  
    print(H,length);  
}  
  
  /** 初始堆进行调整 
 * 将H[0..length-1]建成堆 
 * 调整完之后第一个元素是序列的最小的元素*/  

void BuildingHeap(int H[], int length)  
{   
    //最后一个有孩子的节点的位置 i=  (length -1) / 2  
    for (int i = (length -1) / 2 ; i >= 0; --i)  
        HeapAdjust(H,i,length);  
}  

/* 堆排序算法*/  

void HeapSort(int H[],int length)  
{  
    //初始堆  
    BuildingHeap(H, length);  
    //从最后一个元素开始对序列进行调整  
    for (int i = length - 1; i > 0; --i)  
    {  
        //交换堆顶元素H[0]和堆中最后一个元素  
        int temp = H[i]; H[i] = H[0]; H[0] = temp;  
        //每次交换堆顶元素和堆中最后一个元素之后，都要对堆进行调整  
        HeapAdjust(H,0,i);  
  }  
}   
  
int main()
{  
    int H[10] = {3,1,5,7,2,4,9,6,10,8};  
    cout<<"初始值：";  
    print(H,10);  
    HeapSort(H,10);  
    //selectSort(a, 8);  
    cout<<"结果：";  
    print(H,10);  
}