找到好工做之 LeetcodeTop100(Easy) by JavaScript

時間 2019-11-08

標籤找到 leetcodetop100 leetcodetop easy javascript 欄目 JavaScript 简体版

原文原文鏈接

記錄一下 leetcode top100javascript

該部分只記錄 easy 難度，因爲爲 easy 難度，故基本直接放解答html

1. two sum

兩數和 - 找到無序數組中和爲定值的兩個數，返回下標java

由於須要返回下標，所以先排序後用兩個指針掃（前->後, 後->前）的方式（NlogN）不行。故選用相似 hash 的形式解； key 爲數組值， value 爲下標node

/** * @param {number[]} nums * @param {number} target * @return {number[]} */
var twoSum = function(nums, target) {
    const map = {};
    nums.forEach((num, index) => map[num] = index);
    const len = nums.length;
    for(let i = 0; i < len; i++) {
        const otherIndex = map[target - nums[i]];
        if(otherIndex && otherIndex != i) {
            return [Math.min(i, otherIndex), Math.max(i, otherIndex)]
        }
    }
};
複製代碼

20. Valid Parentheses

判斷輸入的字符串是否是隻包含(, ), {, }, [ and ]算法

必須使用相同類型的括號關閉左括號。
必須以正確的順序關閉左括號。

/** * @param {string} s * @return {boolean} */
var isValid = function(s) {
    const stack = [];
    const helpMap = {
        '(': ')',
        '[': ']',
        '{': '}'
    }
    for(let i = 0; i < s.length; i++) {
        const char = s[i];
        if(char in helpMap) {
            stack.push(helpMap[char]);
        } else if(char !== stack.pop()){
            return false;
        }
    }
    return stack.length === 0;
};

複製代碼

21. Merge Two Sorted Lists

合併兩個已排序的鏈表並將其做爲新鏈表返回。新鏈表應該經過拼接前兩個鏈表的節點來完成。數組

解法一：遞歸

/** * Definition for singly-linked list. * function ListNode(val) { * this.val = val; * this.next = null; * } */
/** * @param {ListNode} l1 * @param {ListNode} l2 * @return {ListNode} */
var mergeTwoLists = function (l1, l2) {
    if (!l1) return l2;
    if (!l2) return l1;
    if (l1.val <= l2.val) {
        l1.next = mergeTwoLists(l1.next, l2);
        return l1;
    } else {
        l2.next = mergeTwoLists(l1, l2.next);
        return l2;
    }
};
複製代碼

解法二：循環

/** * Definition for singly-linked list. * function ListNode(val) { * this.val = val; * this.next = null; * } */
/** * @param {ListNode} l1 * @param {ListNode} l2 * @return {ListNode} */
var mergeTwoLists = function (l1, l2) {
    if (!l1) return l2;
    if (!l2) return l1;
    const newList = new ListNode(null);
    let newPointer = newList;
    while (l1 && l2) {
        if (l1.val < l2.val) {
            newPointer.next = l1;
            l1 = l1.next;
        } else {
            newPointer.next = l2;
            l2 = l2.next;
        }
        newPointer = newPointer.next;
    }
    if (l1) newPointer.next = l1;
    if (l2) newPointer.next = l2;
    return newList.next;
};
複製代碼

35. Search Insert Position

給定排序數組和目標值，若是找到目標，則返回索引。若是沒有，請返回索引按順序插入的索引。緩存

相似於二分查找的變種題安全

平時二分查找遞歸的寫多了，這裏來個不使用遞歸的版本閉包

/** * @param {number[]} nums * @param {number} target * @return {number} */
var searchInsert = function(nums, target) {
    let start = 0, end = nums.length - 1;
    let mid = Math.ceil((end + start) / 2);
    while(nums[mid] !== target) {
        if(end <= start) {
            // 若是沒有找到要看看插哪裏
            return nums[end] < target ? end + 1 : end;
        }
        if(nums[mid] > target) {
            // 保護一下不要變成負的
            end = Math.max(mid - 1, 0);
        } else {
            // 保護一下不要越界
            start = Math.min(mid + 1, nums.length - 1);
        }
        mid = Math.floor((end + start) / 2);
    }
    return mid;
};
複製代碼

52. Maximum Subarray

經典題：找一個數組中最大子序列和app

解法：從頭至尾遍歷每個數組元素，如何前面元素的和爲正，則加上本元素的值繼續搜索；如何前面元素的和爲負，則此元素開始新的和計數。以及整個過程當中要注意更新和的最大值。

