编程珠玑第14章

内容来自互联网，自己做了一定的修改

一，堆

       1）堆：任何结点的值都小于或等于其孩子的值的完全二叉树为小根堆

                    任何结点的值都大于或等于其孩子的值的完全二叉树为大根堆

      为了方便使用完全二叉树的性质，数组从下标1开始。

            这样：leftChild = 2*i ;  

                       rightChild = 2*i + 1 ;  

                       parent = i/2 ; 

                       null   i < 1  or  i > n

       2）堆算法分析

            堆排序的最坏时间复杂度为O(nlogn)。堆序的平均性能较接近于最坏性能。

　　     由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件。

　　     堆排序是就地排序，辅助空间为O(1）

            堆排序是不稳定的

  

       3）堆实现

            【特别注意】堆不一定是完全二叉树但是一般采用完全二叉树,主要是利于存储和运算。堆排序作用在数组上

             初始建立堆：

                        给一个数组，将数组看做完全二叉树。

                        从最后一个非叶结点（length/2，下标从1开始），直到第一个结点a[1]，向上调整建立堆。

             排序和堆调整

                        将第一个值a[1] 跟最后一个值交换，然后对 a[1] 调整堆（此时数组长度调整为length-1）

            【注意】这里初始建堆，只考虑已经有n个元素，向下调整建堆就可以搞定。

                           但是对于insert（t）怎么办？ 采用向上调整堆的策略。

非递归实现堆：

#include<iostream>
using namespace std;
void swap(int *a,int *b)
{
	int temp=*a;
	*a=*b;
	*b=temp;
}
//用迭代的方法调整最大堆
void heapmodify(int a[],int i,int length) //自顶向下调整堆，这是一个最大堆
{
	while(2*i<=(length-1))//注意这里2*i<=(length-1)与i<=(length-1)/2不等效，因为(length-1)/2有可能除不尽，就会向下取整
	{
		int maxchild=2*i+1;//2*i+1为左孩子，2*i+2为右孩子
		if(2*i+2<=(length-1))
		{
			if(a[2*i+2]>a[2*i+1])
				maxchild=2*i+2;
		}
		if(a[i]>=a[maxchild])
			break;
		swap(&a[maxchild],&a[i]);
		i=maxchild;
	}
}
<pre name="code" class="cpp">void heapsort(int a[],int length)
{
	for(int i=(length-1)/2;i>=0;--i)
		heapmodify(a,i,length);
	for(int i=length-1;i>=0;--i)
	{
		swap(&a[0],&a[i]);
			heapmodify(a,0,i-1);
	}
}

int main(){int a[]={1,12,0,3,6,9,8,10};int length=sizeof(a)/sizeof(int);heapsort(a,length);for(int i=0;i<length;i++)cout<<a[i]<<" ";cout<<endl;return 0;}

递归实现堆：

void maxheapify(int num[],int i,int size)//这里调整堆时用的是递归方法
{
	int left=2*i+1;int right=2*i+2;int largest=i;
	if(left<=size&&num[left]>num[i])
		largest=left;
	if(right<=size&&num[right]>num[largest])
		largest=right;
	if(largest!=i)
	{
		int temp=num[i];
		num[i]=num[largest];
		num[largest]=temp;
		maxheapify(num,largest,size);//避免调整之后以max为父节点的子树不是堆 
	}
}
void buildmaxheap(int num[],int size)
{
	for(int i=(size-1)/2;i>=0;i--)//注意这里需要size-1
		maxheapify(num,i,size);//必须从最后一个开始往前推
}
void heapsort(int num[],int size)
{
	buildmaxheap(num,size);
	for(int i=size-1;i>=0;i--)
	{
		int temp=num[0];//注意这里是数组最后一个元素与数组首元素交换也就是num[size-1]与num[0]
		num[0]=num[i];
		num[i]=temp;
		maxheapify(num,0,i-1);//注意首元素标号是0
	}
}

二，优先队列

        1）优先队列是0个或多个元素的集合,每个元素都有一个优先权或值,对优先队列执行的操作有1) 查找; 2) 插入一个新元素; 3) 删除.

              在最小优先队列(min priorityq u e u e)中,查找操作用来搜索优先权最小的元素,删除操作用来删除该元素;

              对于最大优先队列(max priority queue),查找操作用来搜索优先权最大的元素,删除操作用来删除该元素.

              优先权队列中的元素可以有相同的优先权,查找与删除操作可根据任意优先权进行.

            

        2）优先队列实现

              插入元素，将元素插入到数组的尾部，然后向上调整堆。

              删除元素，删除的是第一个元素。首先保存第一个元素为某一个变量，方便输出删除的元素。然后将第一个元素与最后一个元素交换，并向下调整堆。

   

        3）代码实现

