JS：js中的排序算法

冒泡排序

算法复杂度：O（n^2）

var array = [5,9,4,1,10];
this.getArray = function() {
    return array;
}
var swap = function(i, j) {
    temp = array[i];
    array[i] = array[j];
    array[j] = temp;
};
this.bubbleSort = function() {
    for(var i = 1; i < array.length; i++) {
        for (var j = 0; j < i; j++) {
            if(array[i] < array[j]){
                swap(i, j);
            }
        }
    }
};

冒泡排序就是遍历整个数组，对每个元素再遍历其之前的元素，若存在比其大的就进行交换。

选择排序

算法复杂度：O（n^2）

this.selectionSort = function() {
    minIndex = 0;
    for(var i = 0; i< array.length; i++) {
        minIndex = i;
        for(var j = i+1; j < array.length; j++) {
            if(array[minIndex] > array[j]) {
                minIndex = j;
            }
        }
        if(minIndex != i) {
            this.swap(i, minIndex);
        }
    }
};

选择排序的思想就是遍历一遍数组，对每个元素记录其下标为最小下标，再遍历该元素之后的元素，若存在比其小的元素，则将最小下标改为其最小下标。遍历完后就进行交换。

插入排序

算法复杂度：O（n^2）

this.insertSort = function() {
    for(var i = 1; i < array.length; i++) {
        temp = array[i];
        j = i;
        while(j>0 && array[j-1]>temp) {
            array[j] = array[j-1];
            j--;
        }
        array[j] = temp;
    }
};

假设数组的第一个已经是排好的。从数组第二个开始，记录其值，并逐个比较其后元素，若存在比其大的，将位置给那个较大的数字，并继续往前比较，直到比较到一个比自己小的数字就可以结束了。

归并排序

算法复杂度：O（nlogn）

this.mergeSort = function() {
    array = mergeSortRecursive(array); 
};
//递归执行，直到分成长度为1的数组为止
var mergeSortRecursive = function(array) {
    if(array.length == 1) {
        return array;
    }
    var middle = Math.round(array.length / 2);
    var arrayLeft = array.slice(0, middle);
    var arrayRight = array.slice(middle, array.length);

    return merge(mergeSortRecursive(arrayLeft), mergeSortRecursive(arrayRight));
};
//将两个数组进行合并
var merge = function(arrayLeft, arrayRight) {
    var result = [];
    console.log("left",arrayLeft);
    console.log("right",arrayRight);
    var leftLen = 0;
    var rightLen = 0;
    //不断循环比较，直到其中一个数组全部放入result中
    while(leftLen < arrayLeft.length && rightLen < arrayRight.length){
        if(arrayLeft[leftLen] < arrayRight[rightLen]) {
            result.push(arrayLeft[leftLen]);
            leftLen++;
        } else {
            result.push(arrayRight[rightLen]);
            rightLen++;
        }
    }
    //剩下的数组因为是排好序的了，直接放入
    while(leftLen < arrayLeft.length) {
        result.push(arrayLeft[leftLen]);
        leftLen++;
    }
    while(rightLen < arrayRight.length) {
        result.push(arrayRight[rightLen]);
        rightLen++;
    }
    return result;
};

归并排序的原理就是将一个数组不断分，分到不能分为止（长度为1的数组）就可以开始合并。

快速排序

算法复杂度：O（nlogn）

this.quickSort = function() {
    quick(array, 0, array.length-1);
};
var quick = function (array, left, right) {
    if(array.length > 1) {
        index = partition(array, left, right);
        if(left < index - 1) {
            quick(array, left, index-1);
        }
        if(right > index) {
            quick(array, index, right);
        }
    }
    return array;
};
var partition = function(array, left, right) {
    var i = left;
    var j = right;
    var pivot = array[Math.floor((left+right)/2)];
    while(i <= j) {
        while(array[i] < pivot) {
            i++;
        }
        while(array[j] > pivot) {
            j--;
        }
        if(i <= j) {
            swap(i, j);
            i++;
            j--;
        }
    }
    console.log(array, i, j);
    return i;
};

快速排序的原理和归并差不多都是将数组不断分，但是快速排序是从大的开始分而归并是从小的开始。
先找到一个中间值，下标为i的元素表示中间左侧元素，下标为j的元素表示中间右侧元素，i不断找比中间值大的下标，而j不断找比中间值小的下标，一旦i<=j就进行交换。
这样就能保证i下标及以后的元素都是比中间值大的，i下标以前的元素则是比中间值小的。这样直到元素只有一个时就是排好序得了。