/** * @param {number[]} nums * @return {number} */
var maxSubArray = function(nums) {
    let cache = 0;
    let max = -Infinity;
    nums.forEach(num => {
        cache += num;
        if(cache > max) max = cache;
        if(cache < 0) cache = 0;
    })
    return max;
};
複製代碼

70. Climbing Stairs

跳臺階，經典DP

/** * @param {number} n * @return {number} */
var climbStairs = function(n) {
    const dp = [0, 1, 2];
    for(let i = 3; i <= n; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }
    return dp[n]
};
複製代碼

100. Same Tree

判斷倆二叉樹是否是徹底相同很差的寫法：利用短路等特性把代碼寫在一行，注意作取值保護

/** * Definition for a binary tree node. * function TreeNode(val) { * this.val = val; * this.left = this.right = null; * } */
/** * @param {TreeNode} p * @param {TreeNode} q * @return {boolean} */
var isSameTree = function(p, q) {
    return (p || q) ? (p || {}).val === (q || {}).val && isSameTree((p || {}).left, (q || {}).left) && isSameTree((p || {}).right, (q || {}).right) : true
};
複製代碼

101. Symmetric Tree

判斷一顆二叉樹是否是鏡像解法一：繼續一行寫完

/** * Definition for a binary tree node. * function TreeNode(val) { * this.val = val; * this.left = this.right = null; * } */
/** * @param {TreeNode} root * @return {boolean} */
var isSymmetric = function(root) {
    return childIsSymmetric((root || {}).left, (root || {}).right);
};

function childIsSymmetric (left, right) {
    return (left || right) ? (left || {}).val === (right || {}).val && childIsSymmetric((left || {}).left, (right || {}).right) && childIsSymmetric((left || {}).right, (right || {}).left) : true;
}
複製代碼

解法二：

/** * Definition for a binary tree node. * function TreeNode(val) { * this.val = val; * this.left = this.right = null; * } */
/** * @param {TreeNode} root * @return {boolean} */
var isSymmetric = function(root) {
    if(!root) return true;
    function areMirror(left, right) {
        if(!left && !right) return true;
        if((left && !right) || (right && !left)) return false;
        if(left.val != right.val) return false;
        return areMirror(left.left, right.right) && areMirror(left.right, right.left);
    }
    return areMirror(root.left, root.right);
};
複製代碼

104. Maximum Depth of Binary Tree

找二叉樹深度

/** * Definition for a binary tree node. * function TreeNode(val) { * this.val = val; * this.left = this.right = null; * } */
/** * @param {TreeNode} root * @return {number} */
var maxDepth = function(root, deep = 0) {
    if(!root) return deep;
    return Math.max(maxDepth(root.left) + 1, maxDepth(root.right) + 1);
};
複製代碼

121. Best Time to Buy and Sell Stock

給一個數組，其中第i個元素是第i天給定股票的價格。只能進行一次買進和賣出，求最大利潤

首先設定最大利潤和最低價格：

若是當前這一天的股票價格比最低價格還小，那就把最低價格設置爲這一天的股票價格。
若是最大利潤比當天價格減掉最低價格還要低，那就把最大利潤設置成當天價格減去最低的價格。

/** * @param {number[]} prices * @return {number} */
var maxProfit = function(prices) {
    if(!prices.length) return 0;
    let minPrice = Infinity, maxProfit = -Infinity;
    prices.forEach(price => {
        if(price < minPrice) {
            minPrice = price;
        }
        if(maxProfit < (price - minPrice)) {
            maxProfit = (price - minPrice);
        }
    });
    return maxProfit;
};
複製代碼

136. Single Number

經典題，一行代碼異或解決

/** * @param {number[]} nums * @return {number} */
var singleNumber = function(nums){
    return nums.reduce((a,b) => { return a ^ b})；
}
複製代碼

141. Linked List Cycle

判斷鏈表是否有環，不能使用額外空間解法：用兩個指針，快指針每次走兩步，慢指針每次走一步。這樣每走一次快指針比慢指針多一步，若是有環最終可以相遇。

/** * Definition for singly-linked list. * function ListNode(val) { * this.val = val; * this.next = null; * } */

/** * @param {ListNode} head * @return {boolean} */
var hasCycle = function (head) {
    let slow = head;
    let fast = head;

    while (fast) {
        slow = slow.next;
        fast = fast.next && fast.next.next;
        if (slow === fast && fast !== null) {
            return true;
        }
    }

    return false;
};
複製代碼

155. Min Stack

設計一個支持push，pop，top和在恆定時間內檢索最小元素的堆棧。

push(x) -- 將元素x推入堆棧
pop() -- 刪除堆棧頂部的元素
top() -- 獲取頂部元素
getMin() -- 檢索堆棧中的最小元素

