常见数组排序

冒泡排序

选择排序

直接插入排序

希尔排序

快速排序

归并排序

堆排序

function bubble(arr) {
    if (arr.length < 2) return arr;
    for (let i = 0, len = arr.length; i < len; i++) {
        for (let j = i; j < len - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr, j, j+1)
            }
        }
    }
    return arr;
}

function selectSort(arr) {
    for (let i = 0, len = arr.length; i < len - 1; i++) {
        let minIdx = i;
        for (j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIdx]) {
                minIdx = j;
            }
        }
        swap(arr, i, minIdx);
    }
    return arr;
}

function insertSort(arr) {
    for (let i = 1, len = arr.length; i < len - 1; i++) {
        for (j = i - 1; j >= 0; j--) {
            if (arr[j] > arr[j + 1]) {
                swap(arr, j, j+1)
            }
        }
    }
    return arr;
}

function shellSort(arr) {
    let step = arr.length;
    while (true) {
        step = Math.floor(step / 2);
        for (let i = 0; i < step; i++) {
            for (let j = i + step; j < arr.length; j += step) {
                let k = j - step;
                let tmp = arr[j];
                while (k >= 0 && arr[k] > tmp) {
                    arr[k + step] = arr[k];     // 寻找合适的插入位置，右移其他元素为其挪出空间
                    k -= step;
                }
                arr[k + step] = tmp;
            }
        }
        if (step === 1) break;
    }
    return arr;
}

/**
 * reference: https://www.geeksforgeeks.org/quick-sort/
 *
 * @param {*} arr
 */
function quickSort(arr, low, high) {
    if (low < high) {
        let pivot = partition(arr, low, high);
        console.log(arr)
        quickSort(arr, low, pivot - 1);
        quickSort(arr, pivot + 1, high);
    }
    return arr;
}
function partition(arr, low, high) {
    let pivot = arr[high];
    let i = low - 1;
    for (let j = low; j < high; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(arr, i, j);
        }
    }
    swap(arr, i + 1, high); // 每次可以将pivot置于最终的位置
    return i + 1;
}

/**
 * 归并排序
 *
 * @param {*} arr
 * @param {*} low
 * @param {*} high
 */
function mergeSort(arr, low, high) {
    if (low < high) {
        let mid = low + Math.floor((high - low) >> 1);
        mergeSort(arr, low, mid);
        mergeSort(arr, mid + 1, high);
        merge(arr, low, mid, high);
    }
    return arr;
}
function merge(arr, low, mid, high) {
    let i = 0;
    let p1 = low;
    let p2 = mid + 1;
    let help = [];
    while (p1 <= mid && p2 <= high) {
        help[i++] = (arr[p1] < arr[p2] ? arr[p1++] : arr[p2++]);
    }
    while (p1 <= mid) {
        help[i++] = arr[p1++];
    }
    while (p2 <= high) {
        help[i++] = arr[p2++];
    }
    for (let i=0; i<help.length;) {
        arr[low++] = help[i++];
    }
    return arr;
}


/**
 * steps:
 * 1. Build a max heap from the input data.
 * 2. At this point, the largest item is stored at the root of the heap. 
 *    Replace it with the last item of the heap followed by reducing the size of heap by 1.
 *    Finally, heapify the root of tree.
 * 3. Repeat above steps while size of heap is greater than 1
 *
 * @param {*} arr
 */
function heapSort(arr) {
    let len = arr.length;
    // build heap
    // bit operation: let i = len >> 1 -1
    for (let i = Math.floor(len / 2) - 1; i >= 0; i--) {
        heapify(arr, len, i);
    }
    // One by one extract element from heap
    for (let i = len - 1; i >= 0; i--) {
        swap(arr, 0, i);
        // call max heapify on the reduced heap.
        heapify(arr, i, 0);
    }
    return arr;
}
/**
 * @param {*} arr 待排序数组
 * @param {*} n 数组长度
 * @param {*} i 节点索引
 */
function heapify(arr, n, i) {
    let largest = i; // Initialize largest as root 
    let l = 2 * i + 1; // left = 2*i + 1 
    let r = 2 * i + 2; // right = 2*i + 2 

    // If left child is larger than root 
    if (l < n && arr[l] > arr[largest])
        largest = l;

    // If right child is larger than largest so far 
    if (r < n && arr[r] > arr[largest])
        largest = r;

    // If largest is not root 
    if (largest != i) {
        swap(arr, largest, i)

        // Recursively heapify the affected sub-tree 
        heapify(arr, n, largest);
    }
}

function swap(arr, a, b) {
    let tmp = arr[a];
    arr[a] = arr[b];
    arr[b] = tmp;
}

// bit operation
// attrs: a ^ a = 0; k ^ 0 = k; a ^ b ^ c = b ^ a ^ c (have no concern with order)
function swap2(a, b) {
	a ^= b;
	b ^= a;	// b = b^a = b^(a^b) = b^b^a = 0^ a = a;
	a ^= b; // a = a^b = (a^b)^a = a^a^b = 0^b = b;
}

var arr = [12, 22, 3, 4, 34, 7, 11, 18];

console.log('arr', heapSort(arr))

---

参考文献：

1. https://www.geeksforgeeks.org/heap-sort/