关于leetcode:JavaScript刷LeetCode心得

各类题的解决方案

话不多说，零碎整顿下解题的一些算法和解决方案

二叉树

二叉树大多应用递归的形式左右两个元素向下递归。比方：

计算二叉树最大深度

var maxDepth = function (root) {if (root == null) return 0
    return 1 + Math.max(maxDepth(root.left), maxDepth(root.right))
};

将二叉树以二维数组模式体现

var levelOrder = function(root) {let ans = []
    helper(root, ans, 0)
    return ans
};

function helper(node, ans, i){if (node == null) return
    if (i == ans.length) ans.push([])
    ans[i].push(node.val)

    helper(node.left, ans, i + 1)
    helper(node.right, ans, i + 1)
}

都是通过递归形式逐层向上来查找二叉树数据。

可能性问题

这类题个别是通知你一组数据，而后求出可能性、最小值或最大值。比方：

给定几种面额的硬币和一个总额，应用起码的硬币凑成这个总额。

var coinChange = function (coins, amount) {
    let max = amount + 1
    let dp = new Array(amount + 1)
    dp.fill(max)
    dp[0] = 0

    for (let i = 1; i < max; i++) {for (let j = 0; j < coins.length; j++) {if (coins[j] <= i) {dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1)
            }
        }
    }
    return dp[amount] > amount ? -1 : dp[amount]
};

应用了动静布局（DP），将从 0 到指标额度所需的最小硬币数都列出来。

求出从矩阵左上角走到右下角，且只能向右向下挪动，一共有多少种可能性。

var uniquePaths = function (m, n) {const pos = new Array(m)
    for (let i = 0; i < m; i++) {pos[i] = new Array(n)
    }
    for (let i = 0; i < n; i++) {pos[0][i] = 1
    }
    for (let i = 0; i < m; i++) {pos[i][0] = 1
    }
    for (let i = 1; i < m; i++) {for (let j = 1; j < n; j++) {pos[i][j] = pos[i - 1][j] + pos[i][j - 1]
        }
    }
    return pos[m - 1][n - 1]
};

这题就是应用了动静布局逐渐列出每一格的可能性，最初返回右下角的可能性。

获取给定数组间断元素累加最大值

var maxSubArray = function (nums) {let count = nums[0], maxCount = nums[0]
    for (let i = 1; i < nums.length; i++) {count = Math.max(count + nums[i], nums[i])
        maxCount = Math.max(maxCount, count)    
    }
    return maxCount
};

下面这题通过一直比照最大值来保留并返回最大值。

其实，可能性问题应用 动静布局 要比应用 DFS、BFS 算法更加简略而容易了解。（我应用 DFS 常常报 TLE）

查找

个别遇到的查找问题，如查找某个值个别会用到一下办法：

• 排序算法（排序便于查找）
• 二分查找
• 索引挪动查找（这个办法名本人想的，大略就这个意思~）

查找横向和纵向都递增的二维矩阵中的某个值

var searchMatrix = function (matrix, target) {if (matrix.length == 0) return false
    let row = 0, col = matrix[0].length - 1
    while (true) {if (matrix[row][col] > target && col > 0) {col--} else if (matrix[row][col] < target && row < matrix.length - 1) {row++} else if (matrix[row][col] == target) {return true} else {break}
    }
    return false
};

先将地位定位在右上角，通过扭转地位坐标来找到目标值。应用了索引挪动查找法来找到后果。

找到数组中最右边和最左边的某个数字所在位置

var searchRange = function (nums, target) {let targetIndex = binarySearch(nums, target, 0, nums.length - 1)
    if (targetIndex == -1) return [-1, -1]
    let l = targetIndex, r = targetIndex
    while(l > 0 && nums[l - 1] == target){l--}
    while(r < nums.length - 1 && nums[r + 1] == target){r++}
    return [l, r]
};

function binarySearch(arr, val, lo, hi) {if (hi < lo) return -1
    let mid = lo + parseInt((hi - lo) / 2)

    if (val < arr[mid]) {return binarySearch(arr, val, lo, mid - 1)
    } else if (val > arr[mid]) {return binarySearch(arr, val, mid + 1, hi)
    } else {return mid}
}

参考视频：传送门

这题应用 二分法 来查找到某个指标数字的索引值，而后 索引挪动法 别离向左和向右查找字符。获取左右两侧的索引值返回。

回文

所谓回文，就是正着读反着读是一样的。应用索引两边向两头挪动的形式来判断是否为回文。