最優解 - O(1)：

該題要求的是實現一個棧，棧的修改元素的操做只有 pop() 和 push(x)，所以咱們能夠在 push 的時候維護一個做用相似於緩存的，記錄這個時候最小元素是什麼的棧 minStack。在每次 push 的時候，更新一下咱們的緩存，這個時候只須要對比一下當前入棧元素和 minStack 棧頂元素，而後取小的推入 minStack 便可，表明着這個時候最小值應該是以前棧中最小的和新來的中最小的一個元素。

/** * initialize your data structure here. */
var MinStack = function() {
    this.stack = [];
    this.minStack = [];
};

/** * @param {number} x * @return {void} */
MinStack.prototype.push = function(x) {
    this.stack.push(x);
    const minStackTop = this.minStack[this.minStack.length - 1];
    this.minStack.push(Math.min(x, minStackTop === undefined ? Infinity : minStackTop));
};

/** * @return {void} */
MinStack.prototype.pop = function() {
    this.stack.pop();
    this.minStack.pop();
};

/** * @return {number} */
MinStack.prototype.top = function() {
    return this.stack[this.stack.length - 1];
};

/** * @return {number} */
MinStack.prototype.getMin = function() {
    return this.minStack[this.minStack.length - 1];
};

/** * Your MinStack object will be instantiated and called as such: * var obj = Object.create(MinStack).createNew() * obj.push(x) * obj.pop() * var param_3 = obj.top() * var param_4 = obj.getMin() */
複製代碼

160. Intersection of Two Linked Lists

找到兩個單鏈表公共開頭的節點。

果兩個連接列表根本沒有交集，則返回null。
函數返回後，連接列表必須保留其原始結構。
能夠假設整個連接結構中沒有任何循環。
代碼在O(n)時間內運行，而且只使用O(1)內存。

由上圖能夠得知，若是要讓遍歷用的指針在鏈表公共節點入口處相遇，即兩個指針走的節點同樣長，只須要在 A 鏈表遍歷完之後換到 B 鏈表上（走了 a + c + b 個節點），而後 B 鏈表出發走完了換到 A 鏈表上（走了 b + c + a 個節點）便可。

同時咱們還要處理兩個鏈表沒有公共節點的狀況：

如上圖，從 A 出發的指針在走了 a + b 個節點後，從 B 出發的指針也走了 b + a 個節點，所以他們此時再走一步之後就都是 undefined，也就是說兩個鏈表沒有公共節點的話，只要判斷兩個指針都是 undefined 就能夠知道了。

/** * Definition for singly-linked list. * function ListNode(val) { * this.val = val; * this.next = null; * } */

/** * @param {ListNode} headA * @param {ListNode} headB * @return {ListNode} */
var getIntersectionNode = function(headA, headB) {
    let nodeA = headA, nodeB = headB;
    while(nodeA !== nodeB) {
        nodeA = nodeA ? nodeA.next : headB;
        nodeB = nodeB ? nodeB.next : headA;
    }
    return nodeA || null;
};
複製代碼

169. Majority Element

找出數組中出現次數超過 `⌊ n/2 ⌋ 的數這個題比較有意思一點，給出以下幾種方案：

因爲多於一半，所以能夠直接排序後看中間位置上的數
Moore voting algorithm：`每次都找出一對不一樣的元素，從數組中刪掉，直到數組爲空或只有一種元素
Boyer-Moore Algorithm（多數投票算法）：記錄一個當前過半數變量 A 及其個數 numA ，在遍歷過程當中，若是當前元素和記錄元素 A 相等，則 numA 加 1；若是不相等，則 numA 減 1。若是 numA 爲零，則更新 A 和重置 numA 。本質是：在遍歷數組時，若是numA爲0，表示當前並無候選元素，也就是說以前的遍歷過程當中並無找到超過半數的元素。那麼，若是超過半數的元素A存在，那麼A在剩下的子數組中，出現次數也必定超過半數。所以咱們能夠將原始問題轉化爲它的子問題。這裏有一個可視化的流程

/** * @param {number[]} nums * @return {number} */
var majorityElement = function(nums) {
    let result, count = 0
    nums.forEach(num => {
        if(result !== num) {
            if(count === 0) {
                count = 1;
                result = num;
            } else {
                count--;
            }
        } else {
            count++
        }
    });
    return result;
};
複製代碼

198. House Robber

