算法与数据结构-堆排序

堆排序：

时间复杂度 ：

O(NlogN)，可以从下面过程部分和heapSort代码中得知

空间复杂度 ：

O(1)，这也是相较于快排(O(logN))，归并排序(O(N))等其他排序方法的优势

过程：

要实现堆排序，就了解堆结构和下面的操作过程：
堆结构是用数组实现的完全二叉树结构，完全二叉树如果每一棵子树的最大值都在顶部就是大根堆
下面是对堆结构的一些操作：
1.形成大根堆：将每次插入的数不断和父节点进行比较，大于父节点的值就向上移动，
  假设当前节点的下标为index，则父节点的下标为(index-1)/2
  时间复杂度O(logN)
2.删除大根堆的最大值：
  2.1 先将堆最后一个数替换堆顶元素，同时heapSize=heapSize-1，这样就将最大值移除了
  2.2 从根节点开始，从其左孩子和右孩子中选一个最大值，然后将最大值与当前节点值进行比较，
      当前节点小于孩子节点中的最大值就和该最大值进行交换，不小于的话就停止交换
  2.3 交换到孩子节点位置的点还有孩子节点就重复2.2的操作过程
  时间复杂度O(logN)
3.在大根堆中替换某个数，替换后依旧是堆：分别比较该点和其两个孩子节点和其父节点的大小
  3.1 如果小于其孩子节点中的最大值，就进行heapify操作向下调整
  3.2 如果大于其父节点，就进行heapInsert操作向上调整
  时间复杂度O(logN)

实现堆排序，就是不断扩大heapSize，再缩小heapSize的过程，假设将一个数组从小到大排序：
1.将原数组从头开始将每一个元素进行heapInsert操作, heapSize同时在不断增加，
  最终形成一个大根堆
2.将大根堆的堆顶(此时堆的最大值)和heapSize位置上的元素进行交换，并且将heapSize减少
3.此时的堆不一定是大根堆，需要进行堆化操作(heapify)重新形成一个大根堆
4.重复进行2、3操作直到heapSize=0，此时数组元素值按从小到大排好序了

代码实现：

public class HeapSort {
    public static void heapSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        // 对应堆排序的步骤1
        for (int i = 0; i < arr.length; i++) {  // O(N)
            heapInsert(arr, i);  // O(logN)
        }
        int heapSize = arr.length;
        // 对应堆排序的步骤2和3
        swap(arr, 0, --heapSize);
        while (heapSize > 0) {  // O(N)
            heapify(arr, 0, heapSize);  // O(logN)
            swap(arr, 0, --heapSize); // O(1)
        }

    }

    public static void heapSort_2(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        // 该方式同样是将数组变为一个大根堆，但是速度相较于使用heapInsert较快
        for (int i = arr.length - 1; i >= 0; i--) {
            heapify(arr, i, arr.length);
        }
        int heapSize = arr.length;
        // 对应堆排序的步骤2和3
        swap(arr, 0, --heapSize);
        while (heapSize > 0) {  // O(N)
            heapify(arr, 0, heapSize);  // O(logN)
            swap(arr, 0, --heapSize); // O(1)
        }

    }

    // 某个数现处在index位置，通过比较看是否要往上继续移动
    public static void heapInsert(int[] arr, int index) {
        // 比较此时位置和其父位置上的数大小，并且不断向上比较
        // 当index=0时,(index-1)/2 = 0, 即到了根节点后不会向上比较
        while (arr[index] > arr[(index - 1) / 2]) {
            swap(arr, index, (index - 1) / 2);
            index = (index - 1) / 2;
        }
    }

    // 堆化:某个数在index位置，看能否向下移动，对应2.2和2.3操作
    public static void heapify(int[] arr, int index, int heapSize) {
        int left = index * 2 + 1; // 左孩子下标
        // 下方还有孩子的时候(如果left>=heapSize, 毫无疑问right>=heapSize),但是不能确定是否有右孩子，
        // 所有下面还需要判断left+1和heapSize的关系
        while (left < heapSize) {
            // 两个孩子中，谁的值大就把下标给largest
            int largest = left + 1 < heapSize && arr[left + 1] > arr[left] ? left + 1 : left;
            // 父节点和较大的孩子节点间，谁大就把下标给largest
            largest = arr[largest] > arr[index] ? largest : index;

            // 当父节点不小于其两个孩子节点时，停止操作
            if (largest == index) {
                break;
            }
            // 当父节点小于其两个孩子节点时，进行值的交换
            swap(arr, largest, index);
            index = largest;
            left = index * 2 + 1;
        }
    }

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

tips: