feat: update 6 leetcode

Author: kyriejoshua

leetcode/1446.consecutive-characters.ts

@@ -0,0 +1,63 @@
+/*
+ * @lc app=leetcode id=1446 lang=typescript
+ *
+ * [1446] Consecutive Characters
+ */
+
+// @lc code=start
+/**
+ * @description: 类似动态规划的思路？
+ * 时间复杂度 O(n)
+ * 空间复杂度 O(1)
+ * @param {string} s
+ * @return {number}
+ */
+function maxPower(s: string): number {
+ if (s.length <= 1) return 1;
+ let maxLength = 1;
+ let curLength = 1;
+
+ for (let i = 1; i < s.length; i++) {
+ if (s[i] !== s[i - 1]) {
+ curLength = 1;
+ continue;
+ }
+ curLength += 1;
+
+ if (curLength > maxLength) {
+ maxLength = curLength;
+ }
+ }
+
+ return maxLength;
+}
+/**
+ * @description: 使用哈希表的思路来解
+ * 时间复杂度 O(n)
+ * 空间复杂度 O(n)
+ * @param {string} s
+ * @return {number}
+ */
+function maxPower1(s: string): number {
+ if (s.length <= 1) return 1;
+ let maxLength = 1;
+ let hashTable: Array<{ len: number }> = [];
+
+ // 题目的条件以及上面的判断保证里字符串长度至少是 1
+ for (let i = 1; i < s.length; i++) {
+ // 如果当前数字和之前不同，则重置数量为 1
+ if (s[i] !== s[i - 1]) {
+ hashTable[i] = { len: 1 };
+ continue;
+ }
+ // 用哈希表来保存每个字符累计的次数
+ const lastLen = hashTable[i - 1] ? hashTable[i - 1].len : 1;
+ hashTable[i] = { len: lastLen + 1 };
+ if (hashTable[i].len > maxLength) {
+ maxLength = hashTable[i].len;
+ }
+ }
+
+ return maxLength;
+};
+// @lc code=end

leetcode/290.word-pattern.ts

@@ -0,0 +1,66 @@
+/*
+ * @lc app=leetcode id=290 lang=typescript
+ *
+ * [290] Word Pattern
+ */
+
+// @lc code=start
+/**
+ * @description: 哈希表的思路
+ * 时间复杂度 O(m + n)
+ * 空间复杂度 O(m + n)
+ * @param {string} pattern
+ * @param {string} s
+ * @return {boolean}
+ */
+function wordPattern(pattern: string, s: string): boolean {
+ // 转成数组方便操作
+ const strArr = s.split(' ');
+ // 如果字符长度不一致，那么肯定不遵循
+ if (pattern.length !== strArr.length) return false;
+
+ const pat2Word = new Map();
+ const word2Pat = new Map();
+
+ for (let i = 0; i < pattern.length; i++) {
+ const str = pattern[i];
+
+ if ((pat2Word.has(str) && pat2Word.get(str) !== strArr[i]) || (word2Pat.has(strArr[i]) && word2Pat.get(strArr[i]) !== str)) {
+ return false;
+ }
+ pat2Word.set(str, strArr[i]);
+ word2Pat.set(strArr[i], str);
+ }
+
+ // 遍历完成没有问题，说明验证正确
+ return true;
+};
+
+function wordPattern2(pattern: string, s: string): boolean {
+ // 转成数组方便操作
+ const strArr = s.split(' ');
+ // 如果字符长度不一致，那么肯定不遵循
+ if (pattern.length !== strArr.length) return false;
+
+ const map = new Map();
+
+ for (let i = 0; i < pattern.length; i++) {
+ const str = pattern[i];
+
+ if (map.has(str)) {
+ const strValue = map.get(str);
+ if (strValue !== strArr[i]) return false;
+ } else {
+ // 如果已经保存了这个键值，说明有重复
+ for (const val of map.values()) {
+ if (val === strArr[i]) return false;
+ }
+ map.set(str, strArr[i]);
+ }
+ }
+
+ // 遍历完成没有问题，说明验证正确
+ return true;
+};
+
+// @lc code=end

leetcode/31.next-permutation.ts

@@ -0,0 +1,69 @@
+/*
+ * @lc app=leetcode id=31 lang=typescript
+ *
+ * [31] Next Permutation
+ */
+
+// @lc code=start
+/**
+ Do not return anything, modify nums in-place instead.
+ */
+/**
+ * @description: 时间复杂度 O(n),空间复杂度 O(1)
+ * 核心是找到找到相差最小的两位，进行交换，交换之后再把这位之后的数字进行升序排列
+ * 这里相差最小的两位指的不是值相差最小，而是索引相差最小，例如 [4, 5, 2, 6, 3, 1]; 交换的是 2 和 3；
+ * 升序排列保证了取到的值是更大的数中的最小值
+ * @param {number} nums
+ * @return {void}
+ */
+function nextPermutation(nums: number[]): void {
+ let len= nums.length;
+ let i = len - 2;
+
+ // 循环找出第一个比旁边值小的数
+ // 也就是 i + 1 之后的数组元素都是降序的
+ while (i >= 0 && nums[i] >= nums[i + 1]) {
+ i--;
+ }
+
+ // 当前 i 指向的位数是第一个比右边的数小的数
+ if (i >= 0) {
+ // 寻找第一个比 i 对应的数更大的数
+ let j = len - 1;
+ while (j >= 0 && nums[i] >= nums[j]) {
+ j--;
+ }
+ swap(nums, i, j);
+ }
+
+ reverse(nums, i + 1);
+
+ /**
+ * @description: 原地交换数组内容
+ * @param {number} arr
+ * @param {number} i
+ * @param {number} j
+ * @return {void}
+ */
+ function swap(arr: number[], i: number, j: number): void {
+ [arr[j], arr[i]] = [arr[i], arr[j]];
+ }
+
+ /**
+ * @description: 双指针进行反转
+ * !为什么这里可以直接反转，因为 i 那里的循环保证了 i 之后的数据都是降序排列的
+ * @param {number} arr
+ * @param {number} start
+ * @return {void}
+ */
+ function reverse(arr: number[], start: number): void {
+ let left = start;
+ let right = arr.length - 1;
+ while (left < right) {
+ swap(nums, left, right);
+ left++;
+ right--;
+ }
+ }
+};
+// @lc code=end

