算法笔记五：利用堆结构来对数据进行排序

算法思想：
//将数组build成最大堆格式，这样，数组的第一个元素一定是最大的
//有了这个前提，就可以从后往前迭代：将最后一个元素与第一个元素交换，这样最大值就排到了最后面
//然后对第一个元素开头的堆结构进行重建堆，使其依然满足第一个元素为最大的元素

//关键就在于建堆的逻辑

//堆数据结构：给定一个节点的下标i，其左子节点的位置为2*i+1(i右移一位+1),右子节点的位置为2*i加2(右移一位+2)
//最大堆：父节点的值data[i]一定不小于子节点的值
//涉及的几个操作：

//堆调整：给定一个节点，假设其左子节树和右子树都满足最大堆的性质，那么，如果当前节点和左右子节点不满足堆性质，就要进行调整，调整时，要么和左子节点进行交换，要么和右子节点进行交换
//一旦发生交换后，就会破坏被交换的那个子节点的堆性质，然后需要做的就是递归对子节点进行同样的堆调整操作

//建堆：这里，我们可以利用堆调整的操作，自底而上的构建堆，由子节点位置的计算公式可以得出，数组的n/2处，后面的一定都是叶子节点，所以我们从n/2处开始往回走，直到第一个元素，对这些每个非叶子节点，自下而上的进行堆性质维护，因为自下而上，所以每次都满足我们建堆的假设条件：左右子树都满足堆的性质，所以最终就完成了整个堆的构建

//有了堆，排序就好办，数组的第一个元素是最大的，将他和数组的最后一个元素调换，这样最大的就放到最后去了，然后对堆的根节点重新进行调整

//其他的几个操作：

//增大一个节点的值：因为是增大该节点，所以，其节点本身的堆属性并不会受影响
//而唯一需要做的就是，连续向上和父节点进行比较，如果比父节点大，则交换，直到其比父节点的值要小

//插入一个节点
//也很简单，先扩容，然后插入一个无穷小的值到最后，这时候一定是不违反堆性质的，然后执行上面的增大值的操作将这个无穷大的值增大到实际值即可

//其实就是扩容-->赋值-->执行该节点的增大操作

这里的一个问题就是，其是对原有问题的分解，不属于分治思想，但我们依然可以分析其执行的代价：
整个排序由两部分组成：
1、建堆
2、取最大值(取完之后又要对未取完的数据进行建堆)
其中，取最大值的代价，就是两个元素进行交换的代价，是一个常量值，而且最多执行n次，所以我们可以忽略它
所以，其根本还是取决于建堆的代价

堆调整：其执行的次数，最大值就是要调整树的高度的次数，其值等于lgn = h(树的高度)

建堆：假定每个要调整的子树，其最坏调整代价都是lgn(除根节点处的所有子树，都会小于这个值),
那么一共会有少于总数n的有限个子树需要调整，总代价为n*lgn ，这里的数学公式比较的复杂，但是可以告诉大家其答案为n，也就是不会超过整棵树的元素的个数，读者可以多画几棵树来实际推测验证下。

取最大值：最大值，是遍历数组最后一个元素，与第一个元素交换，然后再重建调整堆，直到交换到数组只剩2个元素，所以，一共的交换的次数为n-1,而每次交换后的调整堆的代价最坏也就是lgN，所以总代价就是(n-1)*lgn,再加上我们前面分析的建堆的代价为lgn,得出最坏的代价为(n-1)*lgn + n

结论：其最坏的代价为(n-1)*lgn + n（这里教科书上将其渐进的等于nlgn）

空间代价：
空间上只有在调整堆时，对两个元素交换使用了一个临时存储空间，所以空间代价还是非常小的

算法实现：

#ifndef __p1__HeapSortV2__
#define __p1__HeapSortV2__

#include <stdio.h>

//将数组build成最大堆格式，这样，数组的第一个元素一定是最大的
//有了这个前提，就可以从后往前迭代：将最后一个元素与第一个元素交换，这样最大值就排到了最后面
//然后对第一个元素开头的堆结构进行重建堆，使其依然满足第一个元素为最大的元素

//关键就在于建堆的逻辑

//堆数据结构：给定一个节点的下标i，其左子节点的位置为2*i+1(i右移一位+1),右子节点的位置为2*i加2(右移一位+2)
//最大堆：父节点的值data[i]一定不小于子节点的值
//涉及的几个操作：

//堆调整：给定一个节点，假设其左子节树和右子树都满足最大堆的性质，那么，如果当前节点和左右子节点不满足堆性质，就要进行调整，调整时，要么和左子节点进行交换，要么和右子节点进行交换
//一旦发生交换后，就会破坏被交换的那个子节点的堆性质，然后需要做的就是递归对子节点进行同样的堆调整操作