你是一名專業強盜，計劃沿着一條街打家劫舍。每間房屋都儲存有必定數量的金錢，惟一能阻止你打劫的約束條件是：因爲房屋之間有安全系統相連，若是同一個晚上有兩間相鄰的房屋被闖入，它們就會自動聯絡警察，所以不能夠打劫相鄰的房屋。給定一列非負整數，表明每間房屋的金錢數，計算出在不驚動警察的前提下一夜最多能夠打劫到的金錢數。

DP：對於第i個房間咱們的選擇是偷和不偷

若是決定是偷，則第 i-1 個房間必須不偷，那麼這一步的就是 dp[i] = nums[i-1] + dp[i -2] , 假設dp[i]表示打劫到第 i 間房屋時累計取得的金錢最大值
若是是不偷，那麼上一步就無所謂是否是已經偷過， dp[i] = dp[i -1]
所以 dp[i] = max(dp[i - 2] + nums[i - 1], dp[i - 1] )

/**
 * @param {number[]} nums
 * @return {number}
 */
var rob = function(nums) {
    if(!nums.length) return 0;
    const dp = [nums[0]];
    for(let i = 1; i < nums.length; i++){
        dp[i] = Math.max(dp[i - 1], (dp[i - 2] || 0) + nums[i]);
    }
    return dp[nums.length - 1];
};
複製代碼

206. Reverse Linked List

反轉鏈表

能夠老老實實的循環/遞歸：

/** * Definition for singly-linked list. * function ListNode(val) { * this.val = val; * this.next = null; * } */
/** * @param {ListNode} head * @return {ListNode} */
var reverseList = function (head) {
    if (!head) return head;
    let start = head;
    let end = head
    while (end.next) {
        const node = end.next;
        end.next = node.next;
        node.next = start;
        start = node;
    }
    return start;
}
複製代碼

也能夠騷操做一下：

/** * Definition for singly-linked list. * function ListNode(val) { * this.val = val; * this.next = null; * } */
/** * @param {ListNode} head * @return {ListNode} */
var reverseList = function (head, pre) {
    if(!head) return head
    const next = head.next;
    head.next = pre || null
    return next ? reverseList(next, head) : head;
};
複製代碼

226. Invert Binary Tree

反轉二叉樹

/** * Definition for a binary tree node. * function TreeNode(val) { * this.val = val; * this.left = this.right = null; * } */
/** * @param {TreeNode} root * @return {TreeNode} */
var invertTree = function(root) {
    if(!root) return [];
    [root.left, root.right] = [root.right, root.left];
    invertTree(root.left);
    invertTree(root.right);
    return root
};
複製代碼

234. Palindrome Linked List

判斷一個鏈表是否是迴文，要求 O(n) 時間， O(1) 空間

本題暴力解法就是遍歷完鏈表後轉爲字符串，而後看是否是迴文，符合時間複雜度要求，可是不符合空間複雜度要求

要求 O(1) 的空間，那就只能從鏈表自己動手了。首先判斷迴文無非就是從兩邊到中間或者從中間到兩邊。因爲咱們能夠對鏈表自己動手，那就考慮讓鏈表可以倒着訪問（由於要求O(1)空間，因此不能直接改造爲雙向鏈表）。因爲咱們只能讓鏈表順着一個方向走，因此能夠想到選擇從中間到兩邊的方式，左邊的向前(pre)，右邊的向後(next)。

那麼咱們如何找到中間的節點呢 - 中間節點即爲鏈表的一半，那咱們使用一個快指針一次走兩步，一個慢指針一次走一步，那麼快指針走到尾時，慢指針應該走到鏈表中間。同時要注意區分鏈表長度是奇數仍是偶數：若是是奇數的話，正中間的節點不須要作判斷，應該用它先後兩個節點開始比較。

最後的代碼以下：

/** * Definition for singly-linked list. * function ListNode(val) { * this.val = val; * this.next = null; * } */
/** * @param {ListNode} head * @return {boolean} */
var isPalindrome = function(head) {
    if(!head) return true;
    if(!head.next) return true;
    let fast = head.next, slow = head;
    let pair = null;
    while(fast != null && fast.next != null) {
        slow.next.pre = slow;
        slow = slow.next;
        fast = fast.next.next;
    }
    if(!fast || fast.next) {
        // 奇數
        pair = slow.next;
        slow = slow.pre;
    } else {
        // 偶數
        pair = slow.next;
    }
    while(pair) {
        if(pair.val !== slow.val) return false;
        pair = pair.next;
        slow = slow.pre;
    }
    return true;
};
複製代碼

283. Move Zeroes

給定一個數組nums，寫一個函數將全部0移動到它的末尾，同時保持非零元素的相對順序。額外要求：