找到给定字符串中某段最长的回文

var longestPalindrome = function (s) {
    let maxLength = 0, left = 0, right = 0
    for (let i = 0; i < s.length; i++) {let singleCharLength = getPalLenByCenterChar(s, i, i)
        let doubleCharLength = getPalLenByCenterChar(s, i, i + 1)
        let max = Math.max(singleCharLength, doubleCharLength)
        if (max > maxLength) {
            maxLength = max
            left = i - parseInt((max - 1) / 2)
            right = i + parseInt(max / 2)
        }
    }
    return s.slice(left, right + 1)
};

function getPalLenByCenterChar(s, left, right) {
    // 两头值为两个字符，确保两个字符相等
    if (s[left] != s[right]){return right - left}
    while (left > 0 && right < s.length - 1) {
        left--
        right++
        if (s[left] != s[right]){return right - left - 1}
    }
    return right - left + 1
}

门路题

门路题能够应用深度优先（DFS）和广度优先（BFS）算法来做。我比拟罕用的是应用 DFS 来做。通过递归将走过的门路进行标记来一直往前找到指标门路。如：

通过给定单词在二维字母数组中查找是否能应用邻近字母组成这个单词(212 题)

let hasWord = false

var findWords = function (board, words) {var ans = []
    for (let word of words) {for (let j = 0; j < board.length; j++) {for (let i = 0; i < board[0].length; i++) {if (board[j][i] == word[0]) {
                    hasWord = false
                    DFS(word, board, 0, j, i, "")
                    if (hasWord) {if (!ans.includes(word))
                            ans.push(word)
                    }
                }
            }
        }
    }
    return ans
};

function DFS(word, board, index, j, i, subStr) {if (word[index] == board[j][i]) {subStr += board[j][i]
        board[j][i] = "*"
        if (j < board.length - 1)
            DFS(word, board, index + 1, j + 1, i, subStr)
        if (j > 0)
            DFS(word, board, index + 1, j - 1, i, subStr)
        if (i < board[0].length - 1)
            DFS(word, board, index + 1, j, i + 1, subStr)
        if (i > 0)
            DFS(word, board, index + 1, j, i - 1, subStr)
        board[j][i] = word[index]
    }
    if (index >= word.length || subStr == word) {hasWord = true}
}

因为 DFS 是一条路走到黑，如果每个元素都去应用 DFS 来找会呈现超时的状况。如果条件容许（如查找递增数组）能够通过 设置缓存 来优化 DFS 查找超时问题。

获取二维矩阵中最大相邻递增数组长度。

const dirs = [[0, 1], [1, 0], [0, -1], [-1, 0]]

var longestIncreasingPath = function (matrix) {if (matrix.length == 0) return 0
    const m = matrix.length, n = matrix[0].length
    let max = 1

    let cache = new Array(m)
    for (let i = 0; i < m; i++){let child = new Array(n)
        child.fill(0)
        cache[i] = child
    }

    for (let i = 0; i < m; i++) {for (let j = 0; j < n; j++) {let len = dfs(matrix, i, j, m, n, cache)
            max = Math.max(max, len)
        }
    }
    return max
}

function dfs(matrix, i, j, m, n, cache){if (cache[i][j] != 0) return cache[i][j]
    let max = 1
    for (let dir of dirs){let x = i + dir[0], y = j + dir[1]
        if(x < 0 || x >= m || y < 0 || y >= n || matrix[x][y] <= matrix[i][j]) continue;
        let len = 1 + dfs(matrix, x, y, m, n, cache)
        max = Math.max(max, len)
    }
    cache[i][j] = max
    return max
}

将已应用 DFS 查找过的长度放入缓存，如果有其余元素走 DFS 走到以后值，间接返回缓存最大值即可。

链表

链表从 JS 的角度来说就是一串对象应用指针连贯的数据结构。正当应用 next 指针扭转指向来实现对链表的一系列操作。如：

链表的排序：

var sortList = function (head) {if (head == null || head.next == null) return head

    let prev = null, slow = head, fast = head
    while (fast != null && fast.next != null) {
        prev = slow
        slow = slow.next
        fast = fast.next.next
    }

    prev.next = null;

    let l1 = sortList(head)
    let l2 = sortList(slow)

    return merge(l1, l2)
};