//建堆：这里，我们可以利用堆调整的操作，自底而上的构建堆，由子节点位置的计算公式可以得出，数组的n/2处，后面的一定都是叶子节点，所以我们从n/2处开始往回走，直到第一个元素，对这些每个非叶子节点，自下而上的进行堆性质维护，因为自下而上，所以每次都满足我们建堆的假设条件：左右子树都满足堆的性质，所以最终就完成了整个堆的构建

//有了堆，排序就好办，数组的第一个元素是最大的，将他和数组的最后一个元素调换，这样最大的就放到最后去了，然后对堆的根节点重新进行调整

//其他的几个操作：

//增大一个节点的值：因为是增大该节点，所以，其节点本身的堆属性并不会受影响
//而唯一需要做的就是，连续向上和父节点进行比较，如果比父节点大，则交换，直到其比父节点的值要小

//插入一个节点
//也很简单，先扩容，然后插入一个无穷小的值到最后，这时候一定是不违反堆性质的，然后执行上面的增大值的操作将这个无穷大的值增大到实际值即可
//其实就是扩容-->赋值-->执行该节点的增大操作

class HeapSortV2 {

public:
//获取父节点
int getParentNode(int i){
return ( i - 1 ) >> 1;
}
//获取左子节点
int getLeftChildNode(int i){
return (i << 1) + 1;
}
//获取右子节点
int getRightChildNode(int i){
return (i << 1) + 2;
}

void changeTwoItems(int * data,int i,int j){
int tmp = *(data + i);
*(data + i) = *(data + j);
*(data + j) = tmp;
}

//求父节点和两个子节点的最大的那个节点
int getLargestNode(int * data,int node,int size){
int leftNode = getLeftChildNode(node);
int rightNode = getRightChildNode(node);

//node没有左子节点
if(leftNode >= size){
return node;
}
//有左子树，没有右子树
if(rightNode >= size){
if(*(data + node) >= *(data + leftNode)){
return node;
}else{
return leftNode;
}
}

//左子树和右子树都有，则求哪个节点是最大的节点
int largsetNode = node;
if(*(data + node) >= *(data + leftNode)){
if(*(data + node) >= *(data + rightNode)){
largsetNode = node;
}else{
largsetNode = rightNode;
}
}else{
if(*(data + leftNode) >= *(data + rightNode)){
largsetNode = leftNode;
}else{
largsetNode = rightNode;
}
}
return largsetNode;
}

//调整给定节点的堆的性质，假定其左子树和右子树都已经满足堆的性质
void adjustHeap(int * data,int node,int size){
//求得最大的节点
int largsetNode = getLargestNode(data,node,size);
if(largsetNode != node){
//交换
changeTwoItems(data,node,largsetNode);
//继续调整那个被改变了的节点
adjustHeap(data,largsetNode,size);
}

}

//将数组build成最大堆
void buildHeap(int * data,int size){
int middle = size / 2 ;
for (; middle >=0 ; middle--) {
adjustHeap(data,middle,size);
}
}

//增大一个节点的值
void increaseNode(int * data,int node){
if(node == 0){
return;
}
int parentNode = getParentNode(node);
if(*(data + node) > *(data + parentNode)){
changeTwoItems(data,node,parentNode);
increaseNode(data, parentNode);
}
}
//增大一个节点的值
void increateNodeValue(int * data,int node,int newValue){
*(data + node) = newValue;
increaseNode(data, node);
}

//执行堆排序
void sortByHeap(int * data,int size){
//建堆
buildHeap(data,size);

//增大值的测试：第80个元素的值增大1002
increateNodeValue(data,8,*(data + 8) + 1002);

//有了堆，排序就好办，数组的第一个元素是最大的，将他和数组的最后一个元素调换，这样最大的就放到最后去了，然后对堆的根节点重新进行调整
for (int i= size -1; i>0; i--) {
changeTwoItems(data,i,0);
adjustHeap(data,0,i );
}
}

//排序入口
void do_sorting(int * data,int size){
sortByHeap(data, size);
}

};

#endif /* defined(__p1__HeapSortV2__) */

算法总结：
时间代价表现优异，n + n*lgn
空间代价上，仅仅在需要进行调整时，开辟一个用来存储两个元素交换的临时的一个存储空间，代价非常小。
还有一个结论就是，在一个已经建好的堆上执行所有的优先级队列的操作，其时间代价均为lgn！比如：取出一个最大值，插入一个值，调整一个值的大小==