JavaScript实现部分排序算法【冒泡，选择，插入，快排，希尔，归并】

实现了冒泡，选择，插入，快排，希尔，归并

冒泡排序

//外层遍历：len-1>=i>0;  i--
//内层遍历：0<=j<i;  j++
//定义一个flag做代码优化
function bubbleSort(arr){
	var len = arr.length;			
	var tmp;
	for(var i=len-1; i>0; i++){
		var flag = true;
		for(var j=0; j<i; j++){
			if(arr[j]>arr[j+1]){
				tmp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = tmp;
				flag = false;
			}
		}
		if(flag){
			return arr;
		}
	}
}

选择排序

//外层排序：1<=i<len; i++;
//内层排序：i+1<=j<len; j++
//左侧默认有序，从右边选出一个最小值来与最左边的最大值进行交换


function selectSort(arr){
	var len = arr.length;
	var minIndex, temp;
	for(var i=0; i<len-1; i++){
		minIndex = i;
		for(var j=i+1; j<len; j++){

			//找出右边的最小值
			if(arr[j]<arr[minIndex]){
				minIndex = j;
			}
		}
		if(minIndex !== i){
			temp = arr[i];
			arr[i] = arr[minIndex];
			arr[minIndex] = temp;
		}
	}
	return arr;
}

插入排序

//外层循环：1<=i<len; i++;
//内层循环：记录arr[i],当左边默认排好序的数组中的数比arr[i]大时，将它们左移

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

快速排序

//注意：需要加上if(arr.length <=1) return arr;
//否则会导致栈溢出
function quickSort(arr){
	if(arr.length <= 1) return arr;
	var num = Math.floor(arr.length/2);
	var numValue = arr.splice(num,1);
	var left = [];
	var right = [];
	//此处判断条件为i<arr.length;不能是i<len;因为前面已经进行过splice操作，此时的len与arr.length并不相等
	for(var i=0; i<arr.length; i++){
		if(arr[i]<numValue){
			left.push(arr[i])
		}else{
			right.push(arr[i])
		}
	}
	return quickSort(left).concat(numValue,quickSort(right))
}

希尔排序

function shellSort(arr){
    // 1.获取数组的长度
    var length = arr.length

    // 2.根据长度计算增量
    var gap = Math.floor(length / 2)

    // 3.增量不断变量小, 大于0就继续排序
    while (gap > 0) {
        // 4.实现插入排序
        for (var i = gap; i < length; i++) {
            // 4.1.保存临时变量
            var j = i
            var temp = arr[i]

            // 4.2.插入排序的内层循环
            while (j-gap>=0 && arr[j - gap] > temp) {
                arr[j] = arr[j - gap]
                j -= gap
            }

            // 4.3.将选出的j位置设置为temp
            arr[j] = temp
        }
      
        // 5.重新计算新的间隔
        gap = Math.floor(gap / 2)
    }
    return arr;
}

归并排序

//归并排序
//分治法
//先将一个数组分为左右两个数组		
function mergeSort(arr){
	var len = arr.length;
	if(len<2) return arr;
	var middle = Math.floor(len/2);
	var left = arr.slice(0,middle);
	var right = arr.slice(middle);
	return merge(mergeSort(left),mergeSort(right));
}

//将左右两个数组排序后以result返回
function merge(left,right){
	var result = [];

	while(left.length>0 && right.length>0){
		if(left[0]<=right[0]){
			result.push(left.shift());
		}else{
			result.push(right.shift());
		}
	}

	while(left.length){
		result.push(left.shift());
	}

	while(right.length){
		result.push(right.shift());
	}
	return result;
}