堆数据结构

（二叉）堆数据结构是一种对象数组，它可以被视为完全二叉树，树中的每个结点和数组中存放该结点值的元素对应，树中每一层都是满的最后一层可能除外（最后一层从一个结点左子树开始填），堆数组有两个属性对象一个是length[A]是数组元素个数，heap_size[A]是堆元素个数，其中heap_size[A]<=length[A],二叉堆有两种一种是最大堆一种是最小堆，最大堆性质是A[parent[i]]>=A[i]，即根节点元素值不小于孩子结点元素值；最小堆性质A[parent[i]]<=A[i],即根结点元素值不大于孩子结点元素值。在堆排序算法中我们使用的是最大堆，最小堆通常在构造优先队列时使用。结点在堆中的高度定义为从本结点到叶子结点的最长简单下降路径上边的数目；定义堆的高度为树根的高度。

保持堆性质的算法：

#include<iostream>
#include<vector>
#include<string.h>
using namespace std;
int n;
void input(int *v)
{  
	 cin>>n;
     v[0]=0;//标志位
	 cout<<"please input array element:"<<endl;
   for(int i=1;i<=n;++i)
	   cin>>v[i];

}
void output(int *v)
{  for(int i=0;i<=n;++i)
     cout<<v[i]<<" ";
     cout<<endl;
 }
void max_heapify(int *v,int i)//递归算法
{   int heap_size=n;
    int l=i<<1,r=(i<<1)+1,largest=i;
	if(l<=heap_size&&v[l]>v[largest]) largest=l;
	if(r<=heap_size&&v[r]>v[largest]) largest=r;
	if(i!=largest)
	{  int temp=v[i];
	   v[i]=v[largest];
	   v[largest]=temp;
       max_heapify(v,largest);
	}
	
}
void max_heapify_effective(int *v,int i)//非递归算法
{int heap_size=n;
   while(i<=n)
   {   int largest=i;
	   int l=i<<1,r=(i<<1)+1;
      if(l<=heap_size&&v[l]>v[largest]) largest=l;
	 if(r<=heap_size&&v[r]>v[largest]) largest=r;
	 if(i!=largest)
	 {  int temp=v[i];
	    v[i]=v[largest];
	    v[largest]=temp;
        i=largest;
	 }
     else break;
   }
   
}
int main()
{   int v[20];
    cout<<"The Array is size:";
    input(v);
	cout<<"please input the sort:  ";
	int i;
	cin>>i;
	//max_heapify(v,i);
	max_heapify_effective(v,i);
	output(v);
	return 0;
}

建堆：

思路：由于当数组中存放n个元素的堆时，叶子结点的下标为n/2......n。基于这一性质我们可以自底向上的调用max_heapify()来将一个数组A[1......n]变成一个最大堆。只需对子数组A[n/2....1]操作。而A[n/2+1...n]都是树的叶子因此可以看作是只含有一个元素的堆。

void build_max_heap(int *v)
{  for(int i=n/2;i>0;--i)
    max_heapify(v,i);
}

堆排序算法：

思路：开始时，堆排序算法先用build_max_heap将输入的数组A[1.....n]构成一个最大堆。因为数组中最大元素在根A[1],则可以通过它与A[n]交换来达到最终正确的位置。现在从堆中去掉结点n，新的根结点可能违背了最大堆的性质，这时需要调用max—heapify(A,1),让A[1....n-1]重新构成最大堆，然后重复上面的过程，直到堆的大小从n一直降到2。

#include<iostream>
#include<vector>
#include<string.h>
using namespace std;
int n,p;
void max_heapify(int *v,int i);
void  heapsort();
void build_max_heap(int *v)构//建最大堆算法
{  for(int i=n/2;i>0;--i)
    max_heapify(v,i);
}

void input(int *v)
{  
	 cin>>n;
	 p=n;
     v[0]=0;//标志位
	 cout<<"please input array element:"<<endl;
   for(int i=1;i<=n;++i)
	   cin>>v[i];
   build_max_heap(v);

}
void output(int *v)
{  for(int i=0;i<=p;++i)
     cout<<v[i]<<" ";
     cout<<endl;
 }
void max_heapify(int *v,int i)//保持堆性质的递归算法
{   int heap_size=n;
    int l=i<<1,r=(i<<1)+1,largest=i;
	if(l<=heap_size&&v[l]>v[largest]) largest=l;
	if(r<=heap_size&&v[r]>v[largest]) largest=r;
	if(i!=largest)
	{  int temp=v[i];
	   v[i]=v[largest];
	   v[largest]=temp;
       max_heapify(v,largest);
	}
	
}
void max_heapify_effective(int *v,int i)//保持堆性质的非递归算法
{int heap_size=n;
   while(i<=n)
   {   int largest=i;
	   int l=i<<1,r=(i<<1)+1;
      if(l<=heap_size&&v[l]>v[largest]) largest=l;
	 if(r<=heap_size&&v[r]>v[largest]) largest=r;
	 if(i!=largest)
	 {  int temp=v[i];
	    v[i]=v[largest];
	    v[largest]=temp;
        i=largest;
	 }
     else break;
   }
   
}
void  heapsort(int *v)//堆排序算法
{  
    int m=n;
   for(int i=m;i>1;--i)
   {  int temp=v[i];
         v[i]=v[1];
		 v[1]=temp;
		 n--;
		 max_heapify(v,1);
	}
}

int main()
{   int v[20];
    cout<<"The Array is size:";
    input(v);
	heapsort(v);
	//cout<<"please input the sort:  ";
	//int i;
	//cin>>i;
	//max_heapify(v,i);
	//max_heapify_effective(v,i);
	output(v);
	return 0;
}

注：max—heapify时间复杂度为O(lgn),heapsort的时间复杂度为O(nlgn)。