CrystalLee

给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。Demos = "leetcode"返回 0s = "loveleetcode"返回 2var firstUniqChar = function(s) { const frequency = _.countBy(s); for (const [i, ch] of Array.from(s).entries()) { if (frequency[ch] === 1) {

给定字符串J 代表石头中宝石的类型，和字符串 S代表你拥有的石头。 S 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。J 中的字母不重复，J 和 S中的所有字符都是字母。字母区分大小写，因此"a"和"A"是不同类型的石头。O(j*s)var numJewelsInStones = function (jewels, stones) { let res = 0; for (let s of stones) { for (let j of jewels) {

给你一个字符串 s，由若干单词组成，单词之间用空格隔开。返回字符串中最后一个单词的长度。如果不存在最后一个单词，请返回 0 。单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。var lengthOfLastWord = function (s) { return s.trim().split(" ").pop().length;};var lengthOfLastWord = function (s) { let cache = ""; let p = (s = s.trim

给你一个字符串 s ，将该字符串中的大写字母转换成相同的小写字母，返回新的字符串。/** * @param {string} s * @return {string} */var toLowerCase = function (s) { let str = ""; for (let c of s) { // A - Z => 65 - 90 str += c.charCodeAt() >= 65 && c.charCodeAt().

https://leetcode-cn.com/problems/coin-change/description/给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。你可以认为每种硬币的数量是无限的。动态规划var coinChange = function(coins, amount) { const dp = new Array(amount + 1).fill(amount .

https://leetcode-cn.com/problems/maximum-product-subarray/description/给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。动态规划/** * @param {number[]} nums * @return {number} */var maxProduct = function(nums) { let res = nums[0], max = .

https://leetcode-cn.com/problems/maximum-subarray/给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和动态规划dp方程： f(i) = Math.max(f(i), f(i - 1) + nums[i])var maxSubArray = function(nums) { for (let i = 1; i < nums.length; i++) { nums[i] = Mat.

https://leetcode-cn.com/problems/triangle/description/给定一个三角形 triangle ，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。dp方程：dp[i][j] = Math.min(dp[i + 1][j], dp[i + .

https://leetcode-cn.com/problems/longest-common-subsequence/给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。

https://leetcode-cn.com/problems/unique-paths-ii一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？动态规划var uniquePathsWithObstacles = function(obstacleGrid) { // obstac

https://leetcode-cn.com/problems/unique-paths一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。问总共有多少条不同的路径？动态规划var uniquePaths = function(m, n) { if (m === 0 && n === 0) return 0 let dp =

链接：https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array假设按照升序排序的数组在预先未知的某个点上进行了旋转。例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] 。请找出其中最小的元素。var findMin = function(nums) { let left = 0, right = nums.length - 1; while(left < right) {

链接：https://leetcode-cn.com/problems/search-a-2d-matrix编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：每行中的整数从左到右按升序排列。每行的第一个整数大于前一行的最后一个整数。二分法的两种实现var searchMatrix = function(matrix, target) { const array = [].concat(...matrix) let left = 0; right = ar

链接：https://leetcode-cn.com/problems/search-in-rotated-sorted-array整数数组 nums 按升序排列，数组中的值 互不相同 。在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,

题目地址：https://leetcode-cn.com/problems/walking-robot-simulation/description/var robotSim = function (commands, obstacles) { let obstacle = {}, x = 0, y = 0, res = 0; let direction = 0; //0 = north, 1 = east, 2 = south, 3 = west for (let i = 0; i &.

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

您需要在二叉树的每一行中找到最大的值。递归【BFS & DFS】/** * Definition for a binary tree node. * function TreeNode(val, left, right) { * this.val = (val===undefined ? 0 : val) * this.left = (left===undefined ? null : left) * this.right = (right===undefine

链接：https://leetcode-cn.com/problems/n-queensn 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。递归/** * @param {number} n * @return {string[][]} */var solveNQueens

题目链接： https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number/给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。输入：“23”输出：[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”].递归var letterCombinations = function(di

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。你可以假设数组是非空的，并且给定的数组总是存在多数元素。HashMap时间复杂度O(n) 空间复杂度O(n)var majorityElement = function(nums) { const n = nums.length / 2, map = {}; for (let i = 0; i < nums.length; i++) { map[nums[i]] = ma

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。递归var subsets = function(nums) { const res = []; const recursion = (level, nums, arr = []) => { if (level === nums.length) { res.push(arr) return }

给定一个 没有重复 数字的序列，返回其所有可能的全排列。var permute = function(nums) { const res = [] const recursion = (arr = []) => { if (arr.length === nums.length) { res.push(arr.slice()) return } for (let i = 0; i <

在这里插入代码片var combine = function(n, k) { const res = [] const recursion = (start, end = n, len = k, arr = []) => { if (arr.length >= len) { res.push(arr); return } } recursion(1, n, k, []) ret

返回与给定的前序和后序遍历匹配的任何二叉树。pre 和 post 遍历中的值是不同的正整数。递归：var constructFromPrePost = function(pre, post) { if (!pre.length) return null const root = new TreeNode(pre[0]) if (pre.length === 1) return root let leftlen = post.indexOf(pre[1]) + 1 root.left

根据一棵树的前序遍历与中序遍历构造二叉树。注意:你可以假设树中没有重复的元素。递归/** * Definition for a binary tree node. * function TreeNode(val) { * this.val = val; * this.left = this.right = null; * } *//** * @param {number[]} preorder * @param {number[]} inorder * @retu

根据一棵树的中序遍历与后序遍历构造二叉树。注意:你可以假设树中没有重复的元素。递归/** * Definition for a binary tree node. * function TreeNode(val) { * this.val = val; * this.left = this.right = null; * } *//** * @param {number[]} inorder * @param {number[]} postorder * @ret

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。递归/** * Definition for a binary tree node. * function TreeNode(val) { *

冒泡排序var ArraySort = function (arr) { if (!arr || arr.length === 0) { return [] } for (let i=0; i<arr.length-1; i++) { for (let j=0; j<arr.length-i-1; j++) { if(a

给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。说明：叶子节点是指没有子节点的节点。链接： https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/递归var minDepth = function(root) { const res = []; if (!root) return 0 const min = (root, level) => { if (!root) ret

递归：/** * // Definition for a Node. * function Node(val,children) { * this.val = val; * this.children = children; * }; *//** * @param {Node} root * @return {number[][]} */var levelOrder = function(root) { let result = [], index = 0;

给定一个 N 叉树，返回其节点值的前序遍历。题目链接： https://leetcode-cn.com/problems/n-ary-tree-preorder-traversal/递归：/** * // Definition for a Node. * function Node(val, children) { * this.val = val; * this.children = children; * }; *//** * @param {Node} root

const recursion = (level, params) =>{ // recursion terminator if(level > MAX_LEVEL){ process_result return } // process current level process(level, params) //drill down recursion(level+1, params) //clean current le

Crystalの算法学习-动态规划相关题目无重复字符的最长子串

验证二叉搜索树链接：https://leetcode-cn.com/problems/validate-binary-search-tree给定一个二叉树，判断其是否是一个有效的二叉搜索树。假设一个二叉搜索树具有如下特征：节点的左子树只包含小于当前节点的数。节点的右子树只包含大于当前节点的数。所有左子树和右子树自身必须也是二叉搜索树/** * Definition for a binary tree node. * function TreeNode(val) { * this.

括号生成数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。输入：n = 3输出：[“((()))”,“(()())”,“(())()”,“()(())”,“()()()”]递归/** * @param {number} n * @return {string[]} */var generateParenthesis = function(n) { const res = [] if (!n) return res;

前端JS算法学习 排序算法相关总结包含： 桶排序，冒泡排序，快速排序等

给定一个正整数 num，编写一个函数，如果 num 是一个完全平方数，则返回 True，否则返回 False。说明：不要使用任何内置的库函数，如 sqrt。链接：https://leetcode-cn.com/problems/valid-perfect-square输入：16输出：True...

实现 int sqrt(int x) 函数。计算并返回 x 的平方根，其中 x 是非负整数。由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。链接：https://leetcode-cn.com/problems/sqrtx输入: 4输出: 2二分/** * @param {number} x * @return {number} */var mySqrt = function(x) { if (x === 0 || x === 1) return x let l

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii输入: [7,1,5,3,6,4]输出: 7解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