常见排序算法中，时间复杂度和空间复杂度是怎样的？

如图所示：

快速排序：

先从数列中取出一个数作为“基准”。

分区过程：将比这个“基准”大的数全放到“基准”的右边，小于或等于“基准”的数全放到“基准”的左边。
再对左右区间重复第二步，直到各区间只有一个数。

复制 1var quickSort = function(arr) {
 2    if (arr.length <= 1) { return arr; }
 3    var pivotIndex = Math.floor(arr.length / 2);   //基准位置（理论上可任意选取）
 4    var pivot = arr.splice(pivotIndex, 1)[0];  //基准数
 5    var left = [];
 6    var right = [];
 7    for (var i = 0; i < arr.length; i++){
 8        if (arr[i] < pivot) {
 9            left.push(arr[i]);
10        } else {
11            right.push(arr[i]);
12        }
13    }
14    return quickSort(left).concat([pivot], quickSort(right));  //链接左数组、基准数构成的数组、右数组
15};

选择排序：

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
重复第二步，直到所有元素均排序完毕。

复制 1function selectionSort(arr) {
 2    var len = arr.length;
 3    var minIndex, temp;
 4    for (var i = 0; i < len - 1; i++) {
 5        minIndex = i;
 6        for (var j = i + 1; j < len; j++) {
 7            if (arr[j] < arr[minIndex]) {     // 寻找最小的数
 8                minIndex = j;                 // 将最小数的索引保存
 9            }
10        }
11        temp = arr[i];
12        arr[i] = arr[minIndex];
13        arr[minIndex] = temp;
14    }
15    return arr;
16}

插入排序：

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

复制 1function insertionSort(arr) {
 2    var len = arr.length;
 3    var preIndex, current;
 4    for (var i = 1; i < len; i++) {
 5        preIndex = i - 1;
 6        current = arr[i];
 7        while(preIndex >= 0 && arr[preIndex] > current) {
 8            arr[preIndex+1] = arr[preIndex];
 9            preIndex--;
10        }
11        arr[preIndex+1] = current;
12    }
13    return arr;
14}

冒泡法排序：

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

复制 1function bubbleSort(arr) {
 2    var len = arr.length;
 3    for (var i = 0; i < len - 1; i++) {
 4        for (var j = 0; j < len - 1 - i; j++) {
 5            if (arr[j] > arr[j+1]) {        // 相邻元素两两对比
 6                var temp = arr[j+1];        // 元素交换
 7                arr[j+1] = arr[j];
 8                arr[j] = temp;
 9            }
10        }
11    }
12    return arr;
13}

希尔排序

1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。
它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
按增量序列个数k，对序列进行k 趟排序；
每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。
仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

复制 1function shellSort(arr) {
 2    var len = arr.length,
 3        temp,
 4        gap = 1;
 5    while (gap < len / 3) {          // 动态定义间隔序列
 6        gap = gap * 3 + 1;
 7    }
 8    for (gap; gap > 0; gap = Math.floor(gap / 3)) {
 9        for (var i = gap; i < len; i++) {
10            temp = arr[i];
11            for (var j = i-gap; j > 0 && arr[j]> temp; j-=gap) {
12                arr[j + gap] = arr[j];
13            }
14            arr[j + gap] = temp;
15        }
16    }
17    return arr;
18}

归并排序

直接上代码了

复制 1function mergeSort(arr){
 2    var len = arr.length;
 3    if(len <2)
 4        return arr;
 5    var mid = Math.floor(len/2),
 6        left = arr.slice(0,mid),
 7        right =arr.slice(mid);
 8    //send left and right to the mergeSort to broke it down into pieces
 9    //then merge those
10    return merge(mergeSort(left),mergeSort(right));
11}
12
13function merge(left, right){
14    var result = [],
15        lLen = left.length,
16        rLen = right.length,
17        l = 0,
18        r = 0;
19    while(l < lLen && r < rLen){
20        if(left[l] < right[r]){
21            result.push(left[l++]);
22        }
23        else{
24            result.push(right[r++]);
25        }
26    }
27    //remaining part needs to be addred to the result
28    return result.concat(left.slice(l)).concat(right.slice(r));
29}