数组的排序总结

数组的排序总结：

1.冒泡排序

	var arr =[7,3,5,7,9,2];
	console.log(arr);
	// 按照位置，确定比较次数
	    // 0-1,1-2,2-3,3-4      length-1-0
	    // 0-1,1-2,2-3          length-1-1
	    // 0-1,1-2              length-1-2
	    // 0-1                  length-1-3
	//确定行的循环
	for(var i=0;i<arr.length-1;i++){
		//确定列的循环
		for(var j=0;j<arr.length-1-i;j++){
			//两两比较；
			if(arr[j]>arr[j+1]){
				//交换
				var ls=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=ls;
				}
			}
		}
	console.log(arr);

2.选择排序

var arr = [9,8,7,5,6];
    console.log(arr);

    // 按照索引，先确定比较次数
    // 0-1,0-2,0-3,0-4      0~length-1
    // 1-2,1-3,1-4          1~length-1
    // 2-3,2-4              2~length-1
    // 3-4                  3~length-1

    // 每一轮比较过程中不交换，只找最小值，一轮结束后，才能确定最小值，再交换

    // 确定行的循环
    for(var i=0;i<arr.length-1;i++){
        // 每轮比较开始之前，假设最小值
        var ls = arr[i];
        // 保存最小值的索引
        var lsIndex = i;
        // 确定列的循环，注意 起点 和 终点
        for(var j=i+1;j<arr.length;j++){
            // 验证，是否是真正的最小值
            if(ls > arr[j]){
                // 如果不是，保存真正的最小值
                ls = arr[j];
                // 最小值的索引
                lsIndex = j;
            }
        }
        // 一轮结束后，确定了最小值，能拿到最小值的索引，交换
        // 先将第一位，放在最小值的位置
        arr[lsIndex] = arr[i];
        // 再将最小值，放在第一位
        arr[i] = ls;
    }

    console.log(arr);

3.插入法排序

• 将要排序的数组分成两部分，每次从后面的部分去除最小值的元素，插入到前一部分的适当位置。

	// Array
var arr = [10, 20, 40, 60, 60, 0, 30]
 
// 排序算法
for(var i = 0; i < arr.length; i++) {
 var n = i;
 while(arr[n] > arr[n+1] && n >= 0) {
     var temp = arr[n];
     arr[n] = arr[n+1];
     arr[n+1] = temp;
     n--;
 }
}
 
// 打印排序后的数组
console.log(arr)//[0, 10, 20, 30, 40, 60, 60]

4.快速排序

• 快速排序是运用递归进行循环调用函数从而使得数组进行排序

	function quickSort(arr){
	  if(arr.length <= 1) return arr;
	  var Temp = Math.floor(arr.length/2);
	  var left = [],right = [];
	  var num = arr.splice(Temp,1)[0];
	  for(var i = 0;i < arr.length;i ++){
	    if(arr[i] < num){
	      left.push(arr[i]);
	    }
	    else {
	      right.push(arr[i]);
	    }
	  }
	  return quickSort(left).concat(num,quickSort(right));
	}
	var arr=[5,2,1,10,8,12,40,26,30];
	console.log(quickSort(arr)); //[1, 2, 5, 8, 10, 12, 26, 30, 40]

• 其原理是首先创建一个递归函数，也就是函数的返回值还是函数本身，直到符合条件之后递归函数停止运行，像这个函数就是当时arr数组的长度小于等于1的时候该递归函数停止运行。基本原理就是先找到数组中的中间那个元素的索引，如果数组长度是双数，那么就默认向上取值，也就是默认取数组长度/2+1位索引，在根据索引去的数组中间的值，然后创建两个空数组，用来放置比该元素小的值和比该元素大的值，在循环数组进行判断，如果数组的元素小于该中间位置元素的值，就放到左边数组，反之放到右边的数组，在函数中返回值设置为左边数组+中间的值+右边数组的拼接新数组，然后再根据递归对左边和右边的数组分别进行刚才的操作，直到数组的长度小于或者等于1，这时候停止，这时候调用函数之后，传入一个数组，就会自动返回数组排序之后的新数组，这就是快速排序的原理。

5.sort排序

• sort默认排序是按照字符来排序的，也就是ascii字母排序的，如果想要改变默认的排序方式，就要给他加一个自定义排序规则

// sort排序
var arr=[8,12,312,4,5];
function sortArray(n1,n2){
    return n1-n2;
}
arr.sort(sortArray); 
console.log(arr) //[4, 5, 8, 12, 312]

6.对象数组排序(数组套对象）

	//对象数组排序
	var arr = [
	 {name:'syy', age:0},
	 {name:'wxy', age:18},
	 {name:'slj', age:8},
	 {name:'wj', age:20}
	];
	 
	// 排序方法
	function compare(property) {//property:根据什么属性排序
	 return function(a,b){
	  var value1 = a[property];
	  var value2 = b[property];
	  /*
	  * value2 - value1; ——> 降序
	  * value1 - value2; ——> 升序
	  */
	  return value1 - value2;//升序排序
	 }
	}
	 
	// 打印排序后的数组
	console.log(arr.sort(compare('age')))
	/*
	0: {name: "syy", age: 0}
	1: {name: "slj", age: 8}
	2: {name: "wxy", age: 18}
	3: {name: "wj", age: 20}

7.希尔排序（性能最好）

如果要从大到小排列，则 while(arr[n] > arr[n - interval] && n > 0) 。

    // 希尔排序算法
   function xier(arr){
    var interval = parseInt(arr.length / 2);//分组间隔设置
    while(interval > 0){
     for(var i = 0 ; i < arr.length ; i ++){
      var n = i;
      while(arr[n] < arr[n - interval] && n > 0){
       var temp = arr[n];
       arr[n] = arr[n - interval];
       arr[n - interval] = temp;
       n = n - interval;
      }
     }
     interval = parseInt(interval / 2);
    }
    return arr;
   }
    
   // Array
   var arr = [10, 20, 40, 60, 60, 0, 30]
    
   // 打印排序后的数组
   console.log(xier(arr))//[0, 10, 20, 30, 40, 60, 60]