function merge(l1, l2) {let l = new ListNode(0), p = l;

    while (l1 != null && l2 != null) {if (l1.val < l2.val) {
            p.next = l1;
            l1 = l1.next;
        } else {
            p.next = l2;
            l2 = l2.next;
        }
        p = p.next;
    }

    if (l1 != null)
        p.next = l1;

    if (l2 != null)
        p.next = l2;

    return l.next;
}

应用了 自上而下的归并排序办法 对链表进行了排序。应用 slow.next 和 fast.next.next 两种速度获取链表节点，从而获取两头值。

链表的倒序

var reverseList = function(head) {
    let ans = null,cur = head
    while (cur != null) {
        let nextTmp = cur.next
        cur.next = ans
        ans = cur
        cur = nextTmp
    }
    return ans
};

排序

排序和查找算是算法中最重要的问题了。罕用的排序算法有：

• 插入排序
• 抉择排序
• 疾速排序
• 归并排序
• 计数排序

更多排序算法的知识点可参考《JS 家的排序算法》，文章作者图文并茂的解说了各种排序算法，很容易了解。
举几个排序算法的栗子：

求数组中第 K 大的值

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number}
 */
var findKthLargest = function (nums, k) {for (let i = 0; i <= k; i++) {
        let max = i
        for (let j = i; j < nums.length; j++) {if (nums[j] > nums[max]) max = j
        }
        swap(nums, i, max)
    }
    return nums[k - 1]
};

function swap(arr, a, b) {let tmp = arr[a]
    arr[a] = arr[b]
    arr[b] = tmp
}

应用了 抉择排序 排列了前 K 个值得到后果。

对有反复值的数组 [2,0,2,1,1,0] 排序

var sortColors = function (nums) {sort(nums, 0, nums.length - 1)
};

function sort(arr, lo, hi) {if (hi <= lo) return
    let lt = lo, i = lo + 1, gt = hi;
    let v = arr[lo]
    while (i <= gt) {if (arr[i] < v) swap(arr, lt++, i++)
        else if (arr[i] > v) swap(arr, i, gt--)
        else i++
    }
    sort(arr, lo, lt - 1)
    sort(arr, gt + 1, hi)
}

function swap(arr, a, b) {let x = arr[a]
    arr[a] = arr[b]
    arr[b] = x
}

这种有反复值的应用 三向切分的疾速排序 是十分好的解决方案。当然，计数排序 法可是不错的抉择。
还有之前提到的链表的排序应用的是 归并排序。

算术题

算术题看似简略，然而遇到最大的问题就是：如果应用累加、累成这种常熟级别的增长，遇到很大的数字会呈现 TLE（超出工夫限度）。所以，咱们要用指数级别的增长来找到后果。如：

计算 x 的 n 次方

var myPow = function (x, n) {if (n == 0) return 1
    if (n < 0) {
        n = -n
        x = 1 / x
    }
    return (n % 2 == 0) ? myPow(x * x, parseInt(n / 2)) : x * myPow(x * x, parseInt(n / 2));
};

一开始我应用了 xx 这么乘上 n 次，然而遇到 n 太大就间接超时了。应用以上计划：29 = 2 44 = 2 82 = 2 64 = 128
间接从常熟级变动变为指数级变动，这一点在数学运算中是须要留神的。

求 x 的平方根

var mySqrt = function (x) {
    let l = 0, r = x
    while (true) {let mid = parseInt(l + (r - l) / 2)
        if (mid * mid > x) {r = mid - 1} else if (mid * mid < x) {if ((mid + 1) * (mid + 1) > x) {return mid}
            l = mid + 1
        } else {return mid}
    }
};

这题应用二分法来找到后果。

二进制问题

二进制问题，个别应用按位运算符和二进制转换 Number.parseInt() 和 Number.prototype.toString()来解决。

将一个 32 位数字的二进制进行倒序

var reverseBits = function(n) {var t = n.toString(2).split("");
    while(t.length < 32) t.unshift("0"); // 插入足够的 0
    return parseInt(t.reverse().join(""), 2);
};

罕用算法

讲了这么多，其实除了罕用的排序、搜寻，其余最罕用的就是 DP、DFS、BFS 这三个算法了。能够这么说：把握了排序和这三个算法，能够 AC 大多数的算法问题。这么牛逼的算法理解一下？

简略说说几种排序和查找

