堆排序的简单实现

Posted 2020-09-05 zhangoliver

堆排序是排序的一种，一般有大根对和小根堆之说，大根对，根节点的值比左右子树的根节点的值要大。建堆我们一般是一个完全二叉树。堆排序一般面向数据量比较大的时候，数据量比较小的时候，不适合使用堆排序，比如有种情况就是topN算法的实现，一般都是借助于一个大根对来实现，扫描海量数据，把海量数据中的把最大的前N个数据放到堆中。下面实现的时候，为了简单起见，使用的数组存储二叉树，也就是一个顺序树，这个例子不仅是回顾了堆排序的内容，还回顾了二叉树的一些相关操作。

完全二叉树的一些性质，根节点root为1，总的节点的个数为n，则第一个非叶节点是第[n/2]个节点。在顺序书中，节点i的左孩子应当是2*i，右孩子为2*i+1。

堆排序，首先要做的是先建一个初始堆，假设待排序的数据是10个，那么存储二叉树的就是用一个arr[10]的数组

（1）初始堆，这里是大根堆。从[n/2]的位置开始按照大根对的原则开始调整，一直调整到根节点。于是便得到了初始大根堆

（2）大根堆顶端的根节点一定是最大的元素。接下来我们通过n-1次进行排序。i = 0; i < n-1,每次先把root和arr[n-i+1]进行交换，然后把arr[n-i+1]从书上面断开，然后从上往下进行调整。直接看代码。

 1 /**
 2      * 按照大（小）根堆的规则，从上到下来调整堆  递归实现
 3      * @param i        当前子树根节点在顺序树中的数组索引
 4      * @param heap    表示堆的二叉树 其实就是一个顺序数组
 5      * @param end    标志这个二叉树的最后一个节点的索引位置
 6      */
 7     public static void upToDown(int i, int[] heap, int end){
 8         int left = i*2+1;            //左孩子的索引
 9         int right = left + 1;        //右孩子的索引
10         
11         if(right <= end)// 左右孩子都不空
12         {
13             int pos = heap[left]>heap[right]?left:right;
14             if(heap[pos] > heap[i])
15             {
16                 int tmp = heap[i];
17                 heap[i] = heap[pos];
18                 heap[pos] = tmp;
19             }
20             upToDown(left, heap, end);
21             upToDown(right, heap, end);
22         }else{
23             if(left > end)
24                 return;
25             else{
26                 if(heap[left] > heap[i])
27                 {
28                     int tmp = heap[i];
29                     heap[i] = heap[left];
30                     heap[left] = tmp;
31                 }
32                 upToDown(left, heap, end);
33             }
34         }
35     }

接着，创建初始堆：

1 /**
2      * 穿件初始堆
3      * @param heap    堆对应的存储数组
4      */
5     public static void createHeap(int[] heap) {
6         for(int i = heap.length/2-1; i >=0; i--)
7             upToDown(i, heap, heap.length - 1);
8     }

进行堆排序：

 1 /*
 2      * 使用数组简单的模拟堆排序
 3      */
 4     public static void heapSort(int[] heap){
 5         
 6         for(int i = 0; i < heap.length - 1; i++)
 7         {
 8             int tmp = heap[0];
 9             int end = heap.length-i-1;
10             heap[0] = heap[end];
11             heap[end] = tmp;
12             upToDown(0, heap, end-1);14         }
15     }

经过上面的排序，对中的元素就是有序的了，然后按照顺序疏忽堆数组即可。

下面的操作都是和树相关的操作，主要包括求书的节点数，求树的高度，树的递归遍历和非递归遍历。最后是画一个简图作为例子。

（1）求树的叶节点的个数，思路：左子树节点数+右子树节点数+1.

 1 /**
 2      * 递归求树的高度
 3      * @param heap    存储树的数组
 4      * @param root    根节点
 5      * @return        返回树的高度。
 6      */
 7     public static int getNode(int[] heap, int root)
 8     {//递归求树的节点个数（左子树节点个数+右子树节点个数+根节点个数）
 9         int left = root*2+1;
10         int right = left +1;
11         int end = heap.length - 1;        //当前树的最后一个元素的索引
12         
13         if(root > end)
14             return 0;
15         if(left>end && right >end)
16             return 1;
17         return getNode(heap, left) + getNode(heap, right) + 1;
18     }

（2）求树的高度，思路：max(左子树的高度，右子树的高度)+1

 1 public static int getHeight(int[] heap, int root)
 2     {// 左子树 和 右子树中 高度较大的一个 再加1
 3         int left = root*2+1;
 4         int right = left +1;
 5         int end = heap.length - 1;
 6         
 7         
 8         if(root > end) return 0;
 9         
10         if(left>end && right >end)
11             return 1;
12         
13         return Math.max(getHeight(heap, left), getHeight(heap, right)) + 1;
14     }

（3）树的递归遍历，先根序，中根序，后根序便利都很相似，这里就只写一下先根序递归遍历的代码

 1 public static void preTransverse(int[] heap, int i){
 2         int left = i*2+1;
 3         int right = left +1;
 4         
 5         if (i > heap.length - 1)
 6             return;
 7         System.out.print(heap[i]+",");
 8         preTransverse(heap, left);
 9         preTransverse(heap, right);
10     }

preTransverse(heap, left)和preTransverse(heap, right)的放置的位置，主要决定了是先中后的遍历顺序。

　　非递归，遍历一个二叉树，这里面就要使用栈数据结构。当然，非递归的遍历，也可以分为先序、中序和后序，思路相同，这里这记录借助栈的非递归先序遍历二叉树。树结构其实就是图的一种特例，而二叉树无疑又是一种更为特别的图，二叉树的先序遍历其实就相当于是图图的深度优先DFS遍历。非递归的二叉树线序遍历的思想很简单：

（1）当前节点root是否为空，不空的话访问之，并将该节点入栈，并取得当前节点的左孩子p = p*2+1,顺序存储二叉树，二叉树的根节点索引为0

（2）若当前访问的节点是一个空节点，那么弹出栈顶元素p = stack[--cn],并获取其右孩子，p = p*2+2。

（3）重复循环（1）（2）知道访问玩所有的节点，或者栈为空

 1 /**
 2      * 非递归现需便利一个二叉树  使用栈
 3      * @param heap
 4      */
 5     public static void prePrint(int[] heap)
 6     {
 7         int height = getHeight(heap, 0);
 8         int[] stack = new int[height];
 9         int p = 0;
10         int cn = 0;
11         int end = heap.length - 1;
12         
13         while(p<=end || cn!=0){
14             if(p <= end)
15             {
16                 System.out.print(heap[p]+",");
17                 stack[cn++] = p;    // lft child
18                 p = p*2+1;
19             }
20             else{
21                 p = stack[--cn];
22                 p = p*2+2;    //right child
23             }
24         }
25     }

借助队列，分层遍历二叉树。思想也很简单：

（1）首先根节点入队

（2）队列出队的时候就访问之，并且把被访问的这个元素的孩子节点一次入队

（3）重复上面两部操作，知道队列为空的时候结束。

 1 // 非递归  分层便利 借助于队列
 2     public static void broadTranverse(int[] heap)
 3     {
 4         LinkedList<Integer> que = new LinkedList<Integer>();
 5         int end = heap.length - 1;
 6         
 7         que.offer(0);
 8         while(que.isEmpty()==false)
 9         {
10             int p = que.poll();
11             System.out.print(heap[p]+",");
12             int left = p*2+1;
13             int right = left +1;
14             if(left <= end) que.offer(left);
15             if(right <=end) que.offer(right);
16         }
17     }