日日操夜夜添-日日操影院-日日草夜夜操-日日干干-精品一区二区三区波多野结衣-精品一区二区三区高清免费不卡

1. 冒泡排序算法實現（JAVAscript）

//冒泡排序算法(JavaScript)
//author：Hengda
//arr數組
//mode  false 升序 ture 降序
function bubbleSort( arr, mode ){

    var i, j, temp, len = arr.length;
    for( i = len - 1 ; i > 0; i-- ){
        for( j = 0; j < i; j++ ){
            if( mode ? arr[ j + 1 ] < arr[ j ] : arr[ j + 1 ] > arr[ j ] ){
                temp = arr[ j + 1 ];
                arr[ j + 1 ] = arr[ j ];
                arr[ j ] = temp;
            }
        }
    }
    return arr;
}

2. 計數排序算法實現（javascript）

//計數排序算法(javascript)
//author：Hengda
//arr數組
//mode  false 升序 ture 降序
function countingSort( arr, mode ){
    //i,j為控制變量，temp為交換變量，len為數組的長度
    var i, j, temp, len = arr.length;
    var countArr = [];//用于原始數組中統計各元素出現的次數
    var fillPos;//標記下一個回填位置
    var countArrLen;//計數數組的長度
    //統計
    for( i = 0; i < len; i++ ){
        if( countArr[ arr[ i ] ] != null ){
            countArr[ arr[ i ] ] ++;
        }else{
            countArr[ arr[ i ] ] = 1;
        }
    }

    //將數據重新排列回填到原始數組中
    //統計
    var fillPos = 0;//回填起始位置
    var countArrLen = countArr.length;

    if( mode ){
        //
        for( i = countArrLen - 1; i >=0; i-- ){
            //
            if( countArr[ i ] != null ){
                //回填countArr[ i ]個當前值i到原始數組，回填起始位置為fillPos
                for( j = 0; j < countArr[ i ]; j++ ){
                    arr[ fillPos++ ] = i;
                }
            }
        }

    }else{
        //
        for( i = 0; i < countArrLen; i++ ){
            //
            if( countArr[ i ] != null ){
                //回填countArr[ i ]個當前值i到原始數組，回填起始位置為fillPos
                for( j = 0; j < countArr[ i ]; j++ ){
                    arr[ fillPos++ ] = i;
                }
            }
        }
    }

    //排序完成
    return arr;
}

3. 堆排序算法實現（javascript）

//功能：     堆排序(javascript)
//author：   Hengda
//arr：      待排序數組
//mode：     true 從大到小排序，false 從小到大排序
function heapSort( arr, mode ){
    var len = arr.length;   //數組的長度
    var temp;               //用于交換節點值
    var endHeapNodeNo;      //堆末尾節點在數組中的下標

    //將數組調整為二叉堆
    for( var i = Math.floor( len / 2 ) - 1; i >= 0; i-- ){
        heapNodeSink( arr, i, len, mode );
    }

    for( var heapLen = len; heapLen > 0; heapLen-- ){
        endHeapNodeNo = heapLen - 1;//堆的最后一個節點的序號

        //交換堆頂和堆尾元素
        temp = arr[ endHeapNodeNo ];
        arr[ endHeapNodeNo ] = arr[ 0 ];
        arr[ 0 ] = temp;

        //對除了堆尾元素組成的堆進行堆頂下沉操作
        heapNodeSink( arr, 0,  heapLen - 1, mode );
    }
    return arr;
}

//堆中某節點按升序或者降序遞歸下沉
//author：   Hengda
//arr：      待排序數組
//nodeNo：   二叉樹中指定節點的序號/堆數組中的下標
//heapLen：  堆的長度
//mode：     true 大的下沉，false 小的下沉
function heapNodeSink( arr, nodeNo, heapLen, mode ){

    var leftChild = ( nodeNo + 1 ) * 2 - 1; //做孩子
    var rightChild = leftChild + 1;         //右孩子
    var maxminNo = nodeNo;                  //最大值的序號
    var temp;                               //用戶變量值得交換

    if( mode ){
        //
        if( heapLen > leftChild && arr[ maxminNo ] > arr[ leftChild ] ){
            maxminNo = leftChild;//更新最大節點序號
        }
        if( heapLen > rightChild && arr[ maxminNo ] > arr[ rightChild ] ){
            maxminNo = rightChild;//更新最大節點序號
        }
    }else{
        if( heapLen > leftChild && arr[ maxminNo ] < arr[ leftChild ] ){
            maxminNo = leftChild;//更新最大節點序號
        }
        if( heapLen > rightChild && arr[ maxminNo ] < arr[ rightChild ] ){
            maxminNo = rightChild;//更新最大節點序號
        }
    }

    //最大值所在節點有變化，則交換
    if( maxminNo != nodeNo ){

        //交換
        temp = arr[ maxminNo ];
        arr[ maxminNo ] = arr[ nodeNo ];
        arr[ nodeNo ] = temp;

        //繼續下沉操作
        heapNodeSink( arr, maxminNo, heapLen, mode );
    }
}

