首页 > 程序开发 > 软件开发 > 其他 >

【编程珠玑】第十四章:堆(排序,优先级队列)

2012-05-25

一,堆 1)堆:任何结点的值都小于或等于其孩子的值的完全二叉树为小根堆 任何结点的值都大于或等于其孩子的值的完全二叉树为大根堆 为了方便使用完全二叉树的性质,数组从下标1开始。 这样:leftChild = ...

一,堆
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)怎么办? 采用向上调整堆的策略。详细见下文优先队列。
4)源码
[html]
#include"stdio.h"
inline void swap(int &a,int &b)
{
int temp=a;
a=b;
b=temp;

}
void HeapAdjust(int array[],int i,int nLength)//自顶向下调整堆
{
int nChild;
int nTemp;//赋值为待调整的 节点

for(nTemp=array[i];2*i<nLength;i=nChild)//2*i<nLength说明还有左孩子
{
nChild=2*i;//左孩子

/*一共两个子节点的话得到 较大的一个*/
if(nChild<nLength-1&&array[nChild+1]>array[nChild])//nChild<nLength-1 判断到头没有
++nChild;

/*如果较大子节点大于父节点 将子节点 调整到父节点*/
if(nTemp<array[nChild])
array[i]=array[nChild];
else
break;//这个地方不加 会出错 第一个会输出第二个

array[nChild]=nTemp;//子节点 等于父节点 (不执行break)
}
}
void HeapSort(int a[],int length)
{
/*初建堆 */
for(int i=length/2;i>0;--i)//从最后一个 非叶子节点调整 (这里的 i是下标)
HeapAdjust(a,i,length);

for(int i=length;i>1;--i)
{
swap(a[1],a[i]); /*第一个最大元素跟最后一个交换*/

HeapAdjust(a,1,i);//调整堆 (注意 length=i 由于堆是逐渐变小的)
}

}
int main()
{
int a[10]={0,1,2,5,3,8,4,7,6};
HeapSort(a,8);

for(int i=1;i<9;i++)
printf("%d\n",a[i]);
return 0;
}


二,优先队列
1)优先队列是0个或多个元素的集合,每个元素都有一个优先权或值,对优先队列执行的操作有1) 查找; 2) 插入一个新元素; 3) 删除.
在最小优先队列(min priorityq u e u e)中,查找操作用来搜索优先权最小的元素,删除操作用来删除该元素;
对于最大优先队列(max priority queue),查找操作用来搜索优先权最大的元素,删除操作用来删除该元素.
优先权队列中的元素可以有相同的优先权,查找与删除操作可根据任意优先权进行.

2)优先队列实现
初始化一个数组,向空数组依次插入元素,每插入一个元素向上调整一次堆。
删除元素,将第一个元素跟最后一个元素交换,并向下调整堆

3)代码实现
[html]
#include <iostream>
using namespace std;


template<class T>

class priqueue {
private:
int n, maxsize;
T *x;
void swap(int &i, int &j)//根据坐标交换数组元素的值
{ T t = i; i = j; j = t; }
public:
priqueue(int m)//初始化数组
{ maxsize = m;
x = new T[maxsize+1];
n = 0;
}

void insert(T t)
{ int i, p;
x[++n] = t; //插入的元素放到最后
for (i = n; i > 1 && x[p=i/2] > x[i]; i = p)
swap(x[p], x[i]);

}

T extractmin()//向下调整堆
{
int i, c;
T t = x[1];
x[1] = x[n--];

for (i = 1; (c=2*i) <= n; i = c) {
if (c+1<=n && x[c+1]<x[c])
c++;
if (x[i] <= x[c])
break;
swap(x[c], x[i]);
}

return t;
}
void print(int n)
{
for (int i = 1; i < n; i++) //输出堆
cout << x[i] << " ";
}

};

template<class T>
void pqsort(T v[], int n)//先初始化一个数组,然后插入建立一个堆
{ priqueue<T> pq(n);
int i;
for (i = 0; i < n; i++)

pq.insert(v[i]);

cout<<"输出排序后的堆:";
pq.print(n);
}


int main()
{ const int n = 10;
int i, v[n];

/*以下是通过向上调整堆 建立一个10个元素的堆*/
for (i = 0; i < n; i++)
v[i] = n-i;
pqsort(v, n);




cout<<"\n执行插入和删除操作(输入0代表删除最小值,输入其他代表插入)"<<endl;
priqueue<int> pq(100);
int count=0;
while (cin >> i)
if (i == 0)
{
if(count)
cout <<"删除的最小元素为:"<<pq.extractmin() << "\n";
else
cout<<"请先插入元素"<<endl;
}

else
{
pq.insert(i);
count++;
}


return 0;
}


三,习题
1)为了提高向上调整堆的速度,在x[0] 放置哨兵=当前插入的元素。省去了每次都判断 i>1
向上调整堆结束:x[p] <= x[i]

[html]
void insert(T t) //向上调整堆
{ int i, p;
x[++n] = t; //插入的元素放到最后

x[0]=t;

for (i = n; x[p=i/2] > x[i]; i = p)
swap(x[p], x[i]);

}

4)a.构造哈夫曼树时候,需要选取当前数组的两个最小值,删除两个最小值,并将计算之和插入原来数组。
采用堆,初建堆,两次调用选取最小值的函数。计算之和之后,调用插入堆并调整堆

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

c.典型的topK

d.将所有小文件 要插入的当前值组成一个堆。
取堆最小值,插入排序数组。调整堆。然后插入该小文件下一个元素(无后继则不操作)

5)剩余容量组成堆,权值升序插入堆

6)求指教(没看懂)

7)求指教(没看懂)


摘自 小田的专栏

相关文章
最新文章
热点推荐