您必須在不製做數組副本的狀況下就地執行此操做
最小化操做總數。思路：
最小化操做：遍歷一遍的過程當中操做完，且不須要額外移動操做
記 zero 的個數爲 zeroesNums ，而後將每個非零的數向前移動 zeroesNums ，最後在數組末尾填上 zero

/** * @param {number[]} nums * @return {void} Do not return anything, modify nums in-place instead. */
var moveZeroes = function(nums) {
    let zeroesNums = 0;
    nums.forEach((num, index) => {
        if(num === 0) {
            zeroesNums++;
        } else {
            nums[index - zeroesNums] = num;
        }
    });
    for(let i = nums.length - 1; zeroesNums > 0; i--) {
        nums[i] = 0;
        zeroesNums--;
    }
};
複製代碼

437. Path Sum III

給一顆每一個節點都是整數（可正可負）的二叉樹，求有多少條路徑加起來等於一個給定值。注意，路徑不須要在根或葉子處開始或結束，但必須向下（即僅從父節點行進到子節點）。

解法一：暴力解，使用 BFS 和遞歸來搜索符合條件的路徑。須要注意的是這種方法沒有利用任何緩存，即計算每條路徑和的時候都從新遍歷了全部路徑節點。時間複雜度爲 O(n²)

/** * Definition for a binary tree node. * function TreeNode(val) { * this.val = val; * this.left = this.right = null; * } */
/** * @param {TreeNode} root * @param {number} sum * @return {number} */
var pathSum = function(root, sum) {
    if(!root) return 0;
    let result = 0;
    const queue = [root];
    while(stack.length) {
        const node = queue.shift();
        result += reslove(node, sum);
        node.left && queue.push(node.left);
        node.right && queue.push(node.right);
    }
    return result
};

function reslove(root, sum) {
    if(!root) return 0;
    let result = 0;
    if(sum === root.val) result++;
    return result + reslove(root.left, sum - root.val) + reslove(root.right, sum - root.val);
}
複製代碼

解法二：若是不想用 queue，那也能夠直接用遞歸來作搜索

/** * Definition for a binary tree node. * function TreeNode(val) { * this.val = val; * this.left = this.right = null; * } */
/** * @param {TreeNode} root * @param {number} sum * @return {number} */
var pathSum = function(root, sum) {
    if(!root) return 0;
    return reslove(root, sum) + pathSum(root.left, sum) + pathSum(root.right, sum);
};

function reslove(root, sum) {
    if(!root) return 0;
    return ((sum === root.val) ? 1 : 0) + reslove(root.left, sum - root.val) + reslove(root.right, sum - root.val);
}
複製代碼

解法三（O(n)）: 在前兩種解法中，咱們自頂而下重複遍歷了每層節點（第一層被遍歷一次，第二層被遍歷兩次，……）。這個時候咱們就該想辦法利用緩存來減小遍歷次數。

所以便有了以下 O(n) 複雜度的解法（思路寫在了註釋中了）

/** * Definition for a binary tree node. * function TreeNode(val) { * this.val = val; * this.left = this.right = null; * } */
/** * @param {TreeNode} root * @param {number} sum * @return {number} */
var pathSum = function(root, sum) {
    // 緩存
    const hashMap = {};
    let currentSum = 0;
    return pathSumRecursive(root, currentSum, hashMap, sum);
};

function pathSumRecursive(node, currentSum, hashMap, target) {
    if (!node) {
        return 0;
    }

    const newCurrentSum = currentSum + node.val;
    // 看一看能不能利用以前的緩存，巧妙的在一次遍歷中算出了全部線段
    // 當前路徑和 - 目標值 —— 本質是看 中間有沒有一段路徑和 等於 目標值
    // 好比 2 - 5 - 3 的路徑， 目標爲 8，那麼在 3 這個節點時，路徑和爲 10 ， 減去目標值8 後爲 2， 以前路徑上有1條路線和爲 2，所以中間有一段和爲目標值 8
    let totalPaths = hashMap[newCurrentSum - target] || 0;
    
    if (newCurrentSum === target) {
        totalPaths++;
    }
    // 更新一下緩存
    if (hashMap[newCurrentSum]) {
        hashMap[newCurrentSum]++;
    } else {
        hashMap[newCurrentSum] = 1;
    }

    totalPaths += pathSumRecursive(node.left, newCurrentSum, hashMap, target);
    totalPaths += pathSumRecursive(node.right, newCurrentSum, hashMap, target);
    
    // 因爲是共用一個緩存，所以遍歷完後續節點後，要在退回上一層的時候把自身從緩存中刪掉，來保證緩存數據的正確性（只應該有以前路徑的）
    hashMap[newCurrentSum]--;
    return totalPaths;
}
複製代碼