4. 插入排序算法實現（javascript）

//插入排序算法(javascript)
//算法原理
//author：Hengda
//2020/1/25
//arr 待排序數組
//mode true 從大到小排列，false 從小到大排列
function insertionSort( arr, mode ){

    var i, j, temp, len = arr.length;//len為待排序數組長度 temp為交換變量 i j為控制變量。

    //從數組的第二個元素開始逐個往后處理。
    for( i = 1; i < len; i++ ){
        //將當前被處理元素值記錄下來。
        temp = arr[ i ];
        //以下標倒序逐一比較當前元素位置之前的所有元素，如果比當前元素大，則逐一向后覆蓋一個元素。
        for( j = i - 1; j >= 0 && ( mode ? arr[ j ] < temp : arr[ j ] > temp ); j-- ){
            arr[ j + 1 ] = arr[ j ];
        }
        //將點前被處理元素的值填入最終空缺的位置即 （j + 1） 注意這個 j 已經被for循環做了-1操作，所以這里需要+1。
        arr[ j + 1 ] = temp;
    }

    //遍歷完成后，整個數組即為有序數組。
    return arr;
}

5. 歸并排序算法實現（javascript）

//歸并排序算法(javascript)
//author：Hengda
//arr數組
//start 數組中待排序段落的起止位置，len為數據段的長度
//mode  false 升序 ture 降序
function mergeSort( arr, start, len ,mode){

    var i, j, temp;

    //計算左側數據段的位置和長度
    var lstart = start;
    var llen = Math.floor( len / 2 );

    //計算右側數據段的位置和長度
    var rstart = lstart + llen;
    var rlen = len - llen;

    //分別對左右分段進行進行插入排序
    if( llen > 4 ) mergeSort( arr, lstart, llen );
    if( rlen > 4 ) mergeSort( arr, rstart, rlen );

    //對當前數據段進行插入排序
    for( i = start + 1; i < len + start; i++ ){
        temp = arr[ i ];
        for( j = i - 1; j >= start && ( mode ? arr[ j ] < temp : arr[ j ] > temp  ); j-- ){
            arr[ j + 1 ] = arr[ j ];
        }
        arr[ j + 1 ] = temp;
    }
    return arr;
}

6. 選擇排序算法實現（javascript）

//選擇排序算法(javascript)
//author：Hengda
//arr數組
//mode  false 升序 ture 降序
function selectionSort( arr, mode ){
    //i,j為控制變量，miniMaxNo為標記發現的最大或者最小元素的下標，temp為交換變量，len為數組的長度
    var i, j, minMaxNo, temp, len = arr.length;
    //
    for( i = 0; i < len; i++ ){
        //當前位置初始為最小或最大數的位置
        minMaxNo = i;
        //遍歷后續所有元素與minMaxNo對應的元素做比較，如果比minMaxNo大或者小，則更新minMaxNo的值為新元素的下標
        for( j = i; j < len; j++ ){
            if( mode ? arr[ j ] > arr[ minMaxNo ] : arr[ j ] < arr[ minMaxNo ] ){
                minMaxNo = j;
            }
        }
        //將最終確定的最大或者最小值與當前被處理位置i對應的元素值做交換
        temp = arr[ minMaxNo ];
        arr[ minMaxNo ] = arr[ i ];
        arr[ i ] = temp;
    }
    //排序完成
    return arr;
}

7. 希爾排序算法實現（javascript）

//希爾排序算法(javascript)
//author：Hengda
//arr數組 
//mode  false 升序 ture 降序
function shellSort( arr, mode ){
    //1,j,k為控制變量，gap為分組間隙初始化為1，temp用于交換數據，len數組的長度
    var i, j, k, gap = 1, temp, len = arr.length;
    //計算合適的分組元素間隙，這里計算得到gap的最大值，這里的5也可以是其他數，值不同，實際排序速度也不同
    while( gap< len / 5 ){
        gap = gap*5 + 1;
    }

    //開始排序
    while( gap > 0 ){

        //以下按分組排序，該排序原理為插入排序，如看不明白，可參考插入排序算法邏輯
        for( i = gap; i < len; i++ ){
            temp = arr[ i ];
            for( j = i - gap; j >= 0 && ( mode ? arr[ j ] < temp : arr[ j ] > temp ); j -= gap ){
                arr[ j + gap ] = arr[ j ];
            }
            arr[ j + gap ] = temp; 
        }

        //縮小分組間隔值
        gap = Math.floor( gap / 5 );
    }

    return arr;
}

