java8 stream 降序

大顶堆升序、小顶堆降序的堆排序（以Java描述为例版本）

一、定义

1. 堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。
2. 二叉树的相关性质
   当用数组来模拟二叉树的性质的时候，索引为i的结点的左孩子和右孩子对应的数组索引下标依次为：

• 根节点：$i$
• 左孩子：$2 * i + 1$
• 右孩子： $2 * i + 2$

数组长度为$length$，那么最后一个非叶子节点为$length/2-1$

可以分两种情形考虑：

①堆的最后一个非叶子节点若只有左孩子

②堆的最后一个非叶子节点有左右两个孩子

完全二叉树的性质之一是：如果节点序号为$i$，在它的左孩子序号为$2i+1$，右孩子序号为$2i+2$。

对于①左孩子的序号为n-1，则$n-1=2*i-1$，推出$i=n/2-1$；

对于②左孩子的序号为n-2，在$n-2=2*i-1$，推出$i=(n-1)/2-1$；右孩子的序号为n-1，则

$n-1=2*i+2$，推出$i=(n-1)/2-1$；

很显然，当完全二叉树最后一个节点是其父节点的左孩子时，树的节点数为偶数；当完全二叉树最后一个节点是其父节点的右孩子时，树的节点数为奇数。

根据java语法的特征，整数除不尽时向下取整，则若n为奇数时(n-1)/2-1=n/2-1。

因此对于②最后一个非叶子节点的序号也是n/2-1。

得证。

同时，我们对堆中的结点按层进行编号，将这种逻辑结构映射到数组中就是下面这个样子

该数组从逻辑上讲就是一个堆结构，我们用简单的公式来描述一下堆的定义就是：

大顶堆：$arr[i]>=arr[2i+1]$ && $arr[i] >= arr[2i+2]$

小顶堆：$arr[i]<=arr[2i+1]$ && $arr[i] <= arr[2i+2]$

二、第一阶段：建大顶堆

第一步给定无序数组初始化：

第二步开始构建大顶堆：

2.1 此时我们从最后一个非叶子结点开始（叶结点自然不用调整，第一个非叶子结点 arr.length/2-1=5/2-1=1，也就是下面的6结点），从左至右，从下至上进行调整。

2.2. 找到第二个非叶节点4，由于[4,9,8]中9元素最大，4和9交换。

2.3 这时，交换导致了子根[4,5,6]结构混乱，继续调整，[4,5,6]中6最大，交换4和6。

2.4 此时，初始化大顶堆以构建完成，但此时整体还是无序的，因为左右孩子的值没有比较过只是根节点和孩子节点之间的比较，不是左孩子和右孩子之间的比较。

这个时候的大根堆是这样子的

三、第二阶段：大顶堆排序

将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。

重新调整结构，使其继续满足堆定义,此时堆为[8,6,4,5]

再将堆顶元素8与末尾元素5进行交换，得到第二大元素8。

后续再构建堆[6,5,4]

再将堆顶元素6与末尾元素4进行交换，得到第三大元素6。

然后4和5再交换，继续构建大顶堆 这个时候会是[5,4]

然后继续交换，5下沉到此时的最后面，变成了[4]，得到第四大元素5

此时已经全部筛选完，是有序的了。

再简单总结下堆排序的基本思路：

a.将无需序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;

b.将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;

c.重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。

附上代码，这个是可以自由输入的。

package heapsort;

import java.util.Arrays;
import java.util.Scanner;

/**
 * @author zhouyanxiang
 * @Date 2020-12-2020/12/30-10:50
 */
public class BigHeapSort {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要排序的数组的长度：");
        int n = scanner.nextInt();
        int[] arr = new int[n];
        System.out.println("请输入要排序的数组：");
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }
        scanner.close();
        buildHeap(arr);
    }

    public static void buildHeap(int[] arr) {
        int length = arr.length;
        // 先构建一个大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            maximumHeap(arr,i, arr.length);
        }
        // 排序
        for (int i = arr.length - 1; i >= 0; i--) {
            // 过程中的每一步数组元素的变化过程
             System.out.println(Arrays.toString(arr));
            swap(arr,0,i);
            length--;
            maximumHeap(arr,0, length);
        }

        System.out.println(Arrays.toString(arr));
    }

    public static void maximumHeap(int[] arr,int i ,int length) {
        int tmp = arr[i];
        for (int j = 2 * i + 1;j < length; j = j * 2 + 1) {
            // 右孩子比左孩子要大，那么指向右孩子
            if (j+1 < length && arr[j] < arr[j+1]) {
                j++;
            }
            // 右孩子比根节点要大，一直往下探寻
            if (arr[j] > tmp) {
                arr[i] = arr[j];
                i = j;
            }
            //将temp放到最终位置
            arr[i] = tmp;
        }
    }

    public static void swap(int[] arr,int a,int b) {
       int tmp = arr[a];
       arr[a] = arr[b];
       arr[b] = tmp;
    }

}

