Javascript版本排序1

冒泡排序-时间复杂度为O(N^2)-稳定排序：

var a = [49 ,38, 65 ,97 ,76 ,13 ,27, 49];
var length = a.length;
var temp;
for(var i = 0; i < a.length; i++) {
   for(var j = 0; j < a.length - i; j++) {
		if(a[j] > a[j + 1]) {
			temp = a[j];
			a[j] = a[j + 1];
			a[j + 1] = temp;
		}
	}
}
console.log(a.join(" "));

选择排序-时间复杂度为O(N^2)-不稳定排序:  每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。
    初始关键字     [49 38 65 97 76 13 27 49]
    第一趟排序后 13 [38 65 97 76 49 27 49]
    第二趟排序后 13 27 [65 97 76 49 38 49]
    第三趟排序后 13 27 38 [97 76 49 65 49]
    第四趟排序后 13 27 38 49 [76 97 65 49]
    第五趟排序后 13 27 38 49 49 [97 65 76]
    第六趟排序后 13 27 38 49 49 65 [97 76]
    第七趟排序后 13 27 38 49 49 65 76 [97]
    最后排序结果 13 27 38 49 49 65 76 97

var a = [49 ,38, 65 ,97 ,76 ,13 ,27, 49];
var minV, indexM, temp, index = a.length;
for(var i = 0; i < index; i++) {
minV = a[i];
indexM = i;
    for(var j = i; j <  index; j++) {
        if(a[j] < minV) {
            minV = a[j];
            indexM = j;
        }
    }
    temp = a[indexM];
    a[indexM] = a[i];
    a[i] = temp;
}
console.log(a.join(" "));

插入排序--时间复杂度为O(N^2)-稳定的排序方法: 有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序.
    LOG: 1 time: 38 49 65 97 76 13 27 49
    LOG: 2 time: 38 49 65 97 76 13 27 49
    LOG: 3 time: 38 49 65 97 76 13 27 49
    LOG: 4 time: 38 49 65 76 97 13 27 49
    LOG: 5 time: 13 38 49 65 76 97 27 49
    LOG: 6 time: 13 27 38 49 65 76 97 49
    LOG: 7 time: 13 27 38 49 49 65 76 97

var a = [49 ,38, 65 ,97 ,76 ,13 ,27, 49];
var length = a.length;
var temp;
for(var i = 1; i < a.length; i++) {
    var j = i;
    var currentData = a[i];
    while((j > 0) && (a[j - 1] > currentData)) {
        a[j] = a[j - 1];
        j--;
    }
    a[j] = currentData;
}
console.log(a.join(" "));

快速排序:  通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列，不稳定的排序方法
    1 time: 27 38 13 49 76 97 65 49
    2 time: 13 27 38 49 76 97 65 49
    3 time: 13 27 38 49 49 65 76 97
    4 time: 13 27 38 49 49 65 76 97

function QuickSort(data, left, right) {
    var temp = data[left], p = left, i = left, j = right, temp1;
    while(i < j) {
        while(j >= p && data[j] >= temp) {
            j--;
        }
        if(j >= p) {
            temp1 = data[p];
            data[p] = data[j];
            data[j] = temp1;
            p = j;
        }
        while(i < p && data[i] <= temp) {
            i++;
        }
        if(i <= p) {
            temp1 = data[p];
            data[p] = data[i];
            data[i] = temp1;
            p = i;
        }
    }
    if(p - left > 1) QuickSort(data, left, p - 1);
    if(right - p > 1) QuickSort(data, p + 1, right);
}
var a = [49 ,38, 65 ,97 ,76 ,13 ,27, 49], k = 1;
QuickSort(a, 0, a.length - 1);
console.log(a);

希尔排序：属于插入类排序,是将整个无序列分割成若干小的子序列分别进行插入排序，不稳定排序

var a = [49 ,38, 65 ,97 ,76 ,13 ,27, 49];
var n = a.length;
var temp, gap = 0;
while(gap < n) {
    gap = gap * 3 + 1;
}
while(gap > 0) {
    for(i = gap; i < n; i++) {
        j = i - gap;
        temp = a[i];
        while((j >= 0) && (a[j] > temp)) {
            a[j + gap] = a[j];
            j = j - gap;
        }
        a[j + gap] = temp;
    }
    gap = (gap - 1)/3;
}

堆排序

归并排序