8. 快速排序算法實現（javascript）

//快速排序(javascript)
//author：Hengda
//arr數組
//start 待排序數據段的起始下標（含）
//end	待排序數據段終止下標（含）	
//mode	false 升序 ture 降序
function quickSort( arr, start, end, mode ){

    var i,j,temp;
    var divValue;

    if( start < end ){

        //初始化基準值
        baseValue = arr[ end ];
        j = start;

        //遍歷整段數據元素，小于等于基準值的放在基準準直左側（正序），大于等于基準值的放在基準值左側（倒序）
        for( i = start; i <= end ; i++ ){

            //與基準值作比較
            if( mode ? arr[ i ] >= baseValue : arr[ i ] <= baseValue ){

                //從左端開始依次排列放置，當前排列位置為$j，把原位置的元素向后交換
                temp = arr[ j ];
                arr[ j ] = arr[ i ];
                arr[ i ] = temp;
                //更新下一個應排列的位置
                j++;
            }
        }
        //循環中$j在最后的++操作并未使用，這里需要減去，使$j正確標記左右分界元素
        j--;

        //分界元素在兩端是，則靠近分界元素的一端無需再排序
        //分界元素也無需再參與排序，因為左側的一定小于等于分界元素，右側的也一定大于等于分界元素
        //分別對分界元素左右兩側的數據段繼續排序
        if( j > start ) quickSort( arr, start, j - 1, mode );
        if( j < end ) quickSort( arr, j + 1, end, mode );
    }
    return arr;
}

9. 測試排序1萬個無序數，耗時如下

//測試排序10000個數
testSort( 10000, false );
```
```javascript
jssort.html:388 正在生成 10000個無序數...
jssort.html:392 生成 10000個無序數完成
jssort.html:344 ---------
jssort.html:346 快速排序：
jssort.html:358 -正序耗時：: 22.447265625ms
jssort.html:372 -倒序耗時：: 7.83203125ms
jssort.html:344 ---------
jssort.html:346 希爾排序：
jssort.html:358 -正序耗時：: 7.2939453125ms
jssort.html:372 -倒序耗時：: 5.231689453125ms
jssort.html:344 ---------
jssort.html:346 計數排序：
jssort.html:358 -正序耗時：: 7.36083984375ms
jssort.html:372 -倒序耗時：: 7.77392578125ms
jssort.html:344 ---------
jssort.html:346 插入排序：
jssort.html:358 -正序耗時：: 9.529052734375ms
jssort.html:372 -倒序耗時：: 9.830078125ms
jssort.html:344 ---------
jssort.html:346 堆排序：
jssort.html:358 -正序耗時：: 8.35107421875ms
jssort.html:372 -倒序耗時：: 2.64990234375ms
jssort.html:344 ---------
jssort.html:346 歸并排序：
jssort.html:358 -正序耗時：: 82.681884765625ms
jssort.html:372 -倒序耗時：: 114.632080078125ms
jssort.html:344 ---------
jssort.html:346 選擇排序：
jssort.html:358 -正序耗時：: 96.762939453125ms
jssort.html:372 -倒序耗時：: 151.841064453125ms
jssort.html:344 ---------
jssort.html:346 冒泡排序：
jssort.html:358 -正序耗時：: 252.561767578125ms
jssort.html:372 -倒序耗時：: 289.15087890625ms

10. 測試排序10萬個無序數，耗時結果如下

