JavaScript实现排序算法

// 寄生构造方式实现继承
  var MyArray=function(){
    var arr=new Array();
    // 添加值
    arr.push.apply(arr,arguments);//和下面的循环一个效果
    // for (var i = 0; i < arguments.length; i++) {
    //   arr.push(arguments[i]);
    // }

  // ===========================插入排序=====================================
    arr.insertSort=function(){
     var position,
         current;//当前待排序的元素
      for (var i = 1; i < arr.length; i++) {

           if (arr[i]<arr[i-1]) {
              position=i;
              current=arr[i];
              do{
                arr[position]=arr[position-1];//移动数据
                position--;//空位置，用来移动数据的
              }while(position>0 && arr[position-1]>current)
              arr[position]=current;
           }else{ //当前待排序的值>=上一个已排序的值
             // 不用移动，直接进入下一个循环
           }
      }
    };


  // =======================希尔排序==============================
  // 是基于插入排序的变种(以下说的排序都是插入排序)
  // 对待排序的数组进行多次分组排序，最后在对这个数组进行整体合并排序
  // 
  // 那么有两个问题：
  // 1、怎么分组
  // 这里的分组并不是真的新创建新的数组容器来将整个数组进行分组，在原数组上用一些标记来进行划分
  // 例如数组：[1,2,33,5,67,0,6]
  // 我们取下标增量imcrement=3,2,1 分别对这个数组进行3次划分,并且对这3次划分的各个数组进行一次插入排序
  // 增量为3：[1,5,6] [2,67] [33,0] ——排序——>[1,5,6] [2,67] [0,33]——新数组——>[1,2,0,5,67,33,6]
  // 增量为2：[1,0,67,6] [2,5,33]  ——排序——> [1,0,6,67] [2,5,33] ——新数组——> [1,2,0,5,6,33,67]
  // 增量为1：[1,2,0,5,6,33,67]   ——排序——> [0,1,2,5,6,33,67]
  // 
  // 注：每次划分都是在排序后的新循序进行划分
  // 这里的排序方法和之前的插入排序稍有区别，排序的时候"移位"使用的是swap方式的数值交换，因为不能影响到其它的分组。
  // 2、怎么合并
  // 这里分组并没有把数组分割，当使用增量为1的时候就是对整个数组进行合并排序


  arr.shellSort=function(){
    var increment=arr.length;
    do{
      increment= parseInt(increment/3)+1;//这里的取整很重要
      for (var i = 0; i <increment; i++) {
          _inerSort(i,increment);
      }
      if (increment==1) {break;}
    }while(increment>1)
  };
  function _inerSort(start,gap){
    var tmp;
    for (var i = start+gap; i < arr.length; i+=gap) {
       if (arr[i]<arr[i-gap]) {
          tmp=arr[i];
          arr[i]=arr[i-gap];
          arr[i-gap]=tmp;
       }
    }
  }

  // ================start of 选择排序========================
   function _swapFun(low,high){
      var tmp=arr[low];
      arr[low]=arr[high];
      arr[high]=tmp;
   }
   function _findMax_index(low,high){
    var  max_index=low;//if low==high max_index=low
    for (var i = low+1; i < high+1; i++) {
        if (arr[max_index]<arr[i]) {
          max_index=i;
        }
    }
    return max_index;
   }
   arr.selectSort=function(){
         var max_key;
         for (var i = arr.length-1; i >0 ; i--) {
            max_key=_findMax_index(0,i);
            _swapFun(max_key,i);
         }
   };
  // ======================end of 选择排序================================
  //

　　   

// 快速排序
function _partition(low,top){
var mid=low;
pivot=arr[low];
for (var i = low+1; i<top+1; i++) {
if (arr[i]<pivot) {//这个小于号很重要，不能用小于等于
var tmp=arr[i];
arr.splice(i,1);
arr.splice(low,0,tmp);
mid++;
}
}
// var mid=arr.indexOf(pivot);//这个出问题了 有多个相同的值的时候
// console.log("mid="+mid);
return mid;
}

　　

  arr.quickSort=function(low,top){
   if (low>=top) {console.log("low:"+low+"top:"+top+"
");return;}
   var p=_partition(low,top);
     arguments.callee(low,p);
     arguments.callee(p+1,top);
  };

    return arr;
  };