時間/空間復雜度

補充：空間復雜度，如果一個函數運行下來，占用的內存是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循環，性能更好