//測試排序100000個數
testSort( 100000, false );
```
```javascript
testSort(100000)
jssort.html:386 ---------
jssort.html:388 正在生成 100000個無序數...
jssort.html:392 生成 100000個無序數完成
jssort.html:344 ---------
jssort.html:346 快速排序：
jssort.html:358 -正序耗時：: 10.38818359375ms
jssort.html:372 -倒序耗時：: 11.48193359375ms
jssort.html:344 ---------
jssort.html:346 希爾排序：
jssort.html:358 -正序耗時：: 22.110107421875ms
jssort.html:372 -倒序耗時：: 19.762939453125ms
jssort.html:344 ---------
jssort.html:346 計數排序：
jssort.html:358 -正序耗時：: 17.098876953125ms
jssort.html:372 -倒序耗時：: 14.27294921875ms
jssort.html:344 ---------
jssort.html:346 插入排序：
jssort.html:358 -正序耗時：: 25.2509765625ms
jssort.html:372 -倒序耗時：: 27.105712890625ms
jssort.html:344 ---------
jssort.html:346 堆排序：
jssort.html:358 -正序耗時：: 24.9130859375ms
jssort.html:372 -倒序耗時：: 26.115966796875ms
jssort.html:344 ---------
jssort.html:346 歸并排序：
jssort.html:358 -正序耗時：: 4676.212158203125ms
jssort.html:372 -倒序耗時：: 7991.64599609375ms
jssort.html:344 ---------
jssort.html:346 選擇排序：
jssort.html:358 -正序耗時：: 5662.914794921875ms
jssort.html:372 -倒序耗時：: 12556.882080078125ms
jssort.html:344 ---------
jssort.html:346 冒泡排序：
jssort.html:358 -正序耗時：: 21762.098876953125ms
jssort.html:372 -倒序耗時：: 23281.131103515625ms

以下是測試函數

//測試排序算法函數
//totalNum 測試排序的元素個數
//isPrintArrData 是否打印數組數據
function testSort( totalNum, isPrintArrData ){

    //生成測試數據
    arr = makeData( totalNum, isPrintArrData );

    //1>調用測試函數，對 快速排序 算法進行測試
    TestOneSortFunc( arr, 'quickSort', ", 0, arr.length - 1" , "快速排序", isPrintArrData );

    //2>調用測試函數，對 希爾排序 算法進行測試
    TestOneSortFunc( arr, 'shellSort', "", "希爾排序", isPrintArrData );

    //3>調用測試函數，對 計數排序 算法進行測試
    TestOneSortFunc( arr, 'countingSort', "", "計數排序", isPrintArrData );

    //4>調用測試函數，對 插入排序 算法進行測試
    TestOneSortFunc( arr, 'heapSort', "", "插入排序", isPrintArrData );

    //5>調用測試函數，對 堆排序 算法進行測試
    TestOneSortFunc( arr, 'heapSort', "", "堆排序", isPrintArrData );

    //6>調用測試函數，對 歸并排序 算法進行測試
    TestOneSortFunc( arr, 'mergeSort', ",0, arr.length", "歸并排序", isPrintArrData );

    //7>調用測試函數，對 選擇排序 算法進行測試
    TestOneSortFunc( arr, 'selectionSort', "", "選擇排序", isPrintArrData );

    //8>調用測試函數，對 冒泡排序 算法進行測試
    TestOneSortFunc( arr, 'bubbleSort', "", "冒泡排序", isPrintArrData );

}

//測試一個排序算法函數
function TestOneSortFunc( arr, funcName, funcOtherArgv, textName, isPrintArrData ){
    console.log( "---------" );
    //arr = makeData( totalNum );
    console.log( textName + "：" );
    //console.log( "原始數據：" );
    //console.log( arr );

    //正序
    arr1 = arr.slice();
    console.time( "-正序耗時：" );

    //eval( funcName + "(arr1, 0, arr1.length - 1, false)" );
    //, 0, arr1.length - 1
    eval( funcName + "(arr1"+ funcOtherArgv +", false)" );

    console.timeEnd( "-正序耗時：" );
    if( isPrintArrData ){
        console.log( "正序排序結果：" );
        console.log( arr1 );
    }

    //逆序
    arr2 = arr.slice();
    console.time( "-倒序耗時：" );

    //eval( funcName + "(arr2, 0, arr2.length - 1, true)" );
    //, 0, arr2.length - 1
    eval( funcName + "(arr2"+ funcOtherArgv +", true)" );

    console.timeEnd( "-倒序耗時：" );
    
    if( isPrintArrData ){
        console.log( "倒序排序結果：" );
        console.log( arr2 );
    }
}

//數據生成函數
function makeData( totalNum, isPrintArrData ){

    var arr = [];
    var i = totalNum;

    console.log( "---------" );

    console.log( "正在生成 " + totalNum + "個無序數..." );
    while( i-- ){
        arr.push( Math.floor( Math.random() * totalNum ) );
    }
    console.log( "生成 " + totalNum + "個無序數完成" );
    if( isPrintArrData ){
        console.log( "原始無序數據：" );
        console.log( arr );
    }

    return arr;
}

如果需要打印每個算法的排序結果，把 testSort() 的第二個參數設置為true即可