Java 实现堆排序

堆排序

主要思想

利用数组存储完全二叉树，利用堆的性质，构造大根堆或者小根堆。

1、构造大根堆/小根堆
2、进行堆排序，交换最后一个叶子节点与根节点（当前堆中最大/最小元素），并进行下滤操作（堆化操作），并断开交换后的最后一个节点与树的连接，即排好了一个元素

核心方法：堆化操作，也成为下滤操作，即保证树为最大堆/最小堆

复杂度：时间复杂度：O(n logn)，空间复杂度：O(1)

稳定性：不稳定，堆化操作可能会导致相同元素的相对位置发生改变

public class HeapSort {
    
    

    public static void main(String[] args) {
    
    
        int[] arr = new int[10];
        for (int i = 0; i < 10; i++) {
    
    
            arr[i] = new Random().nextInt(100);
        }

        System.out.println("排序前");
        for (int num : arr) {
    
    
            System.out.print(num + " ");
        }
        System.out.println();

        heapSort(arr, arr.length);

        System.out.println("排序后");
        for (int num : arr) {
    
    
            System.out.print(num + " ");
        }
        System.out.println();
    }

    private static void heapSort(int[] nums, int n) {
    
    
        // 建堆
        int i;
        for (i = n / 2 - 1; i >= 0; i--) {
    
    
            heapify(nums, n, i);
        }
		// 排序
        for (i = n - 1; i > 0; i--) {
    
    
            swap(nums, i, 0);
            heapify(nums, i, 0);
        }
    }

    // 核心方法，堆化
    private static void heapify(int[] nums, int n, int i) {
    
    
        int largest = i;
        int l_son = i * 2 + 1;
        int r_son = i * 2 + 2;
        // 寻找父子之中更大的节点
        if (l_son < n && nums[largest] < nums[l_son]) {
    
    
            largest = l_son;
        }
        if (r_son < n && nums[largest] < nums[r_son]) {
    
    
            largest = r_son;
        }
        if (largest != i) {
    
    
            swap(nums, largest, i);
            // 如果交换之后，仍需维护子树堆，即下滤操作
            heapify(nums, n, largest);
        }
    }

    private static void swap(int[] nums, int i, int j) {
    
    
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

}