6.堆与堆排序

目录

一、堆。 

1.堆的定义和实现。

2.堆排序。

---

 

一、堆。 

1.堆的定义和实现。

package 堆;

public class Heap <T extends Comparable<T>>{
    //存储堆中的元素
    private T[] items;
    //记录堆中元素的个数
    private int N;

    public Heap(int capacity){
        //这里不能new Object类型，因为T类型是继承Comparable类型的，（Object 不能转换为 Comparable 类型）
        this.items = (T[]) new Comparable[capacity+1];
        this.N = 0;
    }

    //判断堆中索引i处的元素是否小于索引j处的元素
    private boolean less(int i,int j){
        return items[i].compareTo(items[j]) < 0 ;
    }

    //交换堆中i处索引和j索引处的值
    private void exch(int i,int j){
        T temp = items[i];
        items[i] = items[j];
        items[j] = temp;
    }

    //往堆中插入一个元素
    public void insert(T t){
        //因为数组索引0不存放数据，所以元素个数与N相同
        items[++N] = t;
        //通过上浮算法，放到合适的位置
        swim(N);
    }

    //使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置（其实就是跟父节点比较）
    private void swim(int k){
        //通过循环，不断的比较当前结点的值和其父节点的值，如果发现父节点的值比当前结点的值小，则交换位置
        while (k > 1){//如果k==1，则说明只有一个结点（根节点,k即结点位置），它没有父节点，所以不用比较
            //比较当前结点和父节点
            if (less(k/2,k)){
                exch(k/2,k);
            }
            k = k/2;
        }
    }

    //删除堆中最大的元素，并返回这个最大元素
    public T delMax(){
        T max = items[1];
        //交换索引1处的元素和最大索引处的元素，让完全二叉树中最右侧的元素变为临时根节点
        exch(1,N);
        //最大索引处的元素删除掉
        items[N] = null;
        //元素个数-1
        N--;
        //使用下沉算法，让堆重新有序
        sink(1);
        return max;
    }

    //使用下浮算法，使索引k处的元素能在堆中处于一个正确的位置
    private void sink(int k){
        //通过循环不断的对比当前k结点和其左子结点2k,以及2k+1处中的较大值的元素大小，如果当前结点小，则需要更换位置
        while (2*k <= N) {
            //获取当前结点的子结点中较大结点
            int max;//记录较大结点所在的索引
            if (2*k + 1 <= N){
                if (less(2*k,2*k + 1)){
                    max = 2*k+1;
                }else {
                    max = 2*k;
                }
            }else {
                //没有右子结点
                max = 2*k;
            }
            //比较当前结点和较大结点的值(存在这种情况,如果右结点比左结点大，即与删除元素交换位置的并非最小元素)
            if (!less(k,max)){
                break;
            }
            //交换k索引处的值和max索引处的值
            exch(k,max);
            k = max;
        }
    }
}

代码测试：

package 堆;

import java.util.Arrays;

public class HeapTest {
    public static void main(String[] args) {
        //创建堆对象
        Heap<String> heap = new Heap<String>(10);
        //往堆中存入字符串数据
        heap.insert("A");
        heap.insert("B");
        heap.insert("C");
        heap.insert("D");
        heap.insert("E");
        heap.insert("F");
        heap.insert("G");
        //通过循环从堆中删除元素
        String result = null;
        while ((result = heap.delMax()) != null){
            System.out.print(result+" ");
        }
    }
}

2.堆排序。

 

堆可以分为最大堆和最小堆。最大堆的性质是每个节点的值都大于或等于它的子节点的值，即根节点的值最大；最小堆的性质是每个节点的值都小于或等于它的子节点的值，即根节点的值最小。

在最大堆排序中，首先要将待排序的数组构建成一个大根堆。然后，将堆顶元素（即数组中的最大值）与数组的最后一个元素交换位置，并将堆的大小减1（排除已排序数组的最后一个元素）。接着，对堆顶元素执行“下沉”操作（将堆顶元素与它的子节点进行比较，如果子节点的值大于堆顶元素的值，则交换它们的位置），使得堆重新满足大根堆的性质。这样，堆顶元素就是数组中的下一个最大值。重复执行以上步骤，直到整个数组排序完成。

package 堆;

public class HeapSort {
    //判断heap堆中索引i处的元素是否小于索引j处的元素
    private static boolean less(Comparable[] heap,int i,int j){
        return heap[i].compareTo(heap[j]) < 0;
    }

    //交换heap堆中i索引和j索引处的值
    private static void exch(Comparable[] heap,int i,int j){
        Comparable temp = heap[i];
        heap[i] = heap[j];
        heap[j] = temp;
    }

    //根据原数组source，构造处堆heap
    private static void createHeap(Comparable[] source,Comparable[] heap){
        //把source中的元素拷贝到heap中，heap中的元素就形成一个无序的堆
        /**
         * 这里的source传进来的是字符串数组，不是堆那里的，所以它的元素是从0开始存储
         * source：原数组
         * srcPos: 原数组的起始位置（复制的起始位置）
         * dest：目标数组
         * destPos: 目标数据的起始位置（粘贴的起始位置）
         * length：复制的个数
         */
        System.arraycopy(source,0,heap,1,source.length);
        //对堆中的元素做下沉调整（从长度的一半处开始，往索引1处扫描）
        for (int i = heap.length / 2; i > 0; i--) {
            sink(heap,i,heap.length - 1);//这里-1的原因：因为length是数组的长度个数，其中0索引就是1个长度，所以实际上最大的索引是length-1
        }
    }

    //对source数组中的数据从小到大排序
    public static void sort(Comparable[] source){
        //构建堆
        Comparable[] heap = new Comparable[source.length+1];
        createHeap(source,heap);//复制数组的元素，以及进行第一次下沉排序（因为数组中不是有序的，需要下沉排序）
        //定义一个变量，记录未排序的元素中的最大的索引
        int N = heap.length - 1;
        //通过循环，变换1索引处的元素和排序的元素中最大的索引出的的元素
        while (N != 1){
            //交换元素
            exch(heap,1,N);
            //排序交换后最大元素所在的索引，让它不要参与堆的下沉调整
            N--;
            //需要对索引1处的元素进行堆的下沉调整
            sink(heap,1,N);
        }
        //把heap堆中的数据复制到原数组source中
        System.arraycopy(heap,1,source,0,source.length);
    }

    //在heap堆中，对target处的元素做下沉，范围是0-range
    private static void sink(Comparable[] heap,int target,int range){
        while (2*target <= range){
            //1.找出当前结点的较大的子结点
            int max = 0;
            if (2*target+1 <= range){
                if (less(heap,2*target,2*target+1)){
                    max = 2*target+1;
                }else {
                    max = 2*target;
                }
            }else {
                max = 2*target;
            }
            //2.比较当前结点的值和较大子结点的值
            if (!less(heap,target,max)){
                break;
            }
            exch(heap,target,max);
            target = max;
        }
    }
}

代码测试：

package 堆;

import java.util.Arrays;

public class HeapSortTest {
    public static void main(String[] args) {
        //待排序数组
        String[] arr = {"S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E"};
        //通过HeapSort对数组中的元素进行排序
        HeapSort.sort(arr);
        //打印排序后数组中的元素
        System.out.println(Arrays.toString(arr));
    }
}