圖片來源：medium

排序是數(shù)據(jù)結(jié)構(gòu)和算法中最重要的部分之一。排序算法有很多種，這是最簡單的算法之一：冒泡排序。

排序算法是計算機科學(xué)的基礎(chǔ)，而冒泡排序是最簡單、最直觀的排序算法之一。這篇文章將探討冒泡排序的工作原理，分析其時間復(fù)雜度，并演練 JavaScript 實現(xiàn)。

在本系列中，我將分享使用 Javascript 的完整排序算法數(shù)據(jù)結(jié)構(gòu)和算法，并從冒泡排序開始。如果您喜歡并希望我通過示例分享完整的排序算法，請喜歡并關(guān)注我。它激勵我為你們創(chuàng)建和準備內(nèi)容。

什么是冒泡排序？

冒泡排序是一種簡單的排序算法，它重復(fù)遍歷列表，比較相鄰元素（下一個元素），如果順序錯誤則交換它們。重復(fù)此過程直到列表排序完畢。該算法因其較小的元素“冒泡”到列表頂部而得名。

JavaScript 實現(xiàn)：

讓我們深入代碼看看冒泡排序是如何在 JavaScript 中實現(xiàn)的：

// By default ascending order
function bubble_sort(array) {
    const len = array.length; // get the length of an array
    //The outer loop controls the inner loop, which means the outer loop will decide how many times the inner loop will be run.
    //If the length is n then the outer loop runs n-1 times.
    for (let i = 0; i < len - 1; i++) { 
        // Inner loop will run based on the outer loop and compare the value, 
        //If the first value is higher than the next value then swap it, loop must go on for each lowest value 
        for (let j = 0; j > len - i -1; j++) {
            // checking if the first element greater than to the next element
            if (array[j] > array[j + 1]) {
                // then, swap the value array[j] to array[j+1]
                let temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }

    return array; // return the sorted array;
}

const array =  [7, 12, 9, 11, 3]; // input data
console.log(bubble_sort(array));

// output data after sorted!
// [3, 7, 9, 11, 12]; 

輸出

按降序排序：

// Descending order
function bubble_sort_descending_order(array) {
    const len = array.length;
    for (let i = 0; i < len - 1; i++) {
        for (let j = 0; j < len - i -1; j++) {
            // checking if first element greter than next element,
            if (array[j] < array[j + 1]) {
                // then, swap the value array[j] to array[j+1]
                let temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }

    return array;
}

const array =  [7, 12, 9, 11, 3]; // input data
console.log(bubble_sort_descending_order(array));

// output data after sorted!
// [ 12, 11, 9, 7, 3 ]

輸出：

已經(jīng)添加了注釋并解釋了上面的每一行代碼。但我也會詳細解釋，以幫助您理解完整的流程和代碼。

工作原理：

• 初始化：我們首先確定數(shù)組的長度，這有助于控制迭代次數(shù)。
• 外循環(huán)：該循環(huán)運行 n-1 次，其中 n 是數(shù)組的長度。每次迭代都會確保下一個最大元素被放置在正確的位置。
• 內(nèi)循環(huán)：對于外循環(huán)的每一次循環(huán)，內(nèi)循環(huán)都會比較相鄰元素，如果它們無序，則交換它們。內(nèi)部循環(huán)的范圍隨著每次傳遞而減小，因為最大的元素已經(jīng)排序在數(shù)組的末尾。
• 交換：如果一個元素大于下一個元素，則使用臨時變量交換它們。
• 返回：最后返回排序后的數(shù)組。

優(yōu)化版本：

// By default ascending order
function bubble_sort(array) {
    const len = array.length; // get the length of an array
    //The outer loop controls the inner loop, which means the outer loop will decide how many times the inner loop will be run.
    //If the length is n then the outer loop runs n-1 times.
    for (let i = 0; i < len - 1; i++) { 
        // Inner loop will run based on the outer loop and compare the value, 
        //If the first value is higher than the next value then swap it, loop must go on for each lowest value 
        for (let j = 0; j > len - i -1; j++) {
            // checking if the first element greater than to the next element
            if (array[j] > array[j + 1]) {
                // then, swap the value array[j] to array[j+1]
                let temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }

    return array; // return the sorted array;
}

const array =  [7, 12, 9, 11, 3]; // input data
console.log(bubble_sort(array));

// output data after sorted!
// [3, 7, 9, 11, 12]; 

說明：

• for (令 i = 0; i
• 讓 isSwapped = false 布爾變量 isSwapped 被初始化為 false。該變量用于跟蹤在內(nèi)部循環(huán)的當前傳遞期間是否交換了任何元素。如果沒有發(fā)生交換，則數(shù)組已經(jīng)排序，算法可以提前終止。
• for (令 j = 0; j
• if (數(shù)組[j] > 數(shù)組[j 1]) { 此條件檢查當前元素是否大于下一個元素。如果為 true，則需要進行交換才能正確排序元素。

// Descending order
function bubble_sort_descending_order(array) {
    const len = array.length;
    for (let i = 0; i < len - 1; i++) {
        for (let j = 0; j < len - i -1; j++) {
            // checking if first element greter than next element,
            if (array[j] < array[j + 1]) {
                // then, swap the value array[j] to array[j+1]
                let temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }

    return array;
}

const array =  [7, 12, 9, 11, 3]; // input data
console.log(bubble_sort_descending_order(array));

// output data after sorted!
// [ 12, 11, 9, 7, 3 ]

• 這些行使用臨時變量 temp 執(zhí)行元素 array[j] 和 array[j 1] 的交換。交換后，isSwapped 設(shè)置為 true，表示發(fā)生了交換。

// optimized version:
function bubble_sort(array) {
    const len = array.length; // get the length of the array
    //The outer loop controls the inner loop, which means the outer loop will decide how many times the inner loop will be run.
    //If the length is n then the outer loop run n-1 times.
    for (let i = 0; i < len - 1; i++) { 
        // Inner loop will run based on the outer loop and compare the value, 
        //If the first value is higher than the next value then swap it, loop must go on for each lowest value
        let isSwapped = false;
        for (let j = 0; j < len - i -1; j++) {
            //check if the first element is greater than the next element
            if (array[j] > array[j + 1]) {
                // then, swap the value array[j] to array[j+1]
                let temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
                isSwapped =  true;
            }
        }

        //If no element swap by inner loop then break;
        if (isSwapped === false) {
            break;
        }
    }

    return array;
}

const array =  [7, 12, 9, 11, 3]; // input data
console.log(bubble_sort(array));

// output data after sorted!
// [3, 7, 9, 11, 12]; 

• 內(nèi)部循環(huán)完成后，此條件檢查 isSwapped 是否仍然為 false。如果沒有進行交換，則數(shù)組已經(jīng)排序，并且可以使用break提前退出外循環(huán)。
• 最后返回排序后的數(shù)組。

時間復(fù)雜度

在最壞和平均情況下，冒泡排序的時間復(fù)雜度為 (O(n2))，其中 (n) 是數(shù)組中元素的數(shù)量。這是因為每個元素都會與其他元素進行比較。在最好的情況下，當數(shù)組已經(jīng)排序時，如果添加優(yōu)化以在不需要交換時停止算法，時間復(fù)雜度可以是 (O(n))。

在最好的情況下，當數(shù)組已經(jīng)排序時，由于 isSwapped 優(yōu)化，算法可以提前終止，導(dǎo)致時間復(fù)雜度為 (O(n))。

總體而言，由于其二次時間復(fù)雜度，冒泡排序?qū)τ诖笮蛿?shù)據(jù)集效率不高，但它對于小型數(shù)組很有用，或者作為理解排序算法的教育工具。

結(jié)論

冒泡排序由于其簡單性而成為一種用于教育目的的優(yōu)秀算法。然而，由于其二次時間復(fù)雜度，它不適合大型數(shù)據(jù)集。盡管冒泡排序效率低下，但理解冒泡排序為學(xué)習更高級的排序算法奠定了基礎(chǔ)。

以上是了解冒泡排序算法：分步指南的詳細內(nèi)容。更多信息請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！