算法：堆排序（Java）

思路展示：

堆排序算法

（本视频来自网络,仅供个人观赏学习交流,请勿转载或商用。）

---

import java.util.Arrays;

public class heapSort {
    //主方法
    public static void main(String[] args){
        int testTime = 500000;
        int maxSize = 100;
        int maxValue = 100;
        boolean succeed  = true;
        for(int i = 0; i<testTime; i++){
            int[] arr1 = generateRandomArray(maxSize, maxValue);
            int[] arr2 = copyArray(arr1);
            heapSort(arr1);
            comparator(arr2);
            if(!isEqual(arr1, arr2)) {
                succeed = false;
            }
        }
        System.out.println(succeed ? "Nice~" : "Fucking fucked!");
    }
//***************************************************************************************
    //堆排序
    public static void heapSort(int[] arr){
        //特殊情况处理
        if(arr.length <= 1){
            return;
        }
        //记录堆的长度
        int heapSize = arr.length;
        //从后往前对数组（注意：实质应将数组视为一棵完全二叉树，从数的最后一个元素开始往前）进行heapify操作
        for(int i = arr.length - 1; i >= 0; i--){
            heapify(arr, i, heapSize);
        }
        //为了后面代码的简洁，第一次换位需要手动操作
        swap(arr, 0, heapSize - 1);
        //通过减小heapSize控制堆的长度，将已经处于“对”的位置的元素排除出考虑范围，直至所有元素都在“对”的位置
        while(heapSize > 0){
            heapify(arr, 0, heapSize--);//这里只能heapSize--不能--heapSize，意思为“先使用值再自减”
            swap(arr, 0, heapSize);
        }
    }
    //将index位置上的元素排到它应该到的位置上的方法
    public static void heapify(int[] arr, int index, int heapSize){
        //计算左孩子下标
        int left = index * 2 + 1;
        //当下方还有孩子的时候
        while(left < heapSize){
            //用largest记录两个孩子之中较大者——子&子比较
            int largest = left +1 < heapSize && arr[left] > arr[left + 1] ? left : left + 1;
            //同样用largest记录父子之间较大者——父——子比较
            largest = left + 1 > heapSize && arr[largest] > arr[(index - 1) / 2] ? largest : (index - 1) / 2;
            //避免当父子元素相同时出现死循环
            if(index == largest){
                break;
            }
            //排除了上述情况，就可以放心的交换元素了
            swap(arr, index, largest);
            //更新index的值（如果当前位置仍然不是“对”的位置，则该元素将继续与子元素换位，此处更新index值就是为了方便后续操作）
            index = largest;
            //同理，左孩子也应随着改变
            left = index * 2 + 1;
        }
    }
//***************************************************************************************
    //交换
    public static void swap(int[] arr, int index1, int index2){
        arr[index1] ^= arr[index2];
        arr[index2] ^= arr[index1];
        arr[index1] ^= arr[index2];
    }
    //随机数组生成器
    public static int[] generateRandomArray(int maxSize, int maxValue){
        int[] arr = new int[maxSize * ((int)Math.random() + 1)];
        for(int i = 0; i < arr.length; i++){
            arr[i] = maxValue * (int)Math.random() - (maxValue * (int)Math.random());
        }
        return arr;
    }
    //数组复制器
    public static int[] copyArray(int[] arr){
        if(arr == null){
            return null;
        }
        return arr;
    }
    //比对
    public static boolean isEqual(int[] arr1, int[] arr2){
        if(arr1 == null && arr2 != null || arr1 !=null && arr2 ==null){
            return false;
        }
        if(arr1 == null || arr2 == null){
            return true;
        }
        for(int i = 0; i < arr1.length; i++){
            if(arr1[i] != arr2[i]){
                return false;
            }
        }
        return true;
    }
    //对数器
    public static void comparator(int[] arr){
        Arrays.sort(arr);
    }
}