js排序算法集合

一:快速排序

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

2：分区过程：将比这个“基准”大的数全放到“基准”的右边，小于或等于“基准”的数全放到“基准”的左边。

3：再对左右区间重复第二步，直到各区间只有一个数。

var quickSort = function(arr) {  //快速排序
		if (arr.length <= 1) { return arr; }
		var pivotIndex = Math.floor(arr.length / 2);   //基准位置（理论上可任意选取）
		var pivot = arr.splice(pivotIndex, 1)[0];  //基准数
		console.log(pivotIndex,pivot)
		var left = [];
		var right = [];
		for (var i = 0; i < arr.length; i++){
			if (arr[i] < pivot) {
				left.push(arr[i]);
			} else {
				right.push(arr[i]);
			}
		}
		return quickSort(left).concat([pivot], quickSort(right));  //链接左数组、基准数构成的数组、右数组
};
	
var list = [12,68,1,6,89,888,56,3]
console.log(quickSort(list))

二:冒泡排序

1：比较相邻的两个元素，如果前一个比后一个大，则交换位置。
2：比较完第一轮的时候，最后一个元素是最大的元素。
3：这时候最后一个元素是最大的，所以最后一个元素就不需要参与比较大小。

function bSort(arr) {
  var len = arr.length;
  for (var i = 0; i < len-1; i++) {
    for (var j = 0; j < len - 1 - i; j++) {
         // 相邻元素两两对比，元素交换，大的元素交换到后面
        if (arr[j] > arr[j + 1]) {
            var temp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
    }
  }
  return arr;
}

//举个数组
myArr = [20,18,27,19,35];
//使用函数
bSort(myArr)

三:选择排序

1：在未排序序列中找到最小（大）元素，存放到排序序列的起始位置

2：从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

3：重复第二步，直到所有元素均排序完毕。

var selectionSort = function(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;                 // 将最小数的索引保存
                }
            }
            temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
        return arr;
};

console.log(selectionSort([85, 24, 63, 45, 17, 31, 96, 50]));

四:sort()排序

1.不传参数，将不会按照数值大小排序，按照字符编码的顺序进行排序；

        var arr = ['General','Tom','Bob','John','Army'];
        var resArr = arr.sort();
        console.log(resArr);//输出   ["Army", "Bob", "General", "John", "Tom"]
        
        var arr2 = [30,10,111,35,1899,50,45];
        var resArr2 = arr2.sort();
        console.log(resArr2);//输出   [10, 111, 1899, 30, 35, 45, 50]
2.传入参数，实现升序，降序；

        var arr3 = [30,10,111,35,1899,50,45];
        arr3.sort(function(a,b){
            return a - b;
        })
        console.log(arr3);//输出  [10, 30, 35, 45, 50, 111, 1899]
        
        var arr4 = [30,10,111,35,1899,50,45];
        arr4.sort(function(a,b){
            return b - a;
        })
        console.log(arr4);//输出 [1899, 111, 50, 45, 35, 30, 10]
3.根据数组中的对象的某个属性值排序；

        var arr5 = [{id:10},{id:5},{id:6},{id:9},{id:2},{id:3}];
        arr5.sort(function(a,b){
            return a.id - b.id
        })
        console.log(arr5);
        //输出新的排序
        //        {id: 2}
        //        {id: 3}
        //        {id: 5}
        //        {id: 6}
        //        {id: 9}
        //        {id: 10}
4.根据数组中的对象的多个属性值排序，多条件排序；

        var arr6 = [{id:10,age:2},{id:5,age:4},{id:6,age:10},{id:9,age:6},{id:2,age:8},{id:10,age:9}];
        arr6.sort(function(a,b){
            if(a.id === b.id){//如果id相同，按照age的降序
                return b.age - a.age
            }else{
                return a.id - b.id
            }
        })
        console.log(arr6);
        //输出新的排序
        //        {id: 2, age: 8}
        //        {id: 5, age: 4}
        //        {id: 6, age: 10}
        //        {id: 9, age: 6}
        //        {id: 10, age: 9}
        //        {id: 10, age: 2}