基礎算法之"排序類"

時間/空間復雜度

補充:空間復雜度,如果一個函數運行下來,占用的內存是3個字節,那么空間復雜度是O(1)。如果占用的內存字節數跟邏輯處理是線性關系,那么空間復雜度就是O(n)。
總結:時間復雜度,看的是運行次數,空間復雜度,看的是占用的內存。

(數據結構)十分鐘搞定時間復雜度(算法的時間復雜度)

image.png

冒泡排序

思路:每一輪都兩兩比較,把其中較大的數放到右邊

// 冒泡排序
function bubbleSort(arr) {
    for (let i = arr.length - 1; i > 0; i--) {
        for (let j = 0; j < i; j++) {
            if (arr[j] > arr[j + 1]) {
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
            }
        }
    }
    return arr;
}

選擇排序

思路:每一輪都會選擇中最小的一個數,把這個數放到左邊

// 選擇排序
function selectSort(arr) {
    const len = arr.length;
    for (let i = 0; i < len; i++) {
        for (let j = i + 1; j < len; j++) {
            if (arr[j] < arr[i]) {
                [arr[i], arr[j]] = [arr[j], arr[i]];
            }
        }
    }
    return arr;
}

題目: 922. 按奇偶排序數組 II

思路:首先設定目標數組奇數位和偶數位游標,然后遍歷源數組,如果是奇數就放到奇數位游標的位置上,如果是偶數就放到偶數位游標的位置上。

function sortArrayByParity(arr) {
    // 進行升序排序
    arr.sort((a, b) => a - b);
    // 聲明一個空數組用來存儲奇偶排序后的數組
    let r = [];
    // 記錄奇數,偶數位下標
    let odd = 1;
    let even = 0;
    // 對數組進行遍歷
    arr.forEach(item => {
        if (item % 2 === 1) {
            r[odd] = item;
            odd += 2;
        } else {
            r[even] = item;
            even += 2;
        }
    });
    return r;
}

題目: 215. 數組中的第K個最大元素

常規做法:先降序排序,然后取第k個元素
function findKthLargest(arr, k) {
    return arr.sort((a, b) => b - a)[k - 1];
}

弊端:性能不好,其實沒有必要全部都排序好

更好做法:冒泡排序做到第k次
function findKthLargest(arr, k) {
    for (let i = arr.length - 1; i > arr.length - 1 - k; i--) {
        for (let j = 0; j < i; j++) {
            if (arr[j] > arr[j + 1]) {
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
            }
        }
    }
    return arr[arr.length - k];
}

說明:雖然代碼量比方法1要多,但是性能提高了

題目:164. 最大間距

常規做法:先降序排序,然后取第k個元素
function maximumGap(arr) {
    // 如果長度小于2,返回0
    if (arr.length < 2) {
        return 0;
    }
    // 排序
    arr.sort();
    // 保存相鄰元素的最大差值
    let max = 0;
    let tmp = 0;
    for (let i = 0, len = arr.length; i < len - 1; i++) {
        tmp = arr[i + 1] - arr[i];
        if (tmp > max) {
            max = tmp;
        }
    }
    return max;
}

弊端:同時有sort()和for循環,性能不好

更好做法:在冒泡排序的每一輪中取得最大兩個元素間的差值
function maximumGap(arr) {
    // 如果長度小于2,返回0
    if (arr.length < 2) {
        return 0;
    }
    // 保存相鄰元素的最大差值
    let max = 0;
    let tmp = 0;
    for (let i = arr.length - 1; i > 0; i--) {
        for (let j = 0; j < i; j++) {
            if (arr[j] > arr[j + 1]) {
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
            }
        }   
        // 從第二輪開始計算差值
        if (i < arr.length - 1) {
            tmp = arr[i + 1] - arr[i];
        }
        if (tmp > max) {
            max = tmp;
        }
    }
    // 注意還需要跟arr[1] - arr[0]的結果做比較
    return Math.max(max, arr[1] - arr[0]);
}

說明:相比常規做法,少做了一次for循環,性能更好

題目:41. 缺失的第一個正數

常規做法:先排序再找缺失的正數
function firstMissingPositive(arr) {
    // 過濾掉非正數
    arr = arr.filter(item => item > 0);
    // 正整數數組是不是空
    if (arr.length) {
        // 升序,目的:方便從左到右取最小值arr[0]
        arr.sort();
        // 如果第一個元素不為1,返回1
        if (arr[0] !== 1) {
            return 1;
        } else {
            // 從左到右遍歷,只要下一個元素和當前元素的差值 >1,返回當前元素的下一個值(+1)
            for (let i = 0; i < arr.length - 1; i++) {
                if (arr[i + 1] - arr[i] > 1) {
                    return arr[i] + 1;
                }
            }
            // 如果數組是連續的正數[1,2,3,4,5,6]
            return arr.pop() + 1;
        }
    } else {
        return 1;
    }
}

弊端:同時有sort()和for循環,性能不好

更好做法:在選擇排序的每一輪中找缺失的正數
function firstMissingPositive(arr) {
    // 過濾掉非正數
    arr = arr.filter(item => item > 0);
    let len = arr.length;
    // 正整數數組是不是空
    if (len) {
        for (let i = 0; i < len; i++) {
            for (let j = i + 1; j < len; j++) {
                if (arr[j] < arr[i]) {
                    [arr[i], arr[j]] = [arr[j], arr[i]];
                }
            }
            // arr[i]是本輪中最小的數
            if (i > 0) {
                // 當前元素與前一個元素的差值 >1,返回前一個元素的下一個值(+1)
                if (arr[i] - arr[i - 1] > 1) {
                    return arr[i - 1] + 1;
                }
            } else {
                // 如果第一個元素不為1,返回1
                if (arr[i] !== 1) {
                    return 1;
                }
            }
        }
        return arr.pop() + 1;
    } else {
        return 1;
    }
}

說明:相比常規做法,少做了一次for循環,性能更好

最后編輯于
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明:文章內容(如有圖片或視頻亦包括在內)由作者上傳并發布,文章內容僅代表作者本人觀點,簡書系信息發布平臺,僅提供信息存儲服務。