关于一些基本排序的实现

• 冒泡排序
• 原理：第一次遍历arry.length 将最小的数字放在第一位，第二次遍历arry.length -1 将最小的数字放在第二位 ... ...
• 最坏时间复杂度：O(n^2)
• 稳定性:稳定（稳定与不稳定的区别在于值相等的时候元素的位置是否和排序前一致）
• 空间复杂度：O(1)
• 示例：

    var arry=[1,3,234,4,2,6,9,8,0];
    console.log(arry);
    function rank(arry){
      var i ,j ,tmp,result;
      result=arry.slice(0);
         for(i=0;i<arry.length;i++){
           for(j=arry.length-1;j>i;j--){
            if(result[j]<result[j-1]){
              tmp=result[j-1];
              result[j-1]=result[j];
              result[j]=tmp
            } 
           }
         }
      return result;
    }
    console.log(order(arry));

• 快速排序
• 原理：从数组中取一个值，并将其与剩余的值进行比较，小于基准的值放左边，大于基准值的放右边，并且再次对两边的数进行快速排序，直至左右两边剩余一个元素。
• 最坏时间复杂度：O（n^2） 当选择的基准值为最大值或最小值时
•  稳定性：不稳定
• 平均时间复杂度：O(n*log₂n)
• 示例

  function quick(arr){  //这个方法其实是将一个数组按照取中间值然后左右排序
      var len=arr.length;  
    console.log(len);
      if(len<=1){  
          return arr;  
      }  
      var index=Math.floor(len/2),//向下取整 根据中间的值作为比较对象  
              pindex=arr.splice(index,1)[0],//需要删除中间值，以缩小排序的数组大小  
              left=[],//定义左右两个数组 左大右小  
              right=[];  
    
      for(var i=0;i<len-1;i++){ //遍历整个数组 大放右 小放左  
          if(arr[i]>=pindex){  
              right.push(arr[i]);  
          }else{  
              left.push(arr[i]);  
          }  
      }  
      return quick(left).concat([pindex],quick(right)); //继续递归并将数组合并  
  }  
      console.log(quick(arry));

• 插入排序
  • 原理：

    从数组第二个值开始，依次将后续的数值经过比较与前面排序后的序列比较后插入，如图：

    

    最坏时间复杂度：O(n²)：当数组是从大到小排列时，插入第一个元素需要移动一次，插入第二个需要移动两次，以此类推，所以一共为1+2+3+4+......+（n-1）,与冒泡排序相同

  • 最优时间复杂度：最好的情况是数组已经由小到大排好，则为O(n)
  • 稳定性：稳定
  • 空间复杂度：O(1)
  • 示例

    function insert(array) {  
        var len = array.length,  
                i, j, tmp, result;  
        // 设置数组副本  
        result = array.slice(0);  
        for(i=1; i < len; i++){ //数组第一个值为默认的衡量值  
            tmp = result[i];      //从第二个值开始与之前的值进行比较  
            j = i - 1;           //之前已经排好序的数组的最后一个  
            while( tmp < result[j]){   //与最后一个值进行比较，如果小于  
                result[j+1] = result[j];       //则将最后一个值后移一位  
                j --;                          //j往前移动一位  
            }  
            result[j+1] = tmp;                 //比较完成 这时result[j]<temp或者j已经为-1，则将tmp的值赋给j+1  
        }  
        return result;  
    }  

    原文来自http://blog.csdn.net/supercoooooder/article/details/52153923  代码都敲了一遍加深自己理解