[html]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4.   
5. template<class T>  
6.   
7. class priqueue {  
8. private:  
9.     int n, maxsize;  
10.     T   *x;  
11.     void swap(int &i, int &j)//根据坐标交换数组元素的值  
12.     {   T t = i; i = j; j = t; }  
13. public:  
14.     priqueue(int m)//初始化数组  
15.     {   maxsize = m;  
16.         x = new T[maxsize+1];  
17.         n = 0;  
18.     }  
19.           
20.     void insert(T t)  
21.     {   int i, p;  
22.         x[++n] = t; //插入的元素放到最后  
23.         for (i = n; i > 1 && x[p=i/2] > x[i]; i = p)      
24.                     swap(x[p], x[i]);  
25.                  
26.     }  
27.           
28.     T extractmin()//向下调整堆  
29.     {                
30.                 int i, c;  
31.         T t = x[1];  
32.         x[1] = x[n--];  
33.                   
34.         for (i = 1; (c=2*i) <= n; i = c) {  
35.             if (c+1<=n && x[c+1]<x[c])  
36.                 c++;  
37.             if (x[i] <= x[c])  
38.                 break;  
39.             swap(x[c], x[i]);  
40.         }  
41.                   
42.         return t;  
43.     }  
44.         void print(int n)  
45.         {  
46.                 for (int i = 1; i < n; i++) //输出堆  
47.                         cout << x[i] << " ";  
48.         }  
49.           
50. };  

习题

       1  为了提高向上调整堆的速度，在x[0] 放置哨兵=当前插入的元素。省去了每次都判断  i>1

             向上调整堆结束：x[p] <= x[i]  

 

[html]  view plain copy

1. void insert(T t) //向上调整堆  
2.     {   int i, p;  
3.         x[++n] = t; //插入的元素放到最后  
4.                   
5.                 x[0]=t;  //哨兵
6.                   
7.         for (i = n;  x[p=i/2] > x[i]; i = p) //有了哨兵这里就不用检查是否i>1
8.                     swap(x[p], x[i]);  
9.                  
10.     }  

2 构建堆

	for(int i=(length-1)/2;i>=0;--i)
		heapmodify(a,i,length);

3 堆排序

堆排序虽然保证了最坏情况下的O(nlogn)性能。但是对于常见的输入数据，最快的堆排序同城没有简单快速排序慢。

void heapsort(int a[],int length)
{
	for(int i=(length-1)/2;i>=0;--i)
		heapmodify(a,i,length);
	for(int i=length-1;i>=0;--i)
	{
		swap(&a[0],&a[i]);
			heapmodify(a,0,i-1);
	}
}

4

    4）a.构造哈夫曼树时候，需要选取当前数组的两个最小值，删除两个最小值，并将计算之和插入原来数组。

                 采用堆，初建堆，两次调用选取最小值的函数。计算之和之后，调用插入堆并调整堆

             b.如果将较小浮点数和较大浮点数相加可能造成丢失精度。所以每次取最小的两个相加。然后将和插入数组集合。最后剩下一个就是所有浮点数的和

             c.典型的topK

             d.将所有小文件 要插入的当前值组成一个堆。

                 取堆最小值，插入排序数组。调整堆。然后插入该小文件下一个元素（无后继则不操作）

                 实际上是归并排序，在算法导论中也有提及，就是把这k个要归并的，建立成为k元堆，每次取出最小的，并把这个最小的所在链的下一个加入堆中。