国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

JS六種排序算法

wenshi11019 / 2652人閱讀

摘要:冒泡排序循環的最大值從遞減基本就是每次循環只能排好最后一個然后遞減到第一個冒泡調用選擇排序外循環選取當前元素到內循環開始到逐個比較出最小值交換和選擇調用插入排序從下標開始往后選擇直到最后每個選中的和他前面的所有比較直到找到比他小的排

// 冒泡排序
// 循環的最大值從length遞減
// 基本就是每次循環只能排好最后一個 然后遞減到第一個

function bubbleSort(){
var changedData = new Array();
var index = 0;
    console.log("冒泡調用");
    for (var j = a.length; j >0 ; j--) {
        for (var i = 0; i < j; i++) {
            if(a[i]>a[i+1]){
                var z = 0;
                z = a[i+1];
                a[i+1] = a[i];
                a[i] = z;
            }
            changedData[index] = a.toString();
            index++;
        }//one            
    }//two
    showDateChange(changedData);
}

// 選擇排序
// 外循環 j選取當前元素 到length-1
// 內循環 j+1開始 到length 逐個比較出最小值min
// 交換 min 和 a[j]

function selectionSort(){
var changedData = new Array();
var index = 0;
    console.log("選擇調用");
    for (var j = 0; j < a.length-1; j++) {
        var min = a[j];
        var minIndex = j;
        for (var i = j+1; i < a.length; i++) {
            if(a[i] < min) {
                min = a[i];
                minIndex = i;
            }
        }//one
        a[minIndex] = a[j];
        a[j] = min;
        // 
        changedData[index] = a.toString();
        index++;
    }//two
    showDateChange(changedData);
}

// 插入排序
// 從下標1開始 往后選擇直到最后
// 每個選中的和他前面的所有比較
// 直到找到比他小的 排在他后面
// 相當于從1開始 每次都排好之前的i+1個 直到length
// 和冒泡相反

