堆排序两例

1.Code :http://blog.csdn.net/v_JULY_v/article/details/6126406

 

 

//借助堆，查找最小的k个数  
//copyright@ yansha &&July  
//July、updated，2011.04.28。  
#include <iostream>  
#include <assert.h>  
using namespace std;  
void MaxHeap(int heap[], int i, int len);  
/*------------------- 
BUILD-MIN-HEAP(A) 
1  heap-size[A] ← length[A] 
2  for i ← |_length[A]/2_| downto 1 
3       do MAX-HEAPIFY(A, i) 
*/  
// 建立大根堆  
void BuildHeap(int heap[], int len)  
{  
    if (heap == NULL)  
        return;  
      
    int index = len / 2;  
    for (int i = index; i >= 1; i--)  
        MaxHeap(heap, i, len);  
}  
/*----------------------------   
PARENT(i) 
   return |_i/2_| 
LEFT(i) 
   return 2i 
RIGHT(i) 
   return 2i + 1 
MIN-HEAPIFY(A, i) 
l ← LEFT(i) 
2 r ← RIGHT(i) 
3 if l ≤ heap-size[A] and A[l] < A[i] 
4    then smallest ← l 
5    else smallest ← i 
6 if r ≤ heap-size[A] and A[r] < A[smallest] 
7    then smallest ← r 
8 if smallest ≠ i 
9    then exchange A[i] <-> A[smallest] 
10         MIN-HEAPIFY(A, smallest) 
*/  
//调整大根堆  
void MaxHeap(int heap[], int i, int len)  
{  
    int largeIndex = -1;  
    int left = i * 2;  
    int right = i * 2 + 1;  
      
    if (left <= len && heap[left] > heap[i])  
        largeIndex = left;  
    else  
        largeIndex = i;  
      
    if (right <= len && heap[right] > heap[largeIndex])  
        largeIndex = right;  
      
    if (largeIndex != i)  
    {  
        swap(heap[i], heap[largeIndex]);  
        MaxHeap(heap, largeIndex, len);  
    }  
}  
int main()  
{  
    // 定义数组存储堆元素  
    int k;  
    cin >> k;  
    int *heap = new int [k+1];   //注，只需申请存储k个数的数组  
    FILE *fp = fopen("data.txt", "r");   //从文件导入海量数据（便于测试，只截取了9M的数据大小）  
    assert(fp);  
      
    for (int i = 1; i <= k; i++)  
        fscanf(fp, "%d ", &heap[i]);  
      
    BuildHeap(heap, k);      //建堆  
      
    int newData;  
    while (fscanf(fp, "%d", &newData) != EOF)  
    {  
        if (newData < heap[1])   //如果遇到比堆顶元素kmax更小的，则更新堆  
        {  
            heap[1] = newData;  
            MaxHeap(heap, 1, k);   //调整堆  
        }  
          
    }  
      
    for (int j = 1; j <= k; j++)  
        cout << heap[j] << " ";  
    cout << endl;        
    fclose(fp);  
    return 0;  
}  

 

2. CODE : http://www.cnblogs.com/dolphin0520/archive/2011/10/06/2199741.html

 

/*堆排序(大顶堆) 2011.9.14*/ 

#include <iostream>
#include<algorithm>
using namespace std;

void HeapAdjust(int *a,int i,int size)  //调整堆 
{
    int lchild=2*i;       //i的左孩子节点序号 
    int rchild=2*i+1;     //i的右孩子节点序号 
    int max=i;            //临时变量 
    if(i<=size/2)          //如果i是叶节点就不用进行调整 
    {
        if(lchild<=size&&a[lchild]>a[max])
        {
            max=lchild;
        }    
        if(rchild<=size&&a[rchild]>a[max])
        {
            max=rchild;
        }
        if(max!=i)
        {
            swap(a[i],a[max]);
            HeapAdjust(a,max,size);    //避免调整之后以max为父节点的子树不是堆 
        }
    }        
}

void BuildHeap(int *a,int size)    //建立堆 
{
    int i;
    for(i=size/2;i>=1;i--)    //非叶节点最大序号值为size/2 
    {
        HeapAdjust(a,i,size);    
    }    
} 

void HeapSort(int *a,int size)    //堆排序 
{
    int i;
    BuildHeap(a,size);
    for(i=size;i>=1;i--)
    {
        //cout<<a[1]<<" ";
        swap(a[1],a[i]);           //交换堆顶和最后一个元素，即每次将剩余元素中的最大者放到最后面 
          //BuildHeap(a,i-1);        //将余下元素重新建立为大顶堆 
          HeapAdjust(a,1,i-1);      //重新调整堆顶节点成为大顶堆
    }
} 

int main(int argc, char *argv[])
{
     //int a[]={0,16,20,3,11,17,8};
    int a[100];
    int size;
    while(scanf("%d",&size)==1&&size>0)
    {
        int i;
        for(i=1;i<=size;i++)
            cin>>a[i];
        HeapSort(a,size);
        for(i=1;i<=size;i++)
            cout<<a[i]<<"";
        cout<<endl;
    }
    return 0;
}