feat: update 3 leetcode

Author: kyriejoshua

leetcode/46.permutations.js

@@ -0,0 +1,58 @@
+/*
+ * @lc app=leetcode id=46 lang=javascript
+ *
+ * [46] Permutations
+ */
+
+// @lc code=start
+/**
+ * 深度优先的思路 回溯算法
+ * 如果使用广度优先遍历就得使用队列，然后编写结点类。队列中需要存储每一步的状态信息，需要存储的数据很大，真正能用到的很少。
+ * 使用深度优先遍历，直接使用了系统栈，系统栈帮助我们保存了每一个结点的状态信息。我们不用编写结点类，不必手动编写栈完成深度优先遍历。
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var permute = function(nums) {
+ if (nums.length === 0) {
+ return nums;
+ }
+ let len = nums.length;
+ let ans = []; // 保存最终结果
+ let used = []; // 保存数字是否已被使用
+
+ /**
+ * 递归函数
+ * @param {*} arr 原数组
+ * @param {*} len 原数组长度，用于判断遍历是否结束
+ * @param {*} depth 深度，用于判断当前的深度遍历是否结束
+ * @param {*} path 保存当前的值
+ * @param {*} used 保存当前的值是否已经使用
+ * @param {*} ans 最终结果的数组
+ * @returns
+ */
+ function dfs(arr, len, depth, path, used, ans) {
+ // 注意是遍历到数组的长度那一层结束的，尽管开始是从第 0 层，但结束是在数组的长度值那一层
+ if (depth === len) {
+ ans.push(path.slice());
+ return;
+ }
+
+ for (let i = 0; i < len; i++) {
+ if (used[i]) {
+ continue;
+ }
+ // 保存路径并标记使用
+ path.push(arr[i]);
+ used[i] = true;
+ dfs(arr, len, depth + 1, path, used, ans);
+ // 保存后重置状态
+ path.pop();
+ used[i] = false;
+ }
+ }
+
+ dfs(nums, len, 0, [], used, ans);
+
+ return ans;
+};
+// @lc code=end

leetcode/56.merge-intervals.js

@@ -0,0 +1,48 @@
+/*
+ * @lc app=leetcode id=56 lang=javascript
+ *
+ * [56] Merge Intervals
+ */
+
+// @lc code=start
+/**
+ * @param {number[][]} intervals
+ * @return {number[][]}
+ */
+var merge = function(intervals) {
+ // 首先排序获得递增的顺序，方便后续判断
+ const sorted = intervals.sort((arr1, arr2) => arr1[0] - arr2[0]);
+ let i = 1; // 从第二位开始遍历，因为会和旧值比较
+ let last = sorted[0]; // 保存初始的上一个值也就是第一个值
+ let ans = []; // 保存结果内容
+
+ while (i < sorted.length) {
+ const cur = sorted[i]; // 当前值
+ const [firstOfLast, secondOfLast] = last;
+ const [firstOfCur, secondOfCur] = cur;
+ // 如果上一个值和当前值正好是连续的，就合并
+ if (secondOfLast >= firstOfCur && secondOfLast <= secondOfCur) {
+ last = [firstOfLast, secondOfCur];
+ } else if (secondOfLast >= secondOfCur) {
+ // 如果旧值的第二个数大于当前的第二个数，说明旧值区间覆盖了当前区间，所以可以直接使用旧值
+ // last = last;
+ } else {
+ // 如果旧值区间和当前区间不重合，则保存旧值区间，并重置旧值区间
+ ans.push(last);
+ last = cur;
+ }
+ // 如果到了最后一个，直接保存
+ if (i === sorted.length - 1) {
+ ans.push(last);
+ }
+ i++;
+ };
+ // 如果到最后只剩一个合并内容，就直接返回这个合并值
+ if (ans.length === 0) {
+ return [last];
+ }
+
+ return ans;
+
+};
+// @lc code=end

leetcode/78.subsets.js

@@ -0,0 +1,41 @@
+/*
+ * @lc app=leetcode id=78 lang=javascript
+ *
+ * [78] Subsets
+ */
+
+// @lc code=start
+/**
+ * 回溯算法
+ * 获取所有子集的通用写法
+ * 时间复杂度：O(n * 2 ^ n)。一共 2^n个状态，每种状态需要 O(n)O(n) 的时间来构造子集。
+ * 空间复杂度：O(n)。临时数组 list 的空间代价是 O(n)，递归时栈空间的代价为 O(n)。
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var subsets = function(nums) {
+ let list = [];
+ let ans = [];
+
+ /**
+ * 获取所有子集的通用递归写法
+ * @param {*} depth 当前层级
+ * @param {*} nums 总长度
+ * @returns
+ */
+ function dfs(depth, nums) {
+ if (depth === nums.length) {
+ ans.push(list.slice());
+ return;
+ }
+ list.push(nums[depth]);
+ dfs(depth + 1, nums);
+ list.pop();
+ dfs(depth + 1, nums);
+ }
+
+ dfs(0, nums);
+
+ return ans;
+};
+// @lc code=end