【数据结构】堆应用之堆排序

如何实现堆

堆排序

首先建立一个最大堆，然后将堆顶元素与末尾元素进行交换，使末尾元素最大。然后调整堆的大小（即堆元素-1），然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。直至堆剩下一个元素后将得到一个递增的有序序列。

Java版本实现

//堆排序
public class HeapSort<T extends Comparable<T>> extends Sort<T> {
    @Override
    public void sort(T[] nums) {
        int n = nums.length - 1;
        for (int k = n / 2; k >= 0; k--) {
            sink(nums, k, n);
        }

        while (n >= 1) {
            swap(nums, 0, n--);
            sink(nums, 0, n);
        }
    }
	
	//下沉操作，对第 k 
    private void sink(T[] nums, int k, int n) {
        while (2 * k <= n) {
            int j = 2 * k + 1;
            if (j < n && less(nums[j], nums[j + 1]))
                j++;
            if (j > n || !less(nums[k], nums[j]))
                break;
            swap(nums, j, k);
            k = j;
        }
    }
}

继承的抽象类 Sort

package com.wuyi.notecode.sort;

public abstract class Sort<T extends Comparable<T>>{

    public abstract void sort(T[] nums);

    protected boolean less(T v, T w){
        return v.compareTo(w) < 0;
    }

    protected void swap(T[] nums, int i, int j){
        if (i == j)
            return;

        T temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }

    protected void display(T[] nums){
        for (T a : nums){
            System.out.print(a + " ");
        }
        System.out.println();
    }
}

测试代码

 public static void main(String[] args) {
        HeapSort<Integer> sortInt = new HeapSort<>();
        Integer a[] = {6,4,8,2,5,9,10};
        sortInt.sort(a);
        System.out.println("最终结果：");
        sortInt.display(a);

        HeapSort<Double> sortDouble = new HeapSort<>();
        Double b[] = {5.6, 2.2, 58.3, 6.0, 56.1, 5.1, 93.63};
        sortDouble.sort(b);
        System.out.println("最终结果：");
        sortDouble.display(b);

        HeapSort<String> sortStr = new HeapSort<>();
        String s[] = {"d", "f", "D", "r", "U"};
        sortStr.sort(s);
        System.out.println("最终结果：");
        sortStr.display(s);
    }