java之学习记录 11 - 1 - 堆排序

各个排序比对表：

排序算法	时间复杂度	空间复杂度	是否稳定
冒泡排序	O(n²)	O(1)	稳定
快速排序	O(nlogn)	O(logn)	不稳定
堆排序	O(nlogn)	O(1)	不稳定
计数排序	O(m+n)	O(m) 0-10 m=10	稳定
桶排序	O(n)	O(n)	稳定

根据时间复杂度的不同，主流的排序算法可以分为3大类

• 时间复杂度为O( n²)的排序算法
  • 冒泡排序、选择排序、插入排序、希尔排序
• 时间复杂度为O(nlogn)的排序算法
  • 快速排序 、归并排序、堆排序
• 时间复杂度为线性的排序算法
  • 计数排序、桶排序、基数排序

根据其稳定性，可以分为稳定排序和不稳定排序

• 稳定排序：值相同的元素在排序后仍然保持着排序前的顺序
• 不稳定排序：值相同的元素在排序后打乱了排序前的顺序

堆排序

堆排序：堆排序（ Heapsort ）是指利用堆这种数据结构所设计的一种排序算法。

 

堆是具有以下性质的完全二叉树

 

大顶堆：每个结点的值都大于或等于其左右孩子结点的值

小顶堆：每个结点的值都小于或等于其左右孩子结点的值

我们对堆中的结点按层进行编号，将这种逻辑结构映射到数组中：

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

• 大顶堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2] 2*(i+1)
• 小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]

堆排序的基本思想是：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。

1 、构造初始堆

 

将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆 ) 。

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

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

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

此时，将一个无需序列构造成了一个大顶堆。

 

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

 

将堆顶元素 9 和末尾元素 4 进行交换

重新调整结构，使其继续满足堆定义

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

后续过程，继续进行调整，交换，如此反复进行，最终使得整个序列有序

import java.util.Arrays;
public class Hp {
    public static void main(String []args){
        int []arr = {7,6,4,3,5,2,10,9,8};
        System.out.println("排序前："+ Arrays.toString(arr));
        sort(arr);
        System.out.println("排序后："+Arrays.toString(arr));
    }
    public static void sort(int[] array){
        // 1. 把无序数组构建成最大堆
        for (int i = array.length/2-1; i >= 0; i--){
            adjustHeap(array, i, array.length);
        }
        // 2. 调整堆结构+交换堆顶元素与末尾元素，调整堆产生新的堆顶
        for (int i = array.length - 1; i > 0; i--){
            // 最后1个元素和第1个元素进行交换
            int temp = array[i];
            array[i] = array[0];
            array[0] = temp;
            // “下沉”调整最大堆
            adjustHeap(array, 0, i);
        } 
    }
    public static void adjustHeap(int []array,int parentIndex,int length){ 
        // temp 保存父节点值，用于最后的赋值 
        int temp = array[parentIndex]; 
        int childIndex = 2 * parentIndex + 1; 
        while (childIndex < length){ 
            // 如果有右孩子，且右孩子大于左孩子的值，则定位到右孩子 
            if (childIndex + 1 < length && array[childIndex + 1] > array[childIndex]){ 
                childIndex++; 
            }
            // 如果父节点大于任何一个孩子的值，则直接跳出 
            if (temp >= array[childIndex]) 
                break; 
            //无须真正交换，单向赋值即可 
            array[parentIndex] = array[childIndex]; 
            parentIndex = childIndex; 
            //下一个左孩子 
            childIndex = 2 * childIndex + 1; 
        }
        array[parentIndex] = temp; 
    } 
}

堆排序的时间复杂度是： O(nlogn)