• 冒泡排序：遍历数组，比照元素和前面相邻元素，如果以后元素大于前面元素，调换地位。这样从头遍历到尾，获取最初一位排序玩的元素。而后在 1 到 n – 1 中再次反复以上步骤。直到最初第一和第二个元素对比大小。是一种从后往前的排序。
• 抉择排序：遍历数组，找到最小的元素地位，与第一个元素调换地位，而后放大范畴从第二个元素开始遍历，如此反复到最初一个元素。能够从后往前也能够从前往后排序。

function sort(arr) {
    const len = arr.length
    for (let i = 0; i < len; i++) {
        let min = i
        for (let j = i + 1; j < len; j++) {if (arr[j] < arr[min]) min = j
        }
        swap(arr, i, min)
        console.log(arr)
    }
    return arr
}

• 插入排序：遍历数组，选中某一个元素，与后面相邻元素对比，如果以后元素小于之前元素，调换地位，持续比照直到以后元素前的元素小于以后元素（或者到最后面），如此对所有元素排序一遍。是一种从前往后的排序。

function sort(arr) {
    const len = arr.length
    for (let i = 1; i < len; i++) {for (let j = i; j > 0 && arr[j] < arr[j - 1]; j--) {swap(arr, j, j - 1)
            console.log(arr)
        }
    }
    return arr
}

• 希尔排序：相似于插入排序，选中一个元素与元素前 n 个元素进行比大小和调换地位。之后再放大 n 的值。这种办法能够缩小插入排序中最小值在最初面，而后须要一个一个调换地位晓得最后面这类问题。缩小调换次数。是一种从前往后的排序。
• 归并排序：在《算法》中提到了两种归并排序：一种是自上而下的归并排序。将数组一直二分到最小单位（1 到 2 个元素）将他们进行排序，之后将前两个和后两个元素对比，如此往上最初实现整个数组的排序。还有一种自下而上的归并排序是间接将数组宰割为若干个子数组进行排序而后合并。

let aux = new Array(arr.length)
function sort(arr, lo, hi) {if (hi <= lo) return
    let mid = lo + (parseInt((hi - lo) / 2))

    sort(arr, lo, mid)
    sort(arr, mid + 1, hi)
    merge(arr, lo, mid, hi)
}

function merge(arr, lo, mid, hi) {
    let i = lo, j = mid + 1
    for (let k = lo; k <= hi; k++) {aux[k] = arr[k]
    }
    for (let k = lo; k <= hi; k++) {if (i > mid) arr[k] = aux[j++]
        else if (j > hi) arr[k] = aux[i++]
        else if (aux[j] < aux[i]) arr[k] = aux[j++]
        else arr[k] = aux[i++]
    }
    console.log(arr)
}

• 疾速排序：选定第一个值为两头值，而后将小于两头值的元素放在两头值的左侧而大于两头值的元素放在两头值右侧，而后对两侧的元素别离再次切割，直到最小单位。

function sort(arr, lo, hi) {if (hi <= lo + 1) return
    let mid = partition(arr, lo, hi) // 切分办法
    sort(arr, lo, mid)
    sort(arr, mid + 1, hi)
}

function partition(arr, lo, hi) {
    let i = lo, j = hi + 1
    let v = arr[lo]
    while(true) {while(arr[++i] < v) if (i == hi) break
        while(v < arr[--j]) if (j == lo) break
        if ((i >= j)) break
        swap(arr, i, j)
        console.log(arr)
    }
    swap(arr, lo, j)
    console.log(arr)
    return j
}

• 三向切分的疾速排序 ：相似于疾速排序，优化点在于如果某个元素等于切分元素，元素地位不变。最初小于切分元素的到右边，等于切分元素的依据数量放在两头，大于切分元素的放在左边。 实用于有大量雷同大小元素的数组。

function sort(arr, lo, hi) {if (hi <= lo) return
    let lt = lo, i = lo + 1, gt = hi;
    let v = arr[lo]
    while (i <= gt) {if (arr[i] < v) swap(arr, lt++, i++)
        else if (arr[i] > v) swap(arr, i, gt--)
        else i++
        console.log(arr)
    }
    sort(arr, lo, lt - 1)
    sort(arr, gt + 1, hi)
}

• 堆排序：堆排序能够说是一种利用堆的概念来排序的抉择排序。应用优先队列返回最大值的个性一一返回以后堆的最大值。
• 计数排序：就是将数组中所有元素的呈现次数保留在一个数组中，而后依照从小到大返回排序后的数组。
• 桶排序：其实就是字符串排序的 LSD 和 MSD 排序。LSD 应用索引计数法从字符串左边向右边挪动，依据以后值进行排序。而 MSD 是从左到右应用索引计数法来排序，在字符串第一个字符后，将字符串数组分为若干个雷同首字符串的数组各自进行第二、第三次的 MSD 排序。
• 二分查找：对有序数组去两头值与目标值相比对。如果目标值小于两头值，取前一半数组持续二分。如果目标值大于两头值，取后一半数组持续二分。如果目标值等于两头值，命中！

