js算法排序

一、选择算法排序（算法时间复杂度为O(n²)级别）

选择排序就是选择数组中的最小的树，依次排序。第一次选择最小的数放在第一位，第二次从剩余的元素中寻找最小的元素放在第二位，第三次在剩余的数中选择最小的数放在第三位，依次类推

function getMInDate(arr){
		var minIndex;
        var minValue;
		for(var i=0;i<arr.length;i++){
			minIndex=i;
            for(var j=i+1;j<arr.length;j++){
                if(arr[j]<arr[minIndex]){
                  minIndex=j;
                }
            }
             minValue=arr[i];
                  arr[i]=arr[minIndex];
                  arr[minIndex]=minValue;
		}
		return arr;

	}

　　

二、插入算法排序（算法时间复杂度为O(n²)级别）

类似于打牌，选择合适的插入位置。第一个数位第一个元素，将第二个元素与前一个元素进行对比，如果小了，就交换位置。依次往前进行对比。将第三个元素与前一个元素进行对比，如果小于前一个元素，就与前一个元素进行交换，依次往前进行对比。依次类推。

function insertDate(arr){
		var _value;
       for(var i=1;i<arr.length;i++){
          for(var j=i;j>0;j--){
              if(arr[j]<arr[j-1]){
              	 _value=arr[j];
              	 arr[j]=arr[j-1];
              	 arr[j-1]=_value;
              }
          }
       }
       return arr;
	}　　

插入排序的优化：

由于前后元素用赋值的方法进行替换，比较耗性能。可以将要对比的元素复制，依次与前面的元素进行对比，如果这个元素比前一个元素小，前一个元素就等于前前个元素，依次遍历，如果复制的元素比对比的元素要大，就将复制的元素赋值给对比的元素。依此类推。

//插入排序的优化1 减少交换
	function cloneDate(arr){
		var e;
		var _value;
		var j;
       for(var i=1;i<arr.length;i++){
       	  e=arr[i];
       	  j=i;
          while(j>=1 && arr[j-1]>e){
          	arr[j]=arr[j-1];
          	j--;
          }
          arr[j]=e;
       }
       return arr;
	}

	//插入排序的优化2 减少交换
	function cloneDate3(arr){
		var e;
       for(var i=1;i<arr.length;i++){
       	  e=arr[i];
          for(var j=i;j>0;j--){
             if(arr[j-1]>e){
               arr[j]=arr[j-1];
             }else{
             	break;
             }
          }
          arr[j]=e;
       }
       return arr;
	}

　　

三、归并算法排序（算法时间复杂度为O(nlogn)级别）

自顶向下，使用递归。比较简洁

1.先将C划分为两个数组A和B（即把数组C从中间分开）
2.再分别对数组A、B重复步骤1的操作，逐步划分，直到不能再划分为止(每个子数组只剩下一个元素)，这样，划分的过程就结束了。
如：              [12 20 30 21 15 33 26 19 40 25]
划分为:  [12 20 30 21 15]                [33 26 19 40 25]
           [12 20]      [30 21 15]       [33 26]       [19 40 25]
         [12]  [20]   [30]  [21 15]     [33]  [26]    [19]    [40 25]
         [12]  [20]   [30] [21] [15]    [33]  [26]    [19]   [40] [25]
3.然后从下层往上层不断合并数组，每一层合并相邻的两个子数组，合并的过程是每次从待合并的两个子数组中选取一个最小的元素，然后把这个元素放到合并后的数组中，不断重复直到把两个子数组的元素都放到合并后的数组为止。

4.依次类推，直到合并到最上层结束，这时数据的排序已经完成了。

//归并算法
	function mergeSort(arr){
      if(arr.length<2){
         return arr;
      }
      //设立一个中间值
      var middle=parseInt(arr.length/2);
      //第一个值与middle之间的左子列
      var left=arr.slice(0,middle)
      //第middle+1个值到最后的右子列
      var right=arr.slice(middle);
      if(left=="undefined" && right=="undefined"){
         return false;
      }
      return merge(mergeSort(left),mergeSort(right));
	}

	function merge(left,right){
       var result=[];
       //左右子列有值
       while(left.length && right.length){
          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;
	}

　　

暂时写了三种，后续补充。