438. Find All Anagrams in a String

在字符串中尋找同構體：給定一個字符串s和一個非空字符串p，找到s中p的同構體的全部起始索引。什麼是同構體：兩個字符串字母同樣，字母在字符串中的順序可能不同，好比 ab 和 ba 是同構的

解法一：

對於這個首先想到的是利用緩存來提升效率，這裏咱們先才用 Map 的形式作映射。同時使用滑動窗口 - 兩個指針（下標）來指向當前子串。而後從前日後掃，來經過 Map 看是否是匹配。若是

當前字符在咱們的 Map 中有，可是已經被匹配完了，則須要把指向開頭的指針向後掃，直到碰見一樣的字符。
當前字符在咱們的 Map 中根本沒有，則意味着到這個字符爲止都不會有符合條件的字串，所以須要將 Map 恢復後，從當前字符的下一個開始從新尋找

/** * @param {string} s * @param {string} p * @return {number[]} */
var findAnagrams = function(s, p) {
    const targetMap = {};
    // 構建map
    for(let char of p) {
        if(targetMap[char]) {
            targetMap[char]++;
        } else {
            targetMap[char] = 1;
        }
    }
    let start = 0;
    let cacheLen = p.length;
    const result = [];
    for(let i = 0; i < s.length; i++) {
        const char = s[i];
        // 若是 char 還有
        if(targetMap[char]) {
            targetMap[char]--;
            cacheLen--;
            // 若是都匹配上了
            if(cacheLen === 0) {
                result.push(start); // 推動去
                // 全部的向前移動一位
                targetMap[s[start]]++; 
                start++;
                cacheLen++;
            }
        } else if(targetMap[char] === 0) {
            // char 有，可是超過個數了，就要向前走把char去掉一個
            while(s[start] !== char) {
                targetMap[s[start]]++;
                start++;
                cacheLen++;
            }
            start++;
        } else {
            // char 根本沒有，就跳過以前這段
            while(start < i) {
                targetMap[s[start]]++;
                start++;
            }
            start++;
            cacheLen = p.length;
        }
    }
    return result;
};
複製代碼

解法二：上圖中用 Obj 作 Mapping，咱們也能夠用數組結合字符下標來作 Mapping

/** * @param {string} s * @param {string} p * @return {number[]} */
var findAnagrams = function (s2, s1) {
    const map = Array(128).fill(0);
    let start = 0,
        end = 0,
        counter = s1.length;
    const res = [];
    for (let i = 0; i < s1.length; ++i) {
        map[s1.charCodeAt(i)]++;
    }
    while (end < s2.length) {
        if (map[s2.charCodeAt(end)] > 0) {
            counter--;
        }
        map[s2.charCodeAt(end)]--;
        end++;
        while (counter == 0) {
            if (end - start == s1.length) {
                res.push(start);
            }
            if (map[s2.charCodeAt(start)] == 0) {
                counter++;
            }
            map[s2.charCodeAt(start)]++;
            start++;
        }
    }
    return res;
};
複製代碼

448. Find All Numbers Disappeared in an Array

常規解法：由於題目上給出條件說數組裏的數字都在 [1, n]，且要求不適用額外空間，所以能夠想到該題爲套路題：對原位置上的數字移動/加減/位運算等解法。此題常規能夠選用反轉對應位置上數字的方法：把出現的數字的對應位上的數字變爲負數，而後遍歷找出那些正數，其下標+1則爲沒有出現過的數字

/** * @param {number[]} nums * @return {number[]} */
var findDisappearedNumbers = function(nums) {
    nums.forEach(num => {
        num = Math.abs(num);
        if(nums[num - 1] > 0) {
            nums[num - 1] = -nums[num - 1]
        }
    });
    const result = [];
    nums.forEach((num, index) => {
        if(num > 0) {
            result.push(index + 1);
        }
    });
    return result;
};
複製代碼

位運算騷操做版：首先須要簡單理解幾個位運算是幹什麼的：

JavaScript 中位運算將其操做數（operands）看成32位的比特序列，有符號數最左比特位爲1
1 << 31：變成 10000000000000000000000000000000
1 << 31 - 1 則變成 01111111111111111111111111111111
與1 << 31 進行 | 運算，則會把一個數（不管正負）變成負數（只修改符號位）
與1 << 31 - 1 進行 & 運算，則會把一個數（不管正負）變成正數（只修改符號位）該解法用以上方式避開對符號的判斷

