• JavaScript排序算法——堆排序


    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    <html xmlns="http://www.w3.org/1999/xhtml">
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <title>堆排序</title>
    <!--<link rel="stylesheet" type="text/css" href="../style/fdt.css" />-->
    <script type="text/javascript" src="../js/jquery-1.6.2.min.js"></script>
    <script type="text/javascript" src="../js/jquery.easydrag.handler.beta2.js"></script>
    <script type="text/javascript">
    
        $(document).ready(
            function() { 
                
                // var array_1 = [9,8,7,6,5,4,3,2,1];
                var array_1 = [4,5,3,1,2,0];
                alert(array_1);
                /*heapSort*/
                alert(heapSort(array_1));
    
            }
        ); 
    
    
    
    </script>
    
    <style type="text/css">
        
        * { padding:0; margin:0; }
    
        body {
            padding: 100px;
            font-size: 15px; 
        }
    
        
    
    
    </style>
    
    
    <script type="text/javascript">
        function heapSort(elements){
            
    
    
            //调整函数
            function headAdjust(elements, pos, len){
              //将当前节点值进行保存
              var swap = elements[pos];
    
              //定位到当前节点的左边的子节点
              var child = pos * 2 + 1;
    
              //递归,直至没有子节点为止
              while(child < len){
                //如果当前节点有右边的子节点,并且右子节点较大的场合,采用右子节点和当前节点进行比较
                if(child + 1 < len && elements[child] < elements[child + 1]){
                  child += 1;
                }
    
                //比较当前节点和最大的子节点,小于则进行值交换,交换后将当前节点定位于子节点上
                if(elements[pos] < elements[child]){
                  elements[pos] = elements[child];
                  pos = child;
                  child = pos * 2 + 1;
                }
                else{
                  break;
                }
    
                elements[pos] = swap;
              }
            }
    
            //构建堆
            function buildHeap(elements){
              //从最后一个拥有子节点的节点开始,将该节点连同其子节点进行比较,
              //将最大的数交换与该节点,交换后,再依次向前节点进行相同交换处理,
              //直至构建出大顶堆(升序为大顶,降序为小顶)
              for(var i=elements.length/2; i>=0; i--){
                headAdjust(elements, i, elements.length);
              }
            }
    
            function sort(elements){
              //构建堆
              buildHeap(elements);
    
              //从数列的尾部开始进行调整
              for(var i=elements.length-1; i>0; i--){
                //堆顶永远是最大元素,故,将堆顶和尾部元素交换,将
                //最大元素保存于尾部,并且不参与后面的调整
                alert(elements);
                var swap = elements[i];
                elements[i] = elements[0];
                elements[0] = swap;
                alert(elements);
                //进行调整,将最大的元素调整至堆顶
                headAdjust(elements, 0, i);
                alert(elements);
              }
            }
    
            sort(elements);
            return elements;
            
    
        }
    
    
    </script>
    
    
    </head>
    
    
    
    
    <body>
        <div>堆排序</div>
    </body>
    </html>
  • 相关阅读:
    限制容器对CPU的使用
    限制容器对内存的使用
    一张图搞懂容器所有操作
    TQ2440学习笔记——Linux上I2C驱动的两种实现方法(1)
    pr_debug、dev_dbg等动态调试三
    pr_debug、dev_dbg等动态调试二
    TQ2440平台上LCD驱动的移植
    Android如何通过shareduserid获取系统权限
    基于Android的串口聊天室 (基于tiny4412) 一
    Java中的泛型方法
  • 原文地址:https://www.cnblogs.com/tonglin0325/p/5179413.html
Copyright © 2020-2023  润新知