java - 算法 - 大顶堆、小顶堆 排序

java - 算法 - 大顶堆、小顶堆 排序

一、完全二叉树的数组表示形式特性
最后一个父节点下标为 (len/2)-1
若当前节点的下标为i
 父节点的下标为      (i-1)/2
 左子节点的下标为    (i*2)+1 或 (i<<1)+1
 右子节点的下标为    (i*2)+2 或 (i<<1)+2
排序后特性
 大顶堆，排序后为正序；
 小顶堆，排序后为倒序；

二、运行结果

arr
	1	0	2	9	3	8	4	7	5	6	
maxHeap
	9	7	8	5	6	2	4	0	1	3	
父节点 [左子树，右子树]
	9 [7,8]
	7 [5,6]
	8 [2,4]
	5 [0,1]
	6 [3,x]
sort
	0	1	2	3	4	5	6	7	8	9	
minHeap
	0	1	2	5	3	8	4	7	9	6	
sort
	9	8	7	6	5	4	3	2	1	0	
父节点 [左子树，右子树]
	9 [8,7]
	8 [6,5]
	7 [4,3]
	6 [2,1]
	5 [0,x]
xxx

Process finished with exit code 0 

三、排序代码

package algorithm;

import utils.TeachBase;

import java.text.MessageFormat;

public class MaxHeap extends TeachBase {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 0, 2, 9, 3, 8, 4, 7, 5, 6};
        print("arr", arr);
        //初始化大顶堆
        Heap max = new Heap(arr);
        max.maxHeapInit();
        print("maxHeap", max.data);
        max.printTree();
        max.maxHeapSort();
        print("sort", max.data);
        //初始化小顶堆
        Heap min = new Heap(arr);
        min.minHeapInit();
        print("minHeap", min.data);
        min.minHeapSort();
        print("sort", min.data);
        System.out.println("xxx");

    }

    public static class Heap {
        public int[] data;

        public Heap(int[] arr) {
            data = new int[arr.length];
            for (int i = 0; i < arr.length; i++) {
                data[i] = arr[i];
            }
        }

        /**
         * 初始化大顶堆
         */
        public void maxHeapInit() {
            int len = data.length;
            int lastP =  len / 2 - 1 ;
            //从最后一个父节点向上遍历
            for (int i = lastP; i >= 0; i--) {
                shiftDown(i,len);
            }
        }

        /**
         * 父节点小于左右子节点
         */
        private void shiftDown(int i,int len) {
            /**
             * 二叉树特性(若当前节点的下标为 i)
             *  最后一个父节点下标为 (len/2)-1
             *  父节点的下标为      (i-1)/2
             *  左子节点的下标为    (i*2)+1 或 (i<<1)+1
             *  右子节点的下标为    (i*2)+2 或 (i<<1)+2
             */
            //有左子节点
            int l = 0;//左子
            int r = 0;//右子
            int max = 0;
            while ((l = (i * 2 + 1)) < len) {
                //这轮循环,data[l]和data[r]交换位置
                r = l + 1;
                max = l;
                //有右子节点,且右边的更大
                if (r < len && (data[r] > data[l])) {
                    max = r;
                }
                //如果父节点大于等于左子节点,则停止循环
                if (data[i] >= data[max])
                    break;
                //左子节点比父节点值大，交换位置
                swap(data, i, max);
                //设置左子节点为父节点
                i = max;
            }
        }

        /**
         * 大顶堆排序后，正序
         */
        public void maxHeapSort(){
            for(int i= data.length -1;i>=0;i--){
                swap(data,i,0);
                shiftDown(0,i);
            }
        }

        /**
         * 初始化小顶堆
         */
        private void minHeapInit() {
            int len = data.length;
            int lastP =  len / 2 - 1 ;
            //从最后一个父节点向上遍历
            for (int i = lastP; i >= 0; i--) {
                shiftUp(i,len);
            }
        }

        /**
         * 父节点小于左右子节点
         */
        private void shiftUp(int i, int len) {
            /**
             * 二叉树特性(若当前节点的下标为 i)
             *  最后一个父节点下标为 (len/2)-1
             *  父节点的下标为      (i-1)/2
             *  左子节点的下标为    (i*2)+1 或 (i<<1)+1
             *  右子节点的下标为    (i*2)+2 或 (i<<1)+2
             */
            //有左子节点
            int l = 0;//左子
            int r = 0;//右子
            int min = 0;
            while ((l = (i * 2 + 1)) < len) {
                //这轮循环,data[l]和data[r]交换位置
                r = l + 1;
                min = l;
                //有右子节点,且右边的更小
                if (r < len && (data[r] < data[l])) {
                    min = r;
                }
                //如果父节点大于等于左子节点,则停止循环
                if (data[i] <= data[min])
                    break;
                //左子节点比父节点值大，交换位置
                swap(data, i, min);
                //设置左子节点为父节点
                i = min;
            }
        }

        /**
         * 小顶堆排序后，倒序
         */
        public void minHeapSort(){
            for(int i= data.length -1;i>=0;i--){
                swap(data,i,0);
                shiftUp(0,i);
            }
        }


        private void swap(int[] arr,int a,int b){
            int c=arr[a];
            arr[a]=arr[b];
            arr[b]=c;
        }

        /**
         * 二叉树特性(若当前节点的下标为 i)
         *  最后一个父节点下标为 (len/2)-1
         *  父节点的下标为      (i-1)/2
         *  左子节点的下标为    (i*2)+1 或 (i<<1)+1
         *  右子节点的下标为    (i*2)+2 或 (i<<1)+2
         */
        public void printTree(){
            int last = data.length/2-1;
            int l,r;
            int len = data.length;
            System.out.println("父节点 [左子树，右子树]");
            for(int i=0;i<=last;i++){
                l = (i*2) + 1;
                r = l + 1;
                System.out.println(MessageFormat.format("\t{0} [{1},{2}]"
                        ,data[i]
                        ,l<len?data[l]:"x"
                        ,r<len?data[r]:"x"));
            }
        }
    }
}