本文是之前写的一篇js版的算法介绍。

插入排序

将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。

function insertionSort(arr) {
    let len = arr.length;
    for(let i = 1; i < len; i++) {
        let temp = arr[i];
        for(var j = i; j > 0 && arr[j-1] > temp; j--) {
            arr[j] = arr[j-1];
        }
        arr[j] = temp;
    }
}

希尔排序

缩小增量的插入排序，先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

function shellSort(arr) {
    let len = arr.length;
    let inc = parseInt(len / 2);
    while(inc > 0){
        for(let i = inc; i < len; i++) {
            let temp =  arr[i];
            for(var j = i; j >= inc && arr[j-inc] > temp; j -= inc) {
                arr[j] = arr[j-inc];
            }
            arr[j] = temp;
        }
        inc = parseInt(inc / 2);
    }
}

选择排序

在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

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

堆排序

堆排序是一种树形选择排序，是对直接选择排序的有效改进

function heapSort(arr) {
    buildHeap(arr);
    console.log(arr);
    for(let i = arr.length - 1; i >= 0; i--) {
        [arr[i], arr[0]] = [arr[0], arr[i]];
        AdjustHeap(arr, 0, i);
    }
}

function buildHeap(arr) {
    let len = arr.length;
    for(let i = Math.floor(len / 2) - 1; i >= 0; i--) {
        AdjustHeap(arr, i, len);
    }
}

function AdjustHeap(arr, idx, len) {
    // let len = arr.length;
    let left = 2 * idx + 1;
    while(left < len) {
        if(left+1 < len && arr[left] < arr[left+1]) {
            left++;
        }
        if(arr[idx] < arr[left]) {
            [arr[idx], arr[left]] = [arr[left], arr[idx]];
            idx = left;
            left = idx * 2 + 1;
        } else {
            break;
        }
    }
}

冒泡排序

每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

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

设置标志位，对冒泡排序进行改进。

function bubleSort2(arr) {
    let i = arr.length - 1;
    while(i > 0) {
        let pos = 0;
        for(let j = 0; j < i; j++) {
            if(arr[j] > arr[j+1]) {
                [arr[j], arr[j+1]] = [arr[j+1], arr[j]];
                pos = j;
            }
        }
        i  = pos;
        console.log(pos);
    }
}

快速排序

选择一个基准元素,通常选择第一个元素或者最后一个元素；通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小，另一部分记录的 元素值比基准值大；此时基准元素在其排好序后的正确位置；然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。

function quickSort(arr, start, end) {
    if(start < end) {
        let left = start, right = end;
        let mid = arr[left];
        while(left < right) {
            while(left < right && arr[right] >= mid) right--;
            [arr[left], arr[right]] = [arr[right], arr[left]];
            while(left < right && arr[left] <= mid) left++;
            [arr[left], arr[right]] = [arr[right], arr[left]]; 
        }
        quickSort(arr, start, left-1);
        quickSort(arr, left+1, end);
    }
}

归并排序

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

function mergeSort(arr, start, end) {
    if(start < end) {
        let mid = Math.floor((start + end) / 2);
        mergeSort(arr, start, mid);
        mergeSort(arr, mid + 1, end)；
        if(arr[mid] > arr[mid+1]) { //如果两部分已经有序，不再进行归并操作
          merge(arr, start, mid, end); 
        }
    }
}

function merge(arr, start, mid, end) {
    let i = start, j = mid+1;
    let temp = new Array(end - start + 1);
    let k = 0;
    for(; i <= mid && j <= end; ) {
        if(arr[i] <= arr[j]) {
            temp[k++] = arr[i++];
        } else {
            temp[k++] = arr[j++];
        }
    }
    while(i<=mid) temp[k++] = arr[i++];
    while(j<=end) temp[k++] = arr[j++];
    for(let item of temp) {
        arr[start++] = item;
    }
}

归并排序的非递归做法

归并排序的非递归做法好像是面试时常遇到的问题，实现如下：

function mergeSort2(arr) {
    let step = 1;
    let temp = new Array(arr.length);
    for(; step < arr.length ; step = step*2) {
        let ls, le, rs, re;
        for(let ls = 0; ls < arr.length - step; ls = re) {
            rs = le = ls + step;
            re = rs + step;
            if(re > arr.length) {
                re = arr.length;
            }
            let k = 0;
            while(ls < le && rs < re) {
                temp[k++] = arr[ls] > arr[rs] ? arr[rs++] : arr[ls++];
            }
            while(ls < le) {
                temp[k++] = arr[ls++];
            }
            while(k > 0) {
                arr[--rs] = temp[--k];
            }
        }
    }
}

自底向上的归并排序

自底向上的归并排序也是非递归的，实现如下：

template<typename T>
void mergeSortBU(T a[], int n) {
  for(int size = 1; size <= n; size += size) {
    for(int i = 0; i+size < n; i += size + size) {
      merge(a, i, i+size-1, min(i+2*size-1, n-1));
    }
  }
}