【算法总结】堆及堆排序总结

【前言】

堆排序是什么？

堆排序的核心是将数组构建成为一个堆，然后从堆顶逐个逐个数字获取，堆分成最大堆（大顶堆）及最小堆（小顶堆）。

下面还是先说明什么是堆。

堆是一颗完全二叉树。---什么是完全二叉树？百度百科--完全二叉树

简而言之，一个二叉树是饱满的---即二叉树都满了，即使没有饱满，那么上一层都是饱满，最后一层叶子节点从左向右排列。

但是堆相对于完全二叉树有了自己的特点，堆分成最大堆及最小堆，

对于最大堆有：

1、根节点（堆顶）的关键字是最大（至少要大于或等于）的；

2、父亲节点必然比左右子节点都要大（至少等于）--左右节点之间没有大小之分，但是都比父亲节点少。

对于最小堆，性质类似：

1、根节点（堆顶）比所有子节点都小或等于；

2、父亲节点比左右子节点都要小或等于。

最大堆及最小堆的插入，删除，构建，取顶操作都类似，不同之处就是父亲比子节点大还是父亲比子节点小。

插入操作的要点

找到合适的节点（假如堆为满二叉树，那么合适的节点为最左侧，假如堆不满，那么合适的节点为倒数第二层的节点【注：这个节点要根据叶子节点决定，假如有倒数第二个节点有一个左子节点，那么该节点就是合适的节点，假如该倒数第二层的节点要么都有左右子节点，要么没有左右子节点，那么选取最接近的没有左右子节点的节点为合适节点】）---合适节点的选取有点麻烦但是您看多几张图片就完全明白为什么这样选取了，找到合适节点后，以合适节点为父节点，添加新节点进去（假如有左子节点，那么就添加为右子节点），添加以后必须上”浮“进行调整（所谓上浮指的是，比较父亲节点，左子节点，右子节点（假如有的话）的关键字，选取最小--或最大--取决于你操作的是最小堆或最大堆----与父亲节点更换然后递归直到根节点，详情可以查看插入操作图解）---说起来复杂，但是各位直接看图解的话会清楚很多。

删除操作的要点

任何删除的节点都是最后面的叶子节点，当前选中的节点恰好是最后面的叶子节点的话，直接删除（不需要调整结构）；假如不是，分两种情况：

A、假如需要删除的节点下面有子节点，那么：先与最后的叶子节点交换关键字，删除最后面的叶子节点，针对需要删除的节点进行下沉操作（”下沉“操作具体看图解），简单来说，对于最小堆的下沉操作是：假如当前节点有子节点，并且父亲节点至少比其中一个子节点要少，那么通过比较与合适的子节点交换关键字，然后以合适的子节点为当前节点递归下沉操作。

B、假如要删除的节点本身就是叶子节点，那么：与最后叶子节点交换关键字，删除最后叶子节点，然后针对需要删除的节点进行上浮操作，简单而言，针对于最小堆，上浮操作就是，假如该节点的关键字小于父亲节点的关键字，那么与父亲节点关键字交换后，以父亲节点作为当前节点继续递归执行上浮操作。

构建堆的要点

计算出最后边的非叶子节点，（通常根据公式节点个数n除以2得出来，大家猜一猜为什么这样计算？），假设该位置为 loc，那么我们接着从 loc到 位置1 或者0（取决于你如何定义根节点的位置）的节点分别进行下沉操作。操作完毕得到的就是堆了。请看图解。

获取堆顶的要点

将堆顶的关键字记录下来，然后根节点（堆顶）的关键字与最后的叶子节点交换，删除最后的叶子节点，然后对根节点进行下沉操作-------看，实际上就是删除根节点的过程。

堆排序的过程就是构建堆及获取堆顶的组合。

对堆的图文介绍

下面我摘抄了   最大堆的插入/删除/调整/排序操作(图解+程序)（JAVA）  的部分内容，图文并茂说明了各种操作：

 堆有最大堆和最小堆之分，最大堆就是每个节点的值都>=其左右孩子（如果有的话）值的完全二叉树。最小堆便是每个节点的值都<=其左右孩子值的完全二叉树。 

  设有n个元素的序列{k1,k2,...,kn},当且仅当满足下列关系时,称之为堆。 
 