function insertionSort(){
var changedData = new Array();
var index = 0;
    console.log("插入排序");
    for (var j = 1; j < a.length; j++) {
        var now = a[j];
        var i = j - 1;
        while(i>=0 && now

// 希爾排序
// 間隔改變的插入排序
// 傳統插入排序 比較前面的相鄰對象
// 希爾排序比較前面的第h個對象 直到h間隔不存在更改
// 改變h 直到 h=1

function shellSort(){
var changedData = new Array();
var index = 0;
    console.log("希爾排序");
    var N = a.length;
    var h = 1;
    if (h < N/3) {
        h = h*3 + 1;//設置間隔
    }
    while(h > 0){
        for (var j = h; j < a.length; j++) {
            for (var i = j;i >= h && a[i] < a[i-h]; i -= h) {
                var z;
                z = a[i];
                a[i] = a[i-h];
                a[i-h] = z;
                // 
                changedData[index] = a.toString();
                index++;
            }
        }
        h = (h-1)/3;//改變間隔
    }
    showDateChange(changedData);
}

// 歸并排序
// 數據分為 step為間隔的小數組
// 將小數組排序 step變大 直到為1/2個數組
// 將前后兩個已排序的數組 再排序

function mergeSort(arr){
var changedData = new Array();
    console.log("歸并排序");
    if (arr.length < 2) {
        return;
    }
    var step = 1;
    var left;
    var right;
    while(step < arr.length){
        left = 0;
        right = step;
        while(right + step <= arr.length){
            mergeArrays(arr,left,left+step,right,right+step);
            left = right + step;
            right = left + step;
        }
        if (right < arr.length) {
            mergeArrays(arr,left,left+step,right,arr.length);
        }
        step *= 2;
    }
    function mergeArrays(arr,startLeft,stopLeft,startRight,stopRight){
        var leftArray = new Array(stopLeft - startLeft +1);
        var rightArray = new Array(stopRight - startRight +1);
        k = startRight;
        for (var i = 0; i < rightArray.length-1; i++) {
            rightArray[i] = arr[k];
            k++;
        }
        k = startLeft;
        for (var i = 0; i < leftArray.length-1; i++) {
            leftArray[i] = arr[k];
            k++;
        }
        rightArray[rightArray.length-1] = Infinity;
        leftArray[leftArray.length-1] = Infinity;
        var m = 0;
        var n = 0;
        for (var k = startLeft; k < stopRight; k++) {
            if (leftArray[m] <= rightArray[n]) {
                arr[k] = leftArray[m];
                m++;
            }else{
                arr[k] = rightArray[n];
                n++;    
            }
        }
        arr += "";//轉化為字符串
        changedData.push(arr);
    }
    showDateChange(changedData);
}

// 快速排序
// 沒實現可視化排序

function quickSort(){
    console.log("快速排序");
    function qSort(list){
        if (list.length == 0) {
            return list;
        }
        // 選取基數
        var pivotIndex = Math.floor(list.length/2);
        var pivot = list.splice(pivotIndex,1)[0];

        var left = [];
        var right = [];
        for (var i = 0; i < list.length; i++) {
            if (list[i] > pivot) {
                right.push(list[i]);
            }else{
                left.push(list[i]);
            }
        }
        // 遞歸 更換基數 并且排序其左右
        return qSort(left).concat([pivot],qSort(right));
    }
    a = qSort(a);
    showDate();
}

文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規行為,您可以聯系管理員刪除。

轉載請注明本文地址:http://specialneedsforspecialkids.com/yun/80499.html

相關文章

  • JS實現數組去重方法總結(六種方法)

    摘要:利用將結構轉換成數組拓展運算符內部使用循環拓展,合并數組之后去重第種方法將傳入的數組或非數組值與原數組合并組成一個新的數組并返回。該方法會產生一個新的數組再引用上面的任意一個去重方法第種。 1.第1種 雙層循環,外層循環元素,內層循環時比較值,如果有相同的值則跳過,不相同則push進數組 Array.prototype.distinct = function(){ var arr =...

    Fourierr 評論0 收藏0
  • JS算法題之leetcode(11~20)

    摘要:給定一個整數,將其轉為羅馬數字。字符數值例如,羅馬數字寫做,即為兩個并列的。通常情況下,羅馬數字中小的數字在大的數字的右邊。給定一個羅馬數字,將其轉換成整數。注意空字符串可被認為是有效字符串。 JS算法題之leetcode(11~20) showImg(https://segmentfault.com/img/bVbwmfg?w=1790&h=714);這次的十道題目都比較容易,我們簡...

    CoderDock 評論0 收藏0
  • Javascript中數組去重的六種方法

    摘要:數組去重第一種方法先對數組進行排序,排好序,然后把數組的當前項和后一項進行比較,相同則使用數組的相同的位置,,但是為了防止數組塌陷,每次刪除數組元素的時候要把的值減一。 數組去重 第一種方法: 先對數組進行排序sort(),排好序,然后把數組的當前項和后一項進行比較,相同則使用數組的splice(相同的位置,1),但是為了防止數組塌陷,每次刪除數組元素的時候要把i的值減一。 ...

    CodeSheep 評論0 收藏0
  • JS判斷數組的六種方法詳解

    摘要:對象構造函數的判斷用法的每個實例都有構造函數,用于保存著用于創建當前對象的函數如上所示,的實例的跟對象是相等的那么我們就可以用此來判斷數組了原型鏈上的用法屬性表示構造函數的原型其中有一個方法是用于測試一個對象是否存在于另一個對象的原型鏈上。 在JS中,數組是屬于Object類型的,也就是屬于引用類型(引用類型存放在堆內存中,在棧內存會有一個或者多個地址來指向這個堆內存)。 所以對于引用...

    xiaoxiaozi 評論0 收藏0

發表評論

0條評論

最新活動
閱讀需要支付1元查看
<