堆排序

public class Main {
    public static void main(String[] args) throws IOException {
        Main m = new Main();
        int[] array = new int[]{4,9,7,8,6,4,10,15,3,7,6,82,3};
        ArrayList<Integer> list = heapSort(array, false);
    }



    public static ArrayList<Integer> heapSort(int[] array, boolean flag){   //堆排序，flag表明是正序还是倒序，true是正序，false是倒序
        ArrayList<Integer> list = new ArrayList<Integer>();    //存放排序后的数组
        for(int i = array.length - 1; i >= 0; i --){    //存在一个stop，从末尾开始，为了和第一位交换
            creatHeap(array, i, flag);    //将stop位及其之前的建成一个堆

            list.add(array[0]);    //第一位加入排序后的数组中

            int tmp = array[0];    //第一位和和stop位交换
            array[0] = array[i];
            array[i] = tmp;
        }
        return list;    //返回有序的list
    }

    public static void creatHeap(int [] array, int stop, boolean flag) {    //建立堆
        int start = (stop - 1) / 2;    //找到最后一个非叶子节点
        for(int i = start; i >= 0 ;i --){    从这个节点开始到0节点，利用sortHelper使之符合堆的要求
            sortHelper(array, i ,stop, flag);
        }

    }

    public static void sortHelper(int[] array, int i, int stop, boolean flag) {    //将i节点建立成符合要求的一个“堆”
        int left = i * 2;    //i节点的左孩子的序号
        int right = i * 2 + 1;    //i节点右孩子的序号
        int index = -1;    //i节点需要和哪个孩子交换的序号

        if(left > stop) //如果没有左子树，直接返回
            return;
        if(right > stop){   //如果没有右子树，index赋值为left
            index = left;
        }else{  //否则index赋值为左右子树一方的编号
            if(flag){
                index = array[left] < array[right] ? left : right;
            }else{
                index = array[left] > array[right] ? left : right;
            }
        }

        if(flag){
            if(array[i] > array[index]){  //如果当前节点比index节点大，那么交换
                int tmp = array[i];
                array[i] = array[index];
                array[index] = tmp;
                sortHelper(array, index, stop, flag);   //递归处理交换后的节点（max）;
            }else{  //否则直接返回
                return;
            }
        }else{
            if(array[i] < array[index]){  //如果当前节点比max节点小，那么交换
                int tmp = array[i];
                array[i] = array[index];
                array[index] = tmp;
                sortHelper(array, index, stop, flag);   //递归处理交换后的节点（max）;
            }else{  //否则直接返回
                return;
            }
        }

    }
}