第六章:堆排序

原创 2016年05月30日 20:14:20

一:二叉堆的基本操作:

假设我们要实现的是一个最小堆:

1:插入操作

代码:

template<class Type>
void binaryHeap<Type>::insert(const Type& val)
{
        if(currentSize==array.size()-1)
                array.resize(array.size()*2);
        int hole=++currentSize;
        while(hole>1&&val<array[hole/2]){
                array[hole]=array[hole/2];
                hole/=2;
        }
        array[hole]=val;
}

2:下滤操作:

template<class Type>
void binaryHeap<Type>::percolateDown(int hole)
{
        int child;
        Type tmp=array[hole];
        while(hole*2<=currentSize){
                child=hole*2;
                if(child!=currentSize&&array[child+1]<array[child])
                        child++;
                if(array[child]<tmp){
                        array[hole]=array[child];
                        hole=child;
                }
                else break;
        }
        array[hole]=tmp;
}

3:删除最小值操作

//将堆中最小值删除,但不返回该最小值;
template<class Type>
void binaryHeap<Type>::deleteMin()
{
        if(isEmpty())
                throw underflow_error("The heap is empty?!");
        array[1]=array[currentSize--];
        percolateDown(1);
}

//将堆中最小值删除,并且返回该最小值;
template<class Type>
void binaryHeap<Type>::deleteMin(Type& min)
{
        if(isEmpty())
                throw underflow_error("The heap is empty?!");
        min=array[1];
        array[1]=array[currentSize--];
        percolateDown(1);
}

二:堆排序

堆排序顾名思义是用二叉堆对一些列元素进行排序,二叉堆用的是最大堆。代码如下:

//下滤操作:
template<class Comparable>
void percDown(vector<Comparable>& a,int i,int n)
{
        int Child;
        Comparable tmp;
        for(tmp=a[i];2*i+1<n;i=Child)
        {
                Child=2*i+1;
                if(Child!=n-1&&a[Child]<a[Child+1])
                        Child++;
                if(tmp<a[Child])
                        a[i]=a[Child];
                else break;
        }
        a[i]=tmp;
}

template<class Comparable>
void heapsort(vector<Comparable>& a)
{
        for(int i=a.size()/2;i>=0;i--)
                percDown(a,i,a.size()); //建立一个最大堆
        for(int j=a.size()-1;j>0;j--)
        {
                swap(a[0],a[j]);     //删除一个最大值
                percDown(a,0,j);   
        }
}
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

第六章堆排序之“最小优先级队列”(练习6.5-3)

用最小堆实现最小优先级队列: //返回堆中关键字最小的元素 HeapMinimum() //去掉并返回堆中关键字最小的元素 HeapExtractMin() //将堆中元素x的关键字减小到k...

算法导论第六章 堆排序

原文连接诶:http://blog.csdn.net/v_JULY_v/article/details/6198644 基本算是把算法导论的内容原版照抄。 一、堆排序算法的基本特性...

第六章 堆排序 C++

二叉堆:是一个数组,可以看成一个近似的完全二叉树。除了最低层,该树是完全满的。有两种形式:最大堆和最小堆。 堆的两个用途:排序和优先队列。 排序:若要按升序排列,则使用最大堆。 有限队列:在计算...

第六章堆排序之“删除最大堆中的指定元素HEAP-DELETE”(练习6.5-7)

题目:HEAP-DELETE(A,i)操作将节点i中的项从堆中删去。对含n个元素的最大堆,请给出时间为O(lgn)的HEAP-DELETE的实现。 编程思路: 我们可以用堆中最后一个元素a[hea...

算法导论 学习笔记 第六章 堆排序

这一章主要讲了两个点:1.堆排序。2.堆排序的应用(优先级队列)堆排序堆堆是一种完全二叉树(不理解)。反正是一种树状的数据结构了吧。有几种操作。 求左子节点(2i),求右子节点(2i+1),求父节点(...

第六章堆排序之“Young氏矩阵(Young tableau)”(思考题6-3)

这个程序是利用Young氏矩阵为n*n的数组排序。 其中涉及到:插入法建立Young氏矩阵,然后再调用”去掉返回堆顶元素”的函数得到从小到大的排列。总的时间复杂度为O(n^3)。 其中向Young...

算法导论第六章 堆排序总结

MAX-HEAPIFY(A, i) 1 l← LEFT(i) 2 r← RIGHT(i) 3 ifl≤heap-size[A] and A[l] >A[i] 4    thenlargest←l 5 ...

堆排序详细分析(算法导论第六章)

本文将介绍另一种平均时间复杂度是O(nlogn)的排序方法——堆排序(Heap Sort)。堆排序使用了一种被称为“堆”的数据结构,这也是它相比其他两种排序方法的特殊之处。堆这种数据结构不仅可以用于排...

学习《算法导论》第六章 堆排序 总结

学习《算法导论》第六章 堆排序 总结完全二叉树的概述一颗完全二叉树:树的每一层都是填满的,最后一层可能除外(最后一层是从一个结点的左子树开始填的).树的结点表示对于完全二叉树,给定一个结点的下标i,其...

算法导论第六章-堆排序

//堆排序算法,通过建立最大堆去排序,排序结果为从小到大,复杂度为O(nlogn) #include using namespace std; //数组长度 #define length 11 /...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)