数组排序相关

1.sort 方法

sort()对数组排序，不开辟新的内存，对原有数组进行调换,即影响原数组。

1.1简单排序

<script>
   var arr=new Array(1,5,4,3);
   arr.sort();
   console.log(arr.join); //[1,3,4,5];
</script>

问题: 由简单数字组成的数组不可以用这种方法排序

例如：var arr=[12,3,44,5];

        console.log(arr.sort());

       结果是： [12,3,44,5];

  因为js默认比较函数是把要排序的元素都视为字符串，不能在比较这些元素之前先检测他们的类型，所以按字符串排序。

1.2自定义排序

<script>
   var arr=new Array(1,5,4,3);
   arr.sort(function(a,b){
     return b-a;
  });
   console.log(arr); 
</script>

a,b表示数组中的任意两个元素，如果返回值大于0，b在前，a在后，按从大到小排序。

 返回值小于0，b在后，a在前，按从小到大排序。

 return a-b 按从小到大排序，b-a按从大到小排序。

参考文章:http://www.cnblogs.com/longze/archive/2012/11/27/2791230.html

 

2.冒泡排序

 

 function bubbleSort(array){

    var i=0,len=array.length,j,d;

    for(;i<len;i++){

     for(var j=0;j<len;j++){

        if(array[i]<array[j]){

        d=array[i];array[j]=array[i];array[i]=d;

        }

     }

   }

  return array;

}

3.插入排序  从下标1开始 每增1项排序依次，越往后遍历次数越多

var arr=[1,6,4,3,8];
  function sort1(array){
    var len=array.length,i,j,tmp,result;
    //设置数组副本
   result=array.slice(0);
   for(var i=1;i<len;i++){
      tmp=array[i];
      j=i-1;
      while(j>=0 && tmp<result[j]){
         result[j+1]=result[j];
        j--;
      }
     result[j+1]=tmp;
  }
  return result;
   
 }

4.二分法插入排序

//现在有序区通过二分查找的方法找到移动元素的起始位置，然后通过这个起始位置将后面的所有元素后移。

function sort2(array){
   var len=array.length,i,j,tmp,low,high,mid,result;
    result=array.slice(0);
     for(var i=0;i<len;i++){
      tmp=result[i];
      low=0;
      high=i-1;
      while(low<=high){
        mid=parseInt((low+high)/2,10);
        if(tmp<result[mid])high=mid-1;
        else low=mid+1;
       }
     for(var j=i-1;j>high+1;j--){
          result[j+1]=result[j];
       }
     result[j+1]=tmp;
    }

   return result;

}

还有很多，今天先学习到这里。原文请戳这里：http://www.jianshu.com/p/7e6589306a27

 

 

// 2017-5-27

今天继续学习哈。。。

5.冒泡排序

排序思路：遍历数组，每次遍历就将最大(或最小)值推至最前，越往后遍历查询次数越小，跟插入排序刚好相反。

//冒泡排序，每次将最小元素推至最前
function sort4(array){
   var len=array.length,i,j,tmp,result;
   result=array.slice(0);
   for(var i=0;i<len;i++){
      for(var j=len-1;j>i;j--){
        if(result[j]<result[j-1]){
           tmp=result[j-1];
            result[j-1]=result[j];
            result[j]=tmp;
         }
       }
   }
return result;
 
}

5.冒泡排序改进

当一次遍历前后数组不产生变化时，说明该数组已经有序，结束排序。

//如果在某次的排序中没有出现交换的情况
//那么说明在无序的元素已经有序了，可以直接返回。
function sort5(array){
   var len=array.length,i,j,tmp,exchange,result;
   result=array.slice(0);
   for(i=0;i<len;i++){
      exhange=0;
     for(j=len-1;j>i;j--){
          if(result[j]<result[j-1]){
            tmp=result[j];
          result[j]=result[j-1];
          result[j-1]=tmp;
          exchange=1;
         }
      }
    if(!exchange)return result;
  }
return result;
}

6.快速排序

   6.1 在数据集之后，选择一个元素作为“基准”(pivot);

   6.2 所有小于"基准"的元素，都移到"基准"的左边;所有大于"基准"的元素，都移到"基准"的右边。

  6.3对"基准"左边和右边的两个子集，不断重复第一步和第二步，直到所有子集只剩下一个元素为止。

function sort6(array){
   var tmp_array=array.slice(0),result,
   quickSort=function(arr){
     if(arr.length<=1){return arr;}
      var pivotIndex=Math.floor(arr.length/2);
      var pivot=arr.splice(pivotIndex,1)[0];
      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));
   };
    result=quickSort(tmp_array);
    return result;
}