堆排序 js实现

/* 最近 在看c语言版的数据结构，c用法着实很难，于是按照意思，仿照c语言写了javascript版的三种排序方法！仅供大家一起学习和参考
   后续比较难的归并排序，和快速排序，以后再说 ，废话不说，直接边代码边讲解！*/
<script type="text/javascript">
   var a=[0,9,8,7,6,5,4,3,2,1];

   /*希尔排序，
   将表分为几段长度，分别进行排序，然后进行总的排序*/
   function shellSort(t)
   {
       var i,j,temp;
       var increment=t.length;
       do
       {
         //取到希尔跳跃 因为js取到的是浮点数，我们要把它转化成不大于该值得整数
           increment=Math.floor(increment/3+1);
           for(i=increment;i<t.length;i++)//循环便利increment到t.length的值
           {
               if(t[i]<t[i-increment]){//前面值大于后面值 则将t[i]插入有序增量子表
                   temp=t[i];//先将小的数值存储
                   for(j=i-increment;j>=0&&temp<t[j];j-=increment){//跳值便利前面的数值，将比找到的这个小的值大的值往后移
                         t[j+increment]=t[j];//不断移动，找到这个temp应该插入的位置
                          }
                 t[j+increment]=temp;//插入该位置！
                   }
               }
           }
       while(increment>1)
   }

   /*
   js版插入排序
   形如我们打扑克一样，先取到的扑克牌（数字）作为标准，然后拿到下一个扑克牌（数字），比对前面的数字，将它插入到比前面的扑克牌大，
   比后面的数值小的位置，因为前面已经是有序的，只需要从后往前遍历，把比它大的顺序后移一位，空出位置，插到空位
   */
   function insert(l){
       var temp,len=l.length;
       for(var i=1;i<len;i++){//以第一个为基准，遍历以后的进行插入
           if(l[i]<l[i-1]){//当当前数字 小于前一个，就把前面的数字比当前l[j]大的向后移动移动一位；空出最后一个比l[j]大的位置
               temp=l[i];
               for(var j=i-1;j>=0&&l[j]>temp;j--){
                   l[j+1]=l[j];
                   }
                   l[j+1]=temp;//插到正确位置！此时j指针又向后移动了一位，才跳出循环，所以需要j+1；
               }
           }
       }
       /*
       堆排序：原理是，将数组看成一个完全二叉树；
       形如：     0
             1      2
           3   4  5   6
        7   8 9 10
       只需要遍历一半的值，进行循环比对，把最大的节点赋值到根的位置，然后把根部的值和最后一个数值交换，排除最后一个数值
       继续打造大顶堆，最终形成一个小顶堆的算法！
       构造堆排序 s为最小值，m为最大值
       */
       function HeapAdjust(l,s,m){//使用调整大顶堆进行排序，将s到m之间的数值调整为大顶堆！
           var temp=l[s];//将大顶堆顶值负值给temp；
           for(var j=2*s+1;j<m;j=2*j+1)//由于下标是0；这里只从0，1，3，5...每列的第一个数字开始便利就行
           {
               if(j<m&&l[j]<l[j+1])//如果当前下标的值比下一个下标的数值比下一个小（我们是要找最大的那个），则就使j+1指向那个数字
                   ++j;
               if(temp>=l[j])//如果堆顶的值大于当前j下标的值，就不用再找了。跳出循环
                 break;
               l[s]=l[j];//小于j下标的值，就把l[j]复制给l[s]
               s=j;//s就指向当前j的位置，为下步把顶值赋值到这个位置做准备（循环完之前，先不赋值）
               }
              l[s]=temp;//最后赋值给l[s]（s指向现在找到的最大的大堆顶的值）
           }
       function HeapSort(l)
       {
           for(var i=l.length/2;i>=0;i--)//首先构造一个标准的大堆顶，只需要便利二叉树一半的节点，就能够把大堆顶构造出来
               HeapAdjust(l,i,l.length);
           for(var i=l.length;i>0;i--){//构造完之后 把堆顶的值和最后一个互换，然后 排除最后一个继续进行打造大堆顶！
               swap(l,0,i-1);
               HeapAdjust(l,0,i-2);
           }
       }
       function swap(l,i,j){
           var temp=l[i];
           l[i]=l[j];
           l[j]=temp;
       }
      shellSort(a);
       //insert(a);
   console.log(a);
</script>