leetcode/383.ransom-note.ts

@@ -0,0 +1,66 @@
+/*
+ * @lc app=leetcode id=383 lang=typescript
+ *
+ * [383] Ransom Note
+ */
+
+// @lc code=start
+/**
+ * @description: 哈希表的思路
+ * 时间复杂度 O(m * n)
+ * 空间复杂度 O(n)
+ * @param {string} ransomNote
+ * @param {string} magazine
+ * @return {boolean}
+ */
+function canConstruct(ransomNote: string, magazine: string): boolean {
+ // 说明肯定有字母没能对应上
+ if (ransomNote.length > magazine.length) return false;
+
+ // 使用额外的数组作为散列表，存储每个字母出现过的位置
+ const magazineArr = [...magazine];
+ for (const str of ransomNote) {
+ let isStrInMagazine = false;
+
+ for (let i = 0; i < magazineArr.length; i++) {
+ // 如果有对应字符，就置空索引对应的值，否则遍历结束都没有的话就直接抛出结果
+ if (magazineArr[i] === str) {
+ magazineArr[i] = undefined;
+ isStrInMagazine = true;
+ break;
+ }
+ }
+ if (!isStrInMagazine) {
+ return false;
+ }
+ }
+
+ // 赎金信遍历完成，说明没有问题
+ return true;
+};
+
+function canConstruct2(ransomNote: string, magazine: string): boolean {
+ // 说明肯定有字母没能对应上
+ if (ransomNote.length > magazine.length) return false;
+
+ // 使用额外的数组作为散列表，存储每个字母出现过的位置
+ const magazineArr = [...magazine];
+ for (const str of ransomNote) {
+ // 如果原始杂志不包含，则直接返回
+ if (!magazineArr.includes(str)) {
+ return false;
+ }
+
+ for (let i = 0; i < magazineArr.length; i++) {
+ // 如果有对应字符，就置空索引对应的值
+ if (magazineArr[i] === str) {
+ magazineArr[i] = undefined;
+ break;
+ }
+ continue;
+ }
+ }
+
+ return true;
+};
+// @lc code=end

leetcode/387.first-unique-character-in-a-string.ts

@@ -0,0 +1,42 @@
+/*
+ * @lc app=leetcode id=387 lang=typescript
+ *
+ * [387] First Unique Character in a String
+ */
+
+// @lc code=start
+/**
+ * @description: 使用 map 来保存不重复的字符
+ * 时间复杂度 O(n)
+ * @param {string} s
+ * @return {number}
+ */
+function firstUniqChar(s: string): number {
+ let obj = {}; // 保存重复的字符
+ let map = new Map(); // 保存不重复的字符的索引
+
+ // 遍历当前字符
+ for (let i = 0; i < s.length; i++) {
+ const str = s[i];
+ if (map.get(str) === undefined && !obj[str]) {
+ map.set(str, i);
+ continue;
+ }
+ map.delete(str);
+ obj[str] = true;
+ }
+
+ // 如果栈内一个保存的值都没有，说明全部都是重复的
+ if (map.size === 0) {
+ return -1;
+ }
+
+ // 因为 map 的遍历时按照插入顺序的，所以一旦有未重复的值，按照索引顺序也就是插入顺序会排在最前面
+ // for (const value of map.values()) {
+ // return value;
+ // }
+ // 这个方式来获取 map 的第一个值更加优雅
+ // 使用迭代器
+ return map.values().next().value;
+};
+// @lc code=end

leetcode/496.next-greater-element-i.ts

@@ -0,0 +1,47 @@
+/*
+ * @lc app=leetcode id=496 lang=typescript
+ *
+ * [496] Next Greater Element I
+ */
+
+// @lc code=start
+/**
+ * @description: 暴力循环法，时间复杂度 O(n*m)
+ * 其中 m 是 nums1 的长度，n 是 nums2 的长度。
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number[]}
+ */
+function nextGreaterElement(nums1: number[], nums2: number[]): number[] {
+ let res: number[] = [];
+
+ for (const num of nums1) {
+ let foundSame = false;
+ let foundBigger = false;
+ // 在父数组中查找更大的值
+ for (let i = 0; i < nums2.length; i++) {
+ const parentNum = nums2[i];
+ if (parentNum === num) {
+ foundSame = true;
+ continue;
+ }
+ // 结果不相等时继续判断是否有更大的值
+ if (parentNum !== num) {
+ if (foundSame) {
+ if (parentNum > num) {
+ res.push(parentNum);
+ foundBigger = true;
+ break;
+ }
+ }
+ continue;
+ }
+ }
+ if (!foundBigger) {
+ res.push(-1);
+ }
+ }
+
+ return res;
+};
+// @lc code=end