DP

我的了解：动静布局就是下一状态能够依据上一状态，或之前几个状态获取到的一种推理过程。

DFS

深度优先搜寻（DFS）就是选中某条从条件 1 到条件 2 的某条可能性进行搜寻，之后返回搜寻其余一条可能性，如此一条条升入。举个栗子，如果有 5 条路，那么 DFS 算法就是只排出一个斥候先走一条路走到底去侦察，如果走不通那么返回走下一条门路。

DFS（顶点 v）{
  标记 v 为已遍历；for（对于每一个邻接 v 且未标记遍历的点 u）DFS（u）;
}

DFS 应用的是递归的形式进行搜寻的。

示例：在二维字母矩阵中查找是否可能应用相邻字母组成指标单词。

var exist = function (board, word) {for (let y = 0; y < board.length; y++) {for (let x = 0; x < board[0].length; x++) {if (find(board, word, y, x, 0)) return true
        }
    }
    return false
};

function find(board, word, y, x, d) {if (d == word.length) return true
    if (y < 0 || x < 0 || y == board.length || x == board[y].length) return false;
    if (board[y][x] != word[d]) return false
    let tmp = board[y][x]
    board[y][x] = "*"
    let exist = find(board, word, y, x + 1, d + 1)
        || find(board, word, y, x - 1, d + 1)
        || find(board, word, y + 1, x, d + 1)
        || find(board, word, y - 1, x, d + 1)
    board[y][x] = tmp
    return exist
}

BFS

广度优先搜寻（BFS）就是将从条件 1 到条件 2 的所有可能性都列出来同步搜寻的过程。实用于查找最短门路。举个栗子，如果有 5 条路，那么 BFS 算法就是别离向 5 条路排出斥候去侦察。

BFS()
{
  输出起始点；初始化所有顶点标记为未遍历；初始化一个队列 queue 并将起始点放入队列；while（queue 不为空）{

    从队列中删除一个顶点 s 并标记为已遍历；将 s 邻接的所有还没遍历的点退出队列；}
}

BFS 是应用数组存储下一顶点的形式。

示例：每次扭转一次字母，通过给定数组中的单词，从单词 A 变为单词 B。（127 题）

/** * @param {string} beginWord * @param {string} endWord * @param {string[]} wordList * @return {number} */
var ladderLength = function (beginWord, endWord, wordList) {if (!wordList.includes(endWord)) return 0
    let set = new Set(),
        visited = new Set(),
        len = 1

    set.add(beginWord)
    visited.add(beginWord)
    while (set.size != 0) {let tmp = new Set([...set])

        for (let w of tmp) {visited.add(w)
            set.delete(w)

            if (changeOneChar(w, endWord))
                return len + 1

            for (let word of wordList){if (changeOneChar(w, word) && !visited.has(word)){set.add(word)
                }
            }
        }
        len++
    }
    return 0
};

function changeOneChar(a, b) {
    let count = 0
    for (let i = 0; i < a.length; i++)
        if (a[i] != b[i])
            count++
    return count == 1
}

最初

写下 AC 一遍题目之后的播种。

• 晓得了方法论，做起题来轻松了不少。
• 遇到问题多找轮子，肯定有某种方法论能够用。
• 不要耍小聪明用一些奇巧淫技，思路不对再怎么绕都是浪费时间。
• 不要想着本人造轮子（特地是算法方面），绝大多数问题前辈肯定有更好更欠缺的计划在。本人造轮子费时费事又没太大意义。
• 看答案和本人做是两回事，本人入手实现了能力算是会了。
• 算法之所以存在，就是用来适应某些场景、解决某类问题的。在对的场景抉择对的算法能力体现算法的价值，不要滥用算法。
• 没必要把所有算法都精通，但起码在遇到问题时能够找到最优算法解决问题。即晓得算法的存在及其用处，按需深刻学习。

其实刷算法题还是很乏味的事件，之后打算把 LeetCode 题库中的所有问题都刷一遍~

PS：本文以及相干我的项目中有任何谬误或者能够改良的中央，还请提出。共同进步~