排序算法

一、冒泡排序

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

var arr = [1,11,2,32,15,23,67,3];
function bubbleSort(){
	var temp = -1;
	for (var i = 1; i < arr.length; i++) {
		for (var j = 0; j < arr.length-i; j++) {
			if(arr[j+1]<arr[j]){
				temp = arr[j+1];
				arr[j+1] = arr[j];
				arr[j] = temp;
			}
		}
	}
	for (var i = 0; i < arr.length; i++) {
		console.log(arr[i])
	}
}

二、选择排序

选择排序法的第一层循环从起始元素开始选到倒数第二个元素，主要是在每次进入的第二层循环之前，将外层循环的下标赋值给临时变量，接下来的第二层循环中，如果发现有比这个最小位置处的元素更小的元素，则将那个更小的元素的下标赋给临时变量，最后，在二层循环退出后，如果临时变量改变，则说明，有比当前外层循环位置更小的元素，需要将这两个元素交换。

var arr = [1, 11, 2, 32, 15, 23, 67, 3];
	function selectionSort() {
    var minIndex = -1;
    var temp = -1;
    for (var i = 0; i < arr.length - 1; i++) {
        minIndex = i;
        for (var j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        if (minIndex !== i) {
            temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
    for (var i = 0; i < arr.length; i++) {
        console.log(arr[i])
    }
}	

三、快速排序

快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

function quickSort(arr, low, high) {
    if (low > high) {
        return;
    }
    var l = low;
    var h = high;
    var povit = arr[low];
    while (l < h) {
        while (h > l && arr[h] >= povit) {
            h--;
        }
        if (l < h) {
            arr[l] = arr[h];
            l++;
        }
        while (l < h && arr[l] <= povit) {
            l++;
        }
        if (l < h) {
            arr[h] = arr[l];
            h--;
        }
    }
    arr[l] = povit;
    quickSort(arr, low, l - 1);
    quickSort(arr, h + 1, high);
}

四、归并排序

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。归并排序是一种稳定的排序方法。

function mergeSort(arr){
    let len = arr.length
    if(len> 1){
        var index = Math.floor(len / 2),
            left = arr.slice(0,index),
            right = arr.slice(index,len)
            let array =  sort(mergeSort(left),mergeSort(right))
        return array
    }else{
        return arr
    }
}
function sort(left,right){
    let arr = []
    while (left.length && right.length){
        if(left[0]<right[0]){
            arr.push(left.shift())
        }else{
            arr.push(right.shift())
        }
    }
    return arr.concat(left,right)
}