算法笔记 #003# 堆排序

原址排序，且时间复杂度是O(nlgn)的一种排序算法。

js代码：

            class HeapSort {
                static left(i) {
                    return 2 * i;
                }
                
                static right(i) {
                    return 2 * i + 1;
                }
                
                static parent(i) {
                    return Math.floor(i / 2);
                }
                
                // 递归版本
                static maxHeapify(arr, i) {
                    let l = HeapSort.left(i);
                    let r = HeapSort.right(i);
                    let largest = i;
                    if (l < arr.length && arr[l] > arr[largest]) {
                        largest = l;
                    }
                    if (r < arr.length && arr[r] > arr[largest]) {
                        largest = r;
                    }                
                    if (largest != i) {
                        let temp = arr[i];
                        arr[i] = arr[largest];
                        arr[largest] = temp; // 此时arr[largest]已经被置换成更小的那个
                        HeapSort.maxHeapify(arr, largest);
                    }            
                }

                // 非递归修正版本，heapSize表示改动范围仅限于arr[1:heapSize+1]
                static maxHeapify2(arr, i, heapSize) {
                    let flag = true;
                    while (flag) {
                        let l = HeapSort.left(i);
                        let r = HeapSort.right(i);
                        let largest = i;
                        if (l <= heapSize && arr[l] > arr[largest]) {
                            largest = l;
                        }
                        if (r <= heapSize && arr[r] > arr[largest]) {
                            largest = r;
                        }                
                        if (largest != i) {
                            let temp = arr[i];
                            arr[i] = arr[largest];
                            arr[largest] = temp; // 此时arr[largest]已经被置换成更小的那个
                            i = largest;
                        } else {
                            flag = false;
                        }
                    }            
                }
                
                static buildMaxHeap(arr, heapSize) {
                    for (let i = Math.floor(heapSize / 2); i >= 1; --i) {
                        HeapSort.maxHeapify2(arr, i, heapSize);
                    }
                }
                
                static sort(arr) {
                    let heapSize = arr.length - 1;
                    HeapSort.buildMaxHeap(arr, heapSize);
                    for (let i = arr.length - 1; i >= 2; --i) {
                        let temp = arr[i];
                        arr[i] = arr[1];
                        arr[1] = temp;        
                        HeapSort.maxHeapify2(arr, 1, --heapSize);
                    }
                }
                
                static run(data) {
                    let test1 = [undefined, 16, 4, 10, 14, 7, 9, 3, 2, 8, 1];
                    HeapSort.sort(test1);
                    console.log(test1);
                }
            }