堆的三种基本操作(以下以最大堆为例)： 

⑴最大堆的插入   （最小堆类似）

    由于需要维持完全二叉树的形态，需要先将要插入的结点x放在最底层的最右边，插入后满 足完全二叉树的特点； 
  然后把x依次向上调整到合适位置满足堆的性质,例如下图中插入80,先将80放在最后,然后两次上浮到合适位置. 
  时间：O(logn)。  “结点上浮” 
 

⑵最大堆的删除（最小堆类似） 

   操作原理是：当删除节点的数值时，原来的位置就会出现一个孔,填充这个孔的方法就是， 
把最后的叶子的值赋给该孔并下调到合适位置，最后把该叶子删除。 
  
如图中要删除72,先用堆中最后一个元素来35替换72,再将35下沉到合适位置,最后将叶子节点删除。 
　　 “结点下沉” 

 

【勘误】

大家看到上面的删除过程是不是觉得很容易明白？

我也如此认为，直到我写程序时候出现了问题才重新审视删除算法的正确性。

譬如说：现在有一个最小堆，如下图：

现在我选中了93，并且要删除它，接下来会发生什么事？

接下来就是这个算法的结果了：

对，当节点没有空间下沉的时候它就会无所事事，结果导致不对了。

这种情况下面我们可以借用插入过程的上浮调整方式，从最下面开始向上调整。

⑶堆的初始化---堆得构建 

方法1：插入法： 
  从空堆开始，依次插入每一个结点，直到所有的结点全部插入到堆为止。 
  时间：O(n*log(n)) 
  方法2：调整法： 
    序列对应一个完全二叉树；从最后一个分支结点（n div 2）开始，到根（1）为止，依次对每个分支结点进行调整（下沉），
以便形成以每个分支结点为根的堆，当最后对树根结点进行调整后，整个树就变成了一个堆。 
  时间：O(n) 
对如图的序列,要使其成为堆,我们从最后一个分支结点(10/2),其值为72开始,依次对每个分支节点53,18,36 45进行调整(下沉). 
 
 
 

【补充说明】

如何获取相应数组序列？

方法是依次将堆的根节点的小数记下，然后删除根节点，如此反复直到堆为空。上面提到了删除操作，每次删除之后都是要调整堆让堆的性质不变，即根节点必为最大值或最小值，明白了吗？

下面将演示堆的相关操作

【插入关键字18,17,15,19】

【插入关键字16,12,21】

【插入关键字27】

【插入关键字13】

【插入关键字11】

插入操作都大同小异。

然后进行删除操作：

【删除关键字11】

【删除关键字16】

【删除关键字13】

【删除关键字17】

【删除关键字21】

ok，我们输入数组进去，然后构建一个最小堆：

构建完毕后，我们逐个逐个数读取，形成排序完毕的数组（都从根节点开始读，每读一个根节点就删除一个根节点，调整树形结构，直到空）：

 堆有最大堆和最小堆之分，最大堆就是每个节点的值都>=其左右孩子（如果有的话）值的完全二叉树。最小堆便是每个节点的值都<=其左右孩子值的完全二叉树。 

  设有n个元素的序列{k1,k2,...,kn},当且仅当满足下列关系时,称之为堆。 
 

堆的三种基本操作(以下以最大堆为例)： 
⑴最大堆的插入   

    由于需要维持完全二叉树的形态，需要先将要插入的结点x放在最底层的最右边，插入后满 足完全二叉树的特点； 
  然后把x依次向上调整到合适位置满足堆的性质,例如下图中插入80,先将80放在最后,然后两次上浮到合适位置. 
  时间：O(logn)。  “结点上浮” 
 