测试用例

这个是定义好自行修改数组的。

package heapsort;

import java.util.Arrays;

/**
 * @author zhouyanxiang
 * @Date 2020-12-2020/12/30-10:50
 */
public class BigHeapSort {

    public static void main(String[] args) {
        int[] arr = {5,4,8,9,6};
        buildHeap(arr);
    }

    public static void buildHeap(int[] arr) {
        int length = arr.length;
        // 先构建一个大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            maximumHeap(arr,i, arr.length);
        }
        // 排序
        for (int i = arr.length - 1; i >= 0; i--) {
            // 过程中的每一步数组元素的变化过程
             System.out.println(Arrays.toString(arr));
            swap(arr,0,i);
            length--;
            maximumHeap(arr,0, length);
        }

        System.out.println(Arrays.toString(arr));
    }

    public static void maximumHeap(int[] arr,int i ,int length) {
        int tmp = arr[i];
        for (int j = 2 * i + 1;j < length; j = j * 2 + 1) {
            // 右孩子比左孩子要大，那么指向右孩子
            if (j+1 < length && arr[j] < arr[j+1]) {
                j++;
            }
            // 右孩子比根节点要大，一直往下探寻
            if (arr[j] > tmp) {
                arr[i] = arr[j];
                i = j;
            }
            //将temp放到最终位置
            arr[i] = tmp;
        }
    }

    public static void swap(int[] arr,int a,int b) {
       int tmp = arr[a];
       arr[a] = arr[b];
       arr[b] = tmp;
    }

}

如果只想看最后结果，可以在buildHeap（）函数里把详细过程的输出打印代码注释掉就可以只看最后排序结果了。

package heapsort;

import java.util.Arrays;
import java.util.Scanner;

/**
 * @author zhouyanxiang
 * @Date 2020-12-2020/12/30-10:50
 */
public class BigHeapSort {

    public static void main(String[] args) {
        int[] arr = {5,4,8,9,6};
        buildHeap(arr);
    }

    public static void buildHeap(int[] arr) {
        int length = arr.length;
        // 先构建一个大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            maximumHeap(arr,i, arr.length);
        }
        // 排序
        for (int i = arr.length - 1; i >= 0; i--) {
            // 过程中的每一步数组元素的变化过程
            // System.out.println(Arrays.toString(arr));
            swap(arr,0,i);
            length--;
            maximumHeap(arr,0, length);
        }

        System.out.println(Arrays.toString(arr));
    }

    public static void maximumHeap(int[] arr,int i ,int length) {
        int tmp = arr[i];
        for (int j = 2 * i + 1;j < length; j = j * 2 + 1) {
            // 右孩子比左孩子要大，那么指向右孩子
            if (j+1 < length && arr[j] < arr[j+1]) {
                j++;
            }
            // 右孩子比根节点要大，一直往下探寻
            if (arr[j] > tmp) {
                arr[i] = arr[j];
                i = j;
            }
            //将temp放到最终位置
            arr[i] = tmp;
        }
    }

    public static void swap(int[] arr,int a,int b) {
       int tmp = arr[a];
       arr[a] = arr[b];
       arr[b] = tmp;
    }

}

小顶堆的只需要修改那个maximumHeap（）函数里面的arr[j]和tmp的比较语句，还有左孩子和右孩子的比较语句，把比较的大于小于号分别改为相反的就行。

package heapsort;

import java.util.Arrays;

/**
 * @author zhouyanxiang
 * @Date 2020-12-2020/12/30-10:50
 */
public class BigHeapSort {

    public static void main(String[] args) {
        int[] arr = {5,4,8,9,6};
        buildHeap(arr);
    }

    public static void buildHeap(int[] arr) {
        int length = arr.length;
        // 先构建一个大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            maximumHeap(arr,i, arr.length);
        }
        // 排序
        for (int i = arr.length - 1; i >= 0; i--) {
            // 过程中的每一步数组元素的变化过程
             System.out.println(Arrays.toString(arr));
            swap(arr,0,i);
            length--;
            maximumHeap(arr,0, length);
        }

        System.out.println(Arrays.toString(arr));
    }

    public static void maximumHeap(int[] arr,int i ,int length) {
        int tmp = arr[i];
        for (int j = 2 * i + 1;j < length; j = j * 2 + 1) {
            // 右孩子比左孩子要大，那么指向右孩子
            if (j+1 < length && arr[j] > arr[j+1]) {
                j++;
            }
            // 右孩子比根节点要大，一直往下探寻
            if (arr[j] < tmp) {
                arr[i] = arr[j];
                i = j;
            }
            //将temp放到最终位置
            arr[i] = tmp;
        }
    }

    public static void swap(int[] arr,int a,int b) {
       int tmp = arr[a];
       arr[a] = arr[b];
       arr[b] = tmp;
    }

}