/** * @param {number[]} nums * @return {number[]} */
var findDisappearedNumbers = function(nums) {
    for (var i = 0; i < nums.length; i++) {
        nums[(nums[i] & ((1 << 31) - 1)) - 1] |= (1 << 31);
        //                統一正負數運算   變成負數 
    }
    
    ans = [];
    
    for (var i = 0; i < nums.length; i++) {
        // 若是不是負數，就推動去
        if ((nums[i] & (1 << 31)) != (1 << 31))
            ans.push(i+1);
    }
    
    return ans;
};
複製代碼

461. Hamming Distance

Hamming Distance 表示兩個等長字符串在對應位置上不一樣字符的數目，也度量了經過替換字符的方式將字符串x變成y所須要的最小的替換次數。

1.常規解法：轉成二進制之後一位一位的算，須要手動補位或手動判斷 undefined

/** * @param {number} x * @param {number} y * @return {number} */
var hammingDistance = function (x, y) {
    let binaryX = x.toString(2);
    let binaryY = y.toString(2);
    const len = Math.max(binaryX.length, binaryY.length);
    if (binaryX.length < len) {
        binaryX = binaryX.padStart(len, '0')
    } else {
        binaryY = binaryY.padStart(len, '0')
    };
    let result = 0;
    for (let i = len - 1; i >= 0; i--) {
        if (binaryX[i] !== (binaryY[i])) {
            result++
        }
    }
    return result;
};

複製代碼

2.位運算：按位異或，不須要考慮補長度，更簡潔

/** * @param {number} x * @param {number} y * @return {number} */
var hammingDistance = function (x, y) {
    var res = x ^ y;
    var count = 0;
    while (res != 0) {
        if (res % 2 == 1) count++;
        res = Math.floor(res / 2); // res = res >> 1;
    }
    return count;
};
複製代碼

538. Convert BST to Greater Tree

二叉搜索樹上的每個節點要加上全部大於他的節點的值：原始BST的每一個 key 都更改成原始 key 加上大於BST中原始 key 的全部 key 的總和。

解法一：

BST的性質以下
- 若它的左子樹不空，則左子樹上全部結點的值均小於它的根結點的值；
- 若它的右子樹不空，則右子樹上全部結點的值均大於它的根結點的值；
- 它的左、右子樹也分別爲二叉排序樹。
使用右->中->左的順序從大到小遍歷，並利用 cacheVal 來緩存比當前節點大的值來達到 O(n) 的時間複雜度
在遞歸中進行 cacheVal 的傳遞而不是在外層保存該值（麻煩一點，由於須要處理右子樹最左節點：代碼29行）
由於右子樹最左節點的只是除了當前節點之外最小的，因此右子樹最左節點的值爲最大的（全部比當前節點大的節點加起來的值）。所以當前節點只須要加上右子樹最左節點的值便可

/** * Definition for a binary tree node. * function TreeNode(val) { * this.val = val; * this.left = this.right = null; * } */
/** * @param {TreeNode} root * @return {TreeNode} */
var convertBST = function(root) {
    if(root) {
        converVal(root);
        return root;
    } else {
        return [];
    }
};

function converVal(root, cacheVal = 0) {
    if(root.right) {
        cacheVal = converVal(root.right, cacheVal);
    }
    root.val += cacheVal;
    cacheVal = root.val;
    if(root.left) {
        // 處理右子樹最左節點，返回給上一層遞歸來使用（此時右子樹最左節點爲上一層節點須要加的值）
        return converVal(root.left, cacheVal);
    } 
    return root.val;
}
複製代碼

解法二：把解法一中的 cacheVal 提出來放在外圍搞一個閉包，而後就不用每次遞歸傳進去了，這樣只須要從大到小遍歷便可，簡單易懂。

/** * Definition for a binary tree node. * function TreeNode(val) { * this.val = val; * this.left = this.right = null; * } */
/** * @param {TreeNode} root * @return {TreeNode} */
var convertBST = function(root) {
    let sum = 0;
    
    return function inner(root) {
        if (root == null) return null;
        inner(root.right);
        root.val += sum;
        sum = root.val;
        inner(root.left);
        return root;
    }(root);
};
複製代碼

543. Diameter of Binary Tree

給定二叉樹，計算樹的直徑長度 - 二叉樹的直徑是樹中任意兩個節點之間最長路徑的長度。此路徑可能會也可能不會經過根節點。

遞歸，由於是尋找一條最長的路徑，所以分紅兩個狀況考慮：