程序实现: 

 //向最大堆中插入元素, heap:存放堆元素的数组    public static void insert(List<Integer> heap, int value) {        //在数组的尾部添加        if(heap.size()==0)          heap.add(0);//数组下标为0的位置不放元素        heap.add(value);         //开始上升操作        // heapUp2(heap, heap.size() - 1);         heapUp(heap, heap.size() - 1);      }      //上升，让插入的数和父节点的数值比较，当大于父节点的时候就和父节点的值相交换     public static void heapUp(List<Integer> heap, int index) {          //注意由于数值是从下标为1开始，当index = 1的时候，已经是根节点了         if (index > 1) {             //求出父亲的节点             int parent = index / 2;              //获取相应位置的数值             int parentValue = (Integer) heap.get(parent);             int indexValue = (Integer) heap.get(index);             //如果父亲节点比index的数值小，就交换二者的数值             if (parentValue < indexValue) {                 //交换数值                 swap(heap, parent, index);                 //递归调用                 heapUp(heap, parent);             }          }     } 

⑵删除 
   操作原理是：当删除节点的数值时，原来的位置就会出现一个孔,填充这个孔的方法就是， 
把最后的叶子的值赋给该孔并下调到合适位置，最后把该叶子删除。 
  
如图中要删除72,先用堆中最后一个元素来35替换72,再将35下沉到合适位置,最后将叶子节点删除。 
　　 “结点下沉” 

 

程序: /**     * 删除堆中位置是index处的节点     * 操作原理是：当删除节点的数值时，原来的位置就会出现一个孔     * 填充这个孔的方法就是，把最后的叶子的值赋给该孔，最后把该叶子删除     * @param heap      */     public static void delete(List<Integer> heap,int index) {         //把最后的一个叶子的数值赋值给index位置         heap.set(index, heap.get(heap.size() - 1));         //下沉操作         //heapDown2(heap, index);         heapDown(heap, index);         //把最后一个位置的数字删除         heap.remove(heap.size() - 1);     }     /**     * 递归实现     * 删除堆中一个数据的时候，根据堆的性质，应该把相应的位置下移，才能保持住堆性质不变     * @param heap 保持堆元素的数组     * @param index 被删除的那个节点的位置     */     public static void heapDown(List<Integer> heap, int index) {         //因为第一个位置存储的是空值，不在考虑之内         int n = heap.size() - 2;          //记录最大的那个儿子节点的位置         int child = -1;          //2*index>n说明该节点没有左右儿子节点了，那么就返回         if (2 * index > n) {             return;         } //如果左右儿子都存在         else if (2 * index < n) {              //定义左儿子节点             child = 2 * index;             //如果左儿子小于右儿子的数值，取右儿子的下标             if ((Integer) heap.get(child) < (Integer) heap.get(child + 1)) {                 child++;             }          }//如果只有一个儿子（左儿子节点）         else if (2 * index == n) {             child = 2 * index;         }          if ((Integer) heap.get(child) > (Integer) heap.get(index)) {             //交换堆中的child，和index位置的值             swap(heap, child, index);              //完成交换后递归调用，继续下降             heapDown(heap, child);         }     }  

⑶初始化 
方法1：插入法： 
  从空堆开始，依次插入每一个结点，直到所有的结点全部插入到堆为止。 
  时间：O(n*log(n)) 
  方法2：调整法： 
    序列对应一个完全二叉树；从最后一个分支结点（n div 2）开始，到根（1）为止，依次对每个分支结点进行调整（下沉），
以便形成以每个分支结点为根的堆，当最后对树根结点进行调整后，整个树就变成了一个堆。 
  时间：O(n) 
对如图的序列,要使其成为堆,我们从最后一个分支结点(10/2),其值为72开始,依次对每个分支节点53,18,36 45进行调整(下沉). 
 
 
 

程序:     /*根据树的性质建堆，树节点前一半一定是分支节点，即有孩子的，所以我们从这里开始调整出初始堆*/       public static void adjust(List<Integer> heap){        for (int i = heap.size() / 2; i > 0; i--)              adjust(heap,i, heap.size()-1);                    System.out.println("=================================================");        System.out.println("调整后的初始堆：");          print(heap);      }    /**      * 调整堆，使其满足堆得定义      * @param i      * @param n      */      public static void adjust(List<Integer> heap,int i, int n) {                 int child;          for (; i <= n / 2; ) {              child = i * 2;              if(child+1<=n&&heap.get(child)<heap.get(child+1))                  child+=1;/*使child指向值较大的孩子*/              if(heap.get(i)< heap.get(child)){                  swap(heap,i, child);                  /*交换后，以child为根的子树不一定满足堆定义，所以从child处开始调整*/                  i = child;                             }  else break;        }      }  

(4)最大堆排序  

 //对一个最大堆heap排序    public static void heapSort(List<Integer> heap) {                 for (int i = heap.size()-1; i > 0; i--) {           /*把根节点跟最后一个元素交换位置，调整剩下的n-1个节点，即可排好序*/              swap(heap,1, i);              adjust(heap,1, i - 1);          }      }  

(5)完整的代码 

import java.util.*;  /** *实现的最大堆的插入和删除操作 * @author Arthur */ public class Heap {      /**     * 删除堆中位置是index处的值     * 操作原理是：当删除节点的数值时，原来的位置就会出现一个孔     * 填充这个孔的方法就是，把最后的叶子的值赋给该孔，最后把该叶子删除     * @param heap 一个最大堆     */     public static void delete(List<Integer> heap,int index) {         //把最后的一个叶子的数值赋值给index位置         heap.set(index, heap.get(heap.size() - 1));         //下沉操作         //heapDown2(heap, index);         heapDown(heap, index); //节点下沉        //把最后一个位置的数字删除         heap.remove(heap.size() - 1);     }       /**      * 节点下沉递归实现     * 删除一个堆中一个数据的时候，根据堆的性质，应该把相应的位置下移，才能保持住堆性质不变     * @param heap 保持最大堆元素的数组     * @param index 被删除的那个节点的位置     */     public static void heapDown(List<Integer> heap, int index) {         //因为第一个位置存储的是空值，不在考虑之内         int n = heap.size() - 2;          //记录最大的那个儿子节点的位置         int child = -1;          //2*index>n说明该节点没有左右儿子节点了，那么就返回         if (2 * index > n) {             return;         } //如果左右儿子都存在         else if (2 * index < n) {              //定义左儿子节点             child = 2 * index;             //如果左儿子小于右儿子的数值，取右儿子的下标             if ((Integer) heap.get(child) < (Integer) heap.get(child + 1)) {                 child++;             }          }//如果只有一个儿子（左儿子节点）         else if (2 * index == n) {             child = 2 * index;         }          if ((Integer) heap.get(child) > (Integer) heap.get(index)) {             //交换堆中的child，和index位置的值             swap(heap, child, index);              //完成交换后递归调用，继续下降             heapDown(heap, child);         }     }      //非递归实现     public static void heapDown2(List<Integer> heap, int index) {         int child = 0;//存储左儿子的位置          int temp = (Integer) heap.get(index);         int n = heap.size() - 2;         //如果有儿子的话         for (; 2 * index <= n; index = child) {             //获取左儿子的位置             child = 2 * index;             //如果只有左儿子             if (child == n) {                 child = 2 * index;             } //如果右儿子比左儿子的数值大             else if ((Integer) heap.get(child) < (Integer) heap.get(child + 1)) {                 child++;             }              //如果数值最大的儿子比temp的值大             if ((Integer) heap.get(child) >temp) {                 //交换堆中的child，和index位置的值                 swap(heap, child, index);             } else {                 break;             }         }     }           //打印链表     public static void print(List<Integer> list) {         for (int i = 1; i < list.size(); i++) {             System.out.print(list.get(i) + " ");         }         System.out.println();    }      //把堆中的a,b位置的值互换     public static void swap(List<Integer> heap, int a, int b) {         //临时存储child位置的值         int temp = (Integer) heap.get(a);          //把index的值赋给child的位置         heap.set(a, heap.get(b));          //把原来的child位置的数值赋值给index位置         heap.set(b, temp);     }      //向最大堆中插入元素     public static void insert(List<Integer> heap, int value) {            //在数组的尾部添加要插入的元素        if(heap.size()==0)          heap.add(0);//数组下标为0的位置不放元素        heap.add(value);         //开始上升操作        // heapUp2(heap, heap.size() - 1);         heapUp(heap, heap.size() - 1);      }      //节点上浮，让插入的数和父节点的数值比较，当大于父节点的时候就和节点的值相交换     public static void heapUp(List<Integer> heap, int index) {          //注意由于数值是从小标为一开始，当index = 1的时候，已经是根节点了         if (index > 1) {             //保存父亲的节点             int parent = index / 2;              //获取相应位置的数值             int parentValue = (Integer) heap.get(parent);             int indexValue = (Integer) heap.get(index);             //如果父亲节点比index的数值小，就交换二者的数值             if (parentValue < indexValue) {                 //交换数值                 swap(heap, parent, index);                 //递归调用                 heapUp(heap, parent);             }          }     }      //非递归实现     public static void heapUp2(List<Integer> heap, int index) {         int parent = 0;         for (; index > 1; index /= 2) {             //获取index的父节点的下标             parent = index / 2;              //获得父节点的值             int parentValue = (Integer) heap.get(parent);             //获得index位置的值             int indexValue = (Integer) heap.get(index);                          //如果小于就交换             if (parentValue < indexValue) {                 swap(heap, parent, index);             }         }     }      /*根据树的性质建堆，树节点前一半一定是分支节点，即有孩子的，所以我们从这里开始调整出初始堆*/       public static void adjust(List<Integer> heap){        for (int i = heap.size() / 2; i > 0; i--)              adjust(heap,i, heap.size()-1);                    System.out.println("=================================================");        System.out.println("调整后的初始堆：");          print(heap);      }    /**      * 调整堆，使其满足堆得定义      * @param i      * @param n      */      public static void adjust(List<Integer> heap,int i, int n) {                 int child;          for (; i <= n / 2; ) {              child = i * 2;              if(child+1<=n&&heap.get(child)<heap.get(child+1))                  child+=1;/*使child指向值较大的孩子*/              if(heap.get(i)< heap.get(child)){                  swap(heap,i, child);                  /*交换后，以child为根的子树不一定满足堆定义，所以从child处开始调整*/                  i = child;                             }  else break;        }      }       //对一个最大堆heap排序    public static void heapSort(List<Integer> heap) {                 for (int i = heap.size()-1; i > 0; i--) {          /*把根节点跟最后一个元素交换位置，调整剩下的n-1个节点，即可排好序*/              swap(heap,1, i);              adjust(heap,1, i - 1);          }      }     public static void main(String args[]) {         List<Integer> array = new ArrayList<Integer>(Arrays.asList(null, 1, 2, 5, 10, 3, 7, 11, 15, 17, 20, 9, 15, 8, 16));        adjust(array);//调整使array成为最大堆               delete(array,8);//堆中删除下标是8的元素        System.out.println("删除后");        print(array);        insert(array, 99);//堆中插入        print(array);         heapSort(array);//排序        System.out.println("将堆排序后:");        print(array);        System.out.println("-------------------------");        List<Integer> array1=new ArrayList<Integer>();        insert(array1,0);        insert(array1, 1);insert(array1, 2);insert(array1, 5);        insert(array1, 10);insert(array1, 3);insert(array1, 7);        insert(array1, 11);insert(array1, 15); insert(array1, 17);        insert(array1, 20);insert(array1, 9);        insert(array1, 15);insert(array1, 8);insert(array1, 16);        print(array1);                System.out.println("==============================");        array=new ArrayList<Integer>(Arrays.asList(null,45,36,18,53,72,30,48,93,15,35));        adjust(array);          insert(array, 80);//堆中插入          print(array);         delete(array,2);//堆中删除80的元素         print(array);         delete(array,2);//堆中删除72的元素         print(array);                  } } 

程序运行: 
D:\java>java   Heap 
================================================= 
调整后的初始堆： 
20 17 16 15 9 15 11 1 10 3 2 7 8 5 
删除后 
20 17 16 15 9 15 11 5 10 3 2 7 8 
99 17 20 15 9 15 16 5 10 3 2 7 8 11 
将堆排序后: 
2 3 5 7 8 9 10 11 15 15 16 17 20 99 
------------------------- 
20 17 16 10 15 9 15 0 5 2 11 1 7 3 8 
============================== 
================================================= 
调整后的初始堆： 
93 72 48 53 45 30 18 36 15 35 
93 80 48 53 72 30 18 36 15 35 45 
93 72 48 53 45 30 18 36 15 35 
93 53 48 36 45 30 18 35 15