数据结构-二叉堆&堆排序Java

二叉堆
堆排序

二叉堆

import java.util.Arrays;

public class HeapOperator {
    public static void main(String[] args) {
        //上浮
        int[] array0=new int[]{1,3,2,6,5,7,8,9,10,0};
        upAdjust(array0);
        System.out.println(Arrays.toString(array0));


        //小顶堆 下沉
        int[] array=new int[]{7,1,3,10,5,2,8,9,6};
        buildHeap(array);
        System.out.println(Arrays.toString(array));
    }
    //构建堆
    private static void buildHeap(int[] array) {
        //从最后一个非叶子节点开始，依次下沉调整
        for(int i=array.length/2;i>=0;i--){
            downAdjust(array,i,array.length-1);
        }
    }
    //下沉调整
    /*
    构建二叉堆，也就是把一个无序的完全二叉树调整为二叉堆，本质上就是让所有非叶子节点依次下沉。
     */
    private static void downAdjust(int[] array, int parentIndex, int length) {
        //array:要调整的堆，parentIndex：要下沉的父节点，length:堆的有效大小
        int temp=array[parentIndex];
        int childIndex=2*parentIndex+1;
        while(childIndex<length){
            //如果有右孩子，且右孩子小于左孩子,则定位到右孩子
            if(childIndex+1<length&&array[childIndex+1]<array[childIndex]){
                childIndex++;
            }
            //父节点小于任意一个孩子的值，跳出循环
            if(array[parentIndex]<=array[childIndex]){
                break;
            }
            array[parentIndex]=array[childIndex];
            parentIndex=childIndex;
            childIndex=childIndex*2+1;
        }
        array[parentIndex]=temp;
    }
    //上浮调整
    private static void upAdjust(int[] array) {
        int childIndex=array.length-1;
        int parentIndex=(childIndex-1)/2;
        //temp保存插入的叶子节点值，用于最后的赋值
        int temp=array[childIndex];
        while(childIndex>0&&temp<array[parentIndex]){
            array[childIndex]=array[parentIndex];
            childIndex=parentIndex;
            parentIndex=(childIndex-1)/2;
        }
        array[childIndex]=temp;
    }
}

堆排序

import java.util.Arrays;

public class HeapSort {
    /*
    得到升序，要先构造大顶堆。
    我们每一次删除旧堆顶，调整后的新堆顶都是大小仅次于旧堆顶的节点。
    那么我们只要反复删除堆顶，反复调节二叉堆，所得到的集合就成为了一个有序集合。
     */
    public static void main(String[] args) {
        //堆排序
        int[] array2=new int[]{7,1,3,10,5,2,8,9,6};
        heapSort(array2);
        System.out.println(Arrays.toString(array2));
    }
    public static void heapSort(int[] array){
        //从最后一个非叶子节点开始，依次下沉调整
        for(int i=(array.length-2)/2;i>=0;i--){
            downAdjust(array,i,array.length);
        }
        //现在是个大顶堆了
        System.out.println(Arrays.toString(array));
        //循环删除堆顶元素，移到集合尾部，调节堆产生新的堆顶。
        for(int i=array.length-1;i>0;i--){
            int temp=array[i];
            array[i]=array[0];
            array[0]=temp;
            downAdjust(array,0,i);
        }
    }

    //下沉调整
    /*
    构建二叉堆，也就是把一个无序的完全二叉树调整为二叉堆，本质上就是让所有非叶子节点依次下沉。
     */
    private static void downAdjust(int[] array, int parentIndex, int length) {
        //array:要调整的堆，parentIndex：要下沉的父节点，length:堆的有效大小
        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=childIndex*2+1;
        }
        array[parentIndex]=temp;
    }
}

    //下沉
    public static void down(int[] nums,int parentIndex,int len){//len：有效长度
        int childIndex=parentIndex*2+1;
        while(childIndex<len){
            if(childIndex+1<len&&nums[childIndex+1]>nums[childIndex]){
                childIndex=childIndex+1;
            }
            if(nums[parentIndex]>=nums[childIndex]){
                break;
            }
            int tmp=nums[childIndex];
            nums[childIndex]=nums[parentIndex];
            nums[parentIndex]=tmp;
            parentIndex=childIndex;
            childIndex=childIndex*2;
        }
    }