堆排序

思路：
首先构建大根堆: 数组逻辑上看成堆，父节点大于任意子节点的二叉树

父子节点关系：子：index 父：(index - 1) / 2

step1: 构建大根堆的时候，如果子节点大于父节点，交换双方位置，进行上浮，直到子节点小于等于父节点 or 到达根节点

step2: 堆顶和最后一个数交换，size减一，然后维持大根堆，堆顶进行下沉，直到父节点大于等于左右子节点 or 选出左右子节点最大值，交换，左节点大于等于当前size(左节点等于size说明父节点已经是最后一个节点

Python版：

'''
堆排序
语法：
int a 剪去小数部分
// 向下取整，-5 // 3 结果为 -2 向小的方向偏移
'''


def heapSort(arr):
    if len(arr) < 2 or arr == None:
        return

    for i in range(len(arr)):
        upAdjust(arr, i)

    size = len(arr)
    # while循环
    while size > 0:
        downAdjust(arr, 0, size)
        size -= 1
        swap(arr, 0, size)


def upAdjust(arr, index):
    #
    while arr[index] > arr[int((index - 1) / 2)]:
        swap(arr, index, (int((index - 1) / 2)))
        index = int((index - 1) / 2)


def downAdjust(arr, index, size):
    left = 2 * index + 1
    while left < size:
        # python的三目运算
        largest = (left + 1) if (left + 1) < size and arr[left] < arr[left + 1] else left
        if arr[index] > arr[largest]:
            break
        swap(arr, index, largest)
        index = largest
        left = 2 * left + 1


def swap(arr, i, j):
    temp = arr[i]
    arr[i] = arr[j]
    arr[j] = temp


arr = [2, 6, 4, 3, 18, 29, 11, 10]
heapSort(arr)
for x in arr:
    print(x)

Java版：

public class HeapSort_day1 {
    public static void main(String[] args) {
        int[] arr = new int[]{2, 6, 4, 3, 18, 29, 11, 10};
        heapSort(arr);
        for(int i=0; i<arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

    public static void heapSort(int[] arr) {
        if(arr==null || arr.length<2) {
            return;
        }
        for(int i=0; i<arr.length; i++) {
            //构建大根堆
            upAdjust(arr, i);
        }

        //进行排序,将堆顶和最后一个数交换,下沉到指定位置，维持大根堆
        int size = arr.length;
        while (size > 0) {
            downAdjust(arr, 0, size);
            swap(arr, 0, --size);

        }


    }


    public static void upAdjust(int[] arr, int index) {
        //子节点不能大于父节点,只有最后才需要交换，是不是可以优化
        while (arr[index] > arr[(index - 1) / 2]) {
            swap(arr, index, (index-1)/2);
            index = (index - 1) /2;
        }
    }

    /**
     * 交换到堆顶的元素下潜维持堆结构
     * 和子节点比较，大于子节点最大值，不变，小于子节点中的最大值交换位置
     * @param arr
     * @param index
     * @param size
     */
    public static void downAdjust(int[] arr, int index, int size) {
        int left = 2 * index + 1;
        while (left < size) {
            //选子节点的最大值
            int largestChild = (left+1) < size && arr[left] < arr[left+1] ? (left+1) : left;

            int largest = arr[largestChild] < arr[index] ? index : largestChild;
            //如果index是最大值，不需要下沉
            if(index == largest) {
                break;
            }
            swap(arr, index, largest);
            index = largest;
            left = index*2 + 1;
        }

    }

    public static void swap(int[] arr, int x, int y) {
        int temp = arr[x];
        arr[x] = arr[y];
        arr[y] = temp;
    }
}