尋找當前子樹左子樹和右子樹單側最長路徑，並返回給上一層使用
返回當前子樹最長路徑（左子樹最長路徑 + 當前根節點(1） + 右子樹最長路徑給上一層使用

最後找出這二者更大的一個便可

/** * Definition for a binary tree node. * function TreeNode(val) { * this.val = val; * this.left = this.right = null; * } */
/** * @param {TreeNode} root * @return {number} */
var diameterOfBinaryTree = function(root) {
    if(!root) return 0;
    // 返回一個最大的
    return Math.max(...diameterOfSubtree(root)) - 1;
};
function diameterOfSubtree(root) {
    if(!root.left && !root.right) return [1, 1];
    let left = 0, leftBig = 0, right = 0, rightBig = 0;
    if(root.left) [left, leftBig] = diameterOfSubtree(root.left);
    if(root.right) [right, rightBig] = diameterOfSubtree(root.right);
    // 當前子樹最長路徑
    const cacheBig = Math.max(leftBig, rightBig, left + right + 1);
    return [1 + Math.max(left, right), cacheBig];
}

複製代碼

572. Subtree of Another Tree

判斷一棵樹是否是另外一顆樹的子結構

解法一：直接遞歸看一下是否是子樹，但這樣有重複遍歷

/** * Definition for a binary tree node. * function TreeNode(val) { * this.val = val; * this.left = this.right = null; * } */
/** * @param {TreeNode} s * @param {TreeNode} t * @return {boolean} */
var isSubtree = function (s, t) {
    return !!(subtree(s, t) || 
            (s.left && isSubtree(s.left, t)) || 
            (s.right && isSubtree(s.right, t)));
};
function subtree(s, t) {
    if (!s && !t) return true;
    return ((s || {}).val === (t || {}).val) && 
            subtree(s.left, t.left) && 
            subtree(s.right, t.right);
}
複製代碼

解法二：前序遍歷樹，存成字符串，而後看看 source 裏面是否是包含 target 便可

var isSubtree = function(s, t) {
  let string1 = {str: ""};
  let string2 = {str: ""};
  treeString(s, string1);
  treeString(t, string2);

  return string1.str.includes(string2.str);
}

function treeString(root, string) {
  if (!root) {
    string.str += "X";
    return;
  }
  string.str += `,${root.val},`
  treeString(root.left, string);
  treeString(root.right, string);
}
複製代碼

581. Shortest Unsorted Continuous Subarray

最短未排序連續子數組:給定一個整數數組，您須要找到一個最短的連續的子數組，要求是若是序對此子數組進行升序排序後，整個數組也將按升序排序。

第一種簡單的方法是把數組進行排序，那麼原數組和新數組不同的個數即爲界限，可是這種的複雜度爲 O(nlgn) (排序後遍歷)

或者咱們能夠用兩個指針，一個從前向後，一個從後向前

從前向後的尋找最後一個不爲最大值的索引
從後向前的尋找第一個不爲最小值的索引

而後就能得出哪一段是沒有按照升序排序的了

/** * @param {number[]} nums * @return {number} */
var findUnsortedSubarray = function(nums) {
    let last = 0, first = -1, max = -Infinity, min = Infinity;
    for(let i = 0, j = nums.length - 1; j >= 0; j--, i++){
        max = Math.max(max, nums[i]);
        if(nums[i] !== max) first = i;
        
        min = Math.min(min, nums[j]);
        if(nums[j] !== min) last = j;
    }
    return first - last + 1;
};
複製代碼

617. Merge Two Binary Trees

該題有疑似有惡性 bug - testcase:

Input: [] []
Expected: []
Output: null
複製代碼

遞歸：

/** * Definition for a binary tree node. * function TreeNode(val) { * this.val = val; * this.left = this.right = null; * } */
/** * @param {TreeNode} t1 * @param {TreeNode} t2 * @return {TreeNode} */
var mergeTrees = function(t1, t2) {
  if (!t1) {
    return t2;
  }
  if (!t2) {
    return t1;
  }
  t1.val += t2.val;
  t1.left = mergeTrees(t1.left, t2.left);
  t1.right = mergeTrees(t1.right, t2.right);
  return t1;
};
複製代碼

非遞歸：利用棧加樹的層次遍歷寫法

var mergeTrees = function (t1, t2) {
    if (t1 === null) {
        return t2;
    }
    const stack = [];
    stack.push([t1, t2]);
    while (stack.length !== 0) {
        const t = stack.pop();
        if (t[0] === null || t[1] === null) {
            continue;
        }
        t[0].val += t[1].val;
        if (t[0].left === null) {
            t[0].left = t[1].left;
        } else {
            stack.push([t[0].left, t[1].left]);
        }
        if (t[0].right === null) {
            t[0].right = t[1].right;
        } else {
            stack.push([t[0].right, t[1].right]);
        }
    }
    return t1;
};
複製代碼

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。