目錄

• 和為K的子數組
• • 1 題目描述
  • 2 解題（Java）
  • 3 復雜性分析
• 目標和
• • 1 題目描述
  • 2 解題（Java）
  • 3 復雜性分析
• 前 K 個高頻元素
• • 1 題目描述
  • 2 解題（Java）
  • 3 復雜性分析
• 最長連續序列
• • 1 題目描述
  • 2 解題（Java）
  • 3 復雜性分析
• 撲克牌中的順子
• • 1 題目描述
  • 2 解題（Java）
  • 3 復雜性分析
• 最小覆蓋子串
• • 1 題目描述
  • 2 解題（Java）
  • 3 復雜性分析
• 字母異位詞分組
• • 1 題目描述
  • 2 解題（Java）
  • 3 復雜性分析
• 兩數之和
• • 1 題目描述
  • 2 解題（Java）
  • 3 復雜度分析
• 復雜鏈表的復制
• • 1 題目描述
  • 2 解題（java）
  • 3 復雜性分析
• 有效的括號
• • 1 題目描述
  • 2 解題（Java）
  • 3 復雜性分析
• 能否連接形成數組
• • 1 題目描述
  • 2 解題（Java）
  • 3 復雜性分析
• 最長不含重復字符的子字符串
• • 1 題目描述
  • 2 解題（Java）
  • 3 復雜性分析
• 第一個只出現一次的字符
• • 1 題目描述
  • 2 解題（Java）
  • 3 復雜性分析
• 電話號碼的字母組合
• • 1 題目描述
  • 2 解題（Java）
  • • 2.1 解題思路
    • 2.2 代碼
  • 3 復雜性分析
• 設計LRU緩存結構
• • 1 題目描述
  • 2 解題（Java）

和為K的子數組

1 題目描述

給定一個整數數組和一個整數 k，你需要找到該數組中和為 k 的連續的子數組的個數。

示例 1 :

輸入:nums = [1,1,1], k = 2
輸出: 2 , [1,1] 與 [1,1] 為兩種不同的情況。

說明 :

數組的長度為 [1, 20,000]。

數組中元素的范圍是 [-1000, 1000] ，且整數 k 的范圍是 [-1e7, 1e7]。

2 解題（Java）

前綴和 + 哈希表：

class Solution {public int subarraySum(int[] nums, int k) {Map<Integer, Integer> cache = new HashMap<>();int count = 0, pre = 0;cache.put(0, 1);for (int num : nums) {pre += num;count += cache.getOrDefault(pre - k, 0);cache.put(pre, cache.getOrDefault(pre, 0) + 1);}return count;} }

3 復雜性分析

• 時間復雜度：O(n)；
• 空間復雜度：O(n)；

目標和

1 題目描述

給你一個整數數組 nums 和一個整數 target 。

向數組中的每個整數前添加 ‘+’ 或 ‘-’ ，然后串聯起所有整數，可以構造一個 表達式 ：

• 例如，nums = [2, 1] ，可以在 2 之前添加 ‘+’ ，在 1 之前添加 ‘-’ ，然后串聯起來得到表達式 “+2-1” 。

返回可以通過上述方法構造的、運算結果等于 target 的不同 表達式 的數目。

示例 1：

輸入：nums = [1,1,1,1,1], target = 3 輸出：5 解釋：一共有 5 種方法讓最終目標和為 3 。 -1 + 1 + 1 + 1 + 1 = 3 +1 - 1 + 1 + 1 + 1 = 3 +1 + 1 - 1 + 1 + 1 = 3 +1 + 1 + 1 - 1 + 1 = 3 +1 + 1 + 1 + 1 - 1 = 3

示例 2：

輸入：nums = [1], target = 1 輸出：1

提示：

• 1 <= nums.length <= 20
• 0 <= nums[i] <= 1000
• 0 <= sum(nums[i]) <= 1000
• -1000 <= target <= 1000

2 解題（Java）

樹的后序遍歷+記憶化搜索

class Solution {Map<String, Integer> cache = new HashMap<>();int target;int[] nums;public int findTargetSumWays(int[] nums, int target) {this.target = target;this.nums = nums;return dfs(0, nums[0]) + dfs(0, -nums[0]);}int dfs(int index, int sum) {String key = index + "_" + sum;if (cache.containsKey(key)) return cache.get(key);if (index == nums.length - 1) {cache.put(key, sum == target ? 1 : 0);return cache.get(key);}int left = dfs(index + 1, sum + nums[index + 1]);int right = dfs(index + 1, sum - nums[index + 1]);cache.put(key, left + right);return cache.get(key);} }

3 復雜性分析

前 K 個高頻元素

1 題目描述

給你一個整數數組 nums 和一個整數 k ，請你返回其中出現頻率前 k 高的元素。你可以按 任意順序 返回答案。

示例 1:

輸入: nums = [1,1,1,2,2,3], k = 2
輸出: [1,2]

示例 2:

輸入: nums = [1], k = 1
輸出: [1]

提示：

• 1 <= nums.length <= 10⁵
• k 的取值范圍是 [1, 數組中不相同的元素的個數]
• 題目數據保證答案唯一，換句話說，數組中前 k 個高頻元素的集合是唯一的

進階：你所設計算法的時間復雜度 必須 優于 O(n log n) ，其中 n 是數組大小。

2 解題（Java）

HashMap + 堆排序：

class Solution {public int[] topKFrequent(int[] nums, int k) {Map<Integer, Integer> map = new HashMap<Integer, Integer>();for (int num : nums) {map.put(num, map.getOrDefault(num, 0) + 1);}// int[] 的第一個元素代表數組的值，第二個元素代表了該值出現的次數，根據第二個元素設計小根堆PriorityQueue<int[]> heap = new PriorityQueue<int[]>((o1, o2) -> o1[1] - o2[1]);for (Integer num : map.keySet()) {if (heap.size() == k) {if (heap.peek()[1] < map.get(num)) {heap.poll();heap.offer(new int[]{num, map.get(num)});}} else {heap.offer(new int[]{num, map.get(num)});}}int[] res = new int[k];int i = 0;while (!heap.isEmpty()) res[i++] = heap.poll()[0];return res;} }

3 復雜性分析

• 時間復雜度：O(Nlogk)，其中 N 為數組的長度。我們首先遍歷原數組，并使用哈希表記錄出現次數，需 O(N) 時間；隨后遍歷HashMap，由于堆的大小至多為 k，因此每次堆操作需要 O(logk) 的時間，需 O(Nlogk)的時間；總時間復雜度為O(Nlogk)；
• 空間復雜度：O(N)。哈希表 O(N)，堆 O(k)，總 O(N)；

最長連續序列

1 題目描述

給定一個未排序的整數數組 nums ，找出數字連續的最長序列（不要求序列元素在原數組中連續）的長度。

進階：你可以設計并實現時間復雜度為 O(n) 的解決方案嗎？

示例 1：

輸入：nums = [100,4,200,1,3,2]
輸出：4
解釋：最長數字連續序列是 [1, 2, 3, 4]。它的長度為 4。

示例 2：

輸入：nums = [0,3,7,2,5,8,4,6,0,1]
輸出：9

提示：

• 0 <= nums.length <= 10 ^ 4
• -10 ^ 9 <= nums[i] <= 10 ^ 9

2 解題（Java）

class Solution {public int longestConsecutive(int[] nums) {int max = 0;Set<Integer> set = new HashSet<>();for (int num : nums) set.add(num);for (int num : set) {if (!set.contains(num - 1)) {int temp = 1;while (set.contains(++num)) temp++;max = Math.max(max, temp);}}return max;} }

3 復雜性分析

• 時間復雜度O(n)：外層循環需要 O(n) 的時間復雜度；只有當一個數是連續序列的第一個數的情況下才會進入內層循環，然后在內層循環中匹配連續序列中的數，因此數組中的每個數只會進入內層循環1次，時間復雜度為O(n) ；因此總時間復雜度為 O(n)；
• 空間復雜度O(n)：Set存儲數組中的數需要 O(n) 空間；

撲克牌中的順子

1 題目描述

從撲克牌中隨機抽5張牌，判斷是不是一個順子，即這5張牌是不是連續的。2～10為數字本身，A為1，J為11，Q為12，K為13，而大、小王為 0 ，可以看成任意數字。A 不能視為 14。

示例 1:

輸入: [1,2,3,4,5] 輸出: True

示例 2:

輸入: [0,0,1,2,5] 輸出: True

限制：

數組長度為 5

數組的數取值為 [0, 13]

2 解題（Java）

class Solution {public boolean isStraight(int[] nums) {Set<Integer> repeat = new HashSet<>();int max = Integer.MIN_VALUE, min = Integer.MAX_VALUE;for(int num : nums) {if(num == 0) continue; // 跳過大小王max = Math.max(max, num); // 最大牌min = Math.min(min, num); // 最小牌if(!repeat.add(num)) return false; // 添加此牌至set，若有重復，返回 false}return max - min < 5; // 最大牌 - 最小牌 < 5 則可構成順子} }

3 復雜性分析

• 時間復雜度 O(N) = O(5) = O(1)： 其中 N 為 nums 長度，本題中 N≡5 ，遍歷數組使用 O(N) 時間；
• 空間復雜度 O(N) = O(5) = O(1)： 用于判重的輔助 Set 占用 O(N) 額外空間；

最小覆蓋子串

1 題目描述

給你一個字符串 s 、一個字符串 t 。返回 s 中涵蓋 t 所有字符的最小子串。如果 s 中不存在涵蓋 t 所有字符的子串，則返回空字符串 “” 。

注意：如果 s 中存在這樣的子串，我們保證它是唯一的答案。

示例 1：

輸入：s = “ADOBECODEBANC”, t = “ABC”
輸出：“BANC”

示例 2：

輸入：s = “a”, t = “a”
輸出：“a”

提示：

• 1 <= s.length, t.length <= 10 ^ 5
• s 和 t 由英文字母組成

進階：你能設計一個在 o(n) 時間內解決此問題的算法嗎？

2 解題（Java）

class Solution {public String minWindow(String s, String t) {Map<Character, Integer> tMap = new HashMap<>();Map<Character, Integer> windowMap = new HashMap<>();// 記錄t中所有字符及其出現的次數for (char c : t.toCharArray()) {tMap.put(c, tMap.getOrDefault(c, 0) + 1);}int left = 0, right = 0;// 記錄窗口中滿足條件的字符個數int count = 0;// 記錄最小覆蓋子串的起始索引及長度int start = 0, minLength = Integer.MAX_VALUE;while (right < s.length()) {char c = s.charAt(right);// 判斷取出的字符是否在t中if (tMap.containsKey(c)) {windowMap.put(c, windowMap.getOrDefault(c, 0) + 1);// 判斷取出的字符在窗口中出現的次數是否與t中該字符的出現次數相同if (windowMap.get(c).equals(tMap.get(c))) {count++;}}// 找到符合條件的子串后，嘗試縮小窗口while (count == tMap.size()) {if (right - left + 1 < minLength) {start = left;minLength = right - left + 1;}char c1 = s.charAt(left);left++;if (tMap.containsKey(c1)) {if (windowMap.get(c1).equals(tMap.get(c1))) {count--;}windowMap.put(c1, windowMap.get(c1) - 1);}}// 嘗試新方案right++;}return minLength == Integer.MAX_VALUE ? "" : s.substring(start, start + minLength);} }

3 復雜性分析

• 時間復雜度O(n)：n為s的長度，線性遍歷一次s;
• 空間復雜度O(n)：HashMap所占空間；

字母異位詞分組

1 題目描述

給定一個字符串數組，將字母異位詞組合在一起。字母異位詞指字母相同，但排列不同的字符串。

示例:

輸入: [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]
輸出:
[
[“ate”,“eat”,“tea”],
[“nat”,“tan”],
[“bat”]
]

說明：

• 所有輸入均為小寫字母。
• 不考慮答案輸出的順序。

2 解題（Java）

class Solution {public List<List<String>> groupAnagrams(String[] strs) {Map<String, List<String>> map = new HashMap<>();for (String str :strs) {char[] array = str.toCharArray();Arrays.sort(array);String key = new String(array);List<String> list = map.getOrDefault(key, new ArrayList<>());list.add(str);map.put(key, list);}return new ArrayList<List<String>>(map.values());} }

3 復雜性分析

• 時間復雜度O(nklogk)：其中 n 是 strs 中的字符串的數量，k 是 strs 中的字符串的的最大長度。需要遍歷 n 個字符串，對于每個字符串，需要 O(klogk) 的時間進行排序以及 O(1) 的時間更新哈希表，因此總時間復雜度是 O(nklogk)；
• 空間復雜度O(nk)：其中 n 是 strs 中的字符串的數量，k 是 strs 中的字符串的的最大長度，需要用哈希表存儲全部字符串；

兩數之和

1 題目描述

給定一個整數數組 nums 和一個目標值 target，請你在該數組中找出和為目標值的那 兩個 整數，并返回他們的數組下標。

你可以假設每種輸入只會對應一個答案。但是，數組中同一個元素不能使用兩遍。

示例:

給定 nums = [2, 7, 11, 15], target = 9
因為 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

2 解題（Java）

class Solution {public int[] twoSum(int[] nums, int target) {if (nums == null || nums.length < 2) return new int[0];Map<Integer,Integer> map = new HashMap<>();for (int i=0; i<nums.length; i++) {if (map.containsKey(target-nums[i])) {return new int[]{map.get(target-nums[i]), i};}map.put(nums[i], i);}return new int[0];} }

3 復雜度分析

• 時間復雜度：O(N)，其中 N是數組中的元素數量。對于每一個元素 x，我們可以 O(1)地尋找 target - x。
• 空間復雜度：O(N)，其中 N 是數組中的元素數量，主要為哈希表的開銷。

復雜鏈表的復制

1 題目描述

請實現 copyRandomList 函數，復制一個復雜鏈表。在復雜鏈表中，每個節點除了有一個 next 指針指向下一個節點，還有一個 random 指針指向鏈表中的任意節點或者 null。

示例 1：

輸入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
輸出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

示例 2：

輸入：head = [[1,1],[2,1]]
輸出：[[1,1],[2,1]]

示例 3：

輸入：head = [[3,null],[3,0],[3,null]]
輸出：[[3,null],[3,0],[3,null]]

示例 4：

輸入：head = []
輸出：[]

解釋：給定的鏈表為空（空指針），因此返回 null。

提示：

• -10000 <= Node.val <= 10000
• Node.random 為空（null）或指向鏈表中的節點。
• 節點數目不超過 1000 。

2 解題（java）

題意理解：

本題的意思是復制一個鏈表并返回，在這里，復制的意思是指 深拷貝（Deep Copy），事實上，與此對應的還有 淺拷貝，它們的區別是：

淺拷貝只復制指向某個對象的指針，而不復制對象本身，新舊對象還是共享同一塊內存。

但深拷貝會另外創造一個一模一樣的對象，新對象跟原對象不共享內存，修改新對象不會改到原對象。

/* // Definition for a Node. class Node {int val;Node next;Node random;public Node(int val) {this.val = val;this.next = null;this.random = null;} } */ class Solution {public Node copyRandomList(Node head) {if(head == null) return null;Node cur = head;Map<Node, Node> map = new HashMap<>();// 3. 復制各節點，并建立 “原節點 -> 新節點” 的 Map 映射while(cur != null) {map.put(cur, new Node(cur.val));cur = cur.next;}cur = head;// 4. 構建新鏈表的 next 和 random 指向while(cur != null) {map.get(cur).next = map.get(cur.next);map.get(cur).random = map.get(cur.random);cur = cur.next;}// 5. 返回新鏈表的頭節點return map.get(head);} }

3 復雜性分析

• 時間復雜度 O(N) ： 兩輪遍歷鏈表，使用 O(N)時間。
• 空間復雜度 O(N) ： 哈希表空間。

有效的括號

1 題目描述

給定一個只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判斷字符串是否有效。

有效字符串需滿足：

左括號必須用相同類型的右括號閉合。

左括號必須以正確的順序閉合。

注意空字符串可被認為是有效字符串。

示例 1:

輸入: “()”
輸出: true

示例 2:

輸入: “()[]{}”
輸出: true

示例 3:

輸入: “(]”
輸出: false

示例 4:

輸入: “([)]”
輸出: false

2 解題（Java）

棧和哈希表：

class Solution {public boolean isValid(String s) {int n = s.length();if (n % 2 == 1) {return false;}Map<Character, Character> pairs = new HashMap<>() {{put(')', '(');put(']', '[');put('}', '{');}};Deque<Character> stack = new LinkedList<>();for (int i = 0; i < n; i++) {char ch = s.charAt(i);if (pairs.containsKey(ch)) {if (stack.isEmpty() || stack.peek() != pairs.get(ch)) {return false;}stack.pop();} else {stack.push(ch);}}return stack.isEmpty();} }

3 復雜性分析

• 時間復雜度 O(N)：需要遍歷一遍 s；
• 空間復雜度 O(N)：棧使用線性的空間大小；

能否連接形成數組

1 題目描述

給你一個整數數組 arr ，數組中的每個整數互不相同 。另有一個由整數數組構成的數組 pieces，其中的整數也互不相同 。請你以任意順序連接 pieces 中的數組以形成 arr 。但是，不允許對每個數組 pieces[i] 中的整數重新排序。

如果可以連接 pieces 中的數組形成 arr ，返回 true ；否則，返回 false 。

示例 1：

輸入：arr = [85], pieces = [[85]]
輸出：true

示例 2：

輸入：arr = [15,88], pieces = [[88],[15]]
輸出：true
解釋：依次連接 [15] 和 [88]

示例 3：

輸入：arr = [49,18,16], pieces = [[16,18,49]]
輸出：false
解釋：即便數字相符，也不能重新排列pieces[0]

示例 4：

輸入：arr = [91,4,64,78], pieces = [[78],[4,64],[91]]
輸出：true
解釋：依次連接[91]、[4,64] 和 [78]

示例 5：

輸入：arr = [1,3,5,7], pieces = [[2,4,6,8]]
輸出：false

提示：

• 1 <= pieces.length <= arr.length <= 100
• sum(pieces[i].length) == arr.length
• 1 <= pieces[i].length <= arr.length
• 1 <= arr[i], pieces[i][j] <= 100
• arr 中的整數 互不相同
• pieces 中的整數 互不相同（也就是說，如果將 pieces 扁平化成一維數組，數組中的所有整數互不相同）

2 解題（Java）

class Solution {public boolean canFormArray(int[] arr, int[][] pieces) {// 構造哈希表，key為pieces中各數組的首元素，值為對應的各數組Map<Integer, int[]> map = new HashMap<>();for (int[] piece : pieces) {map.put(piece[0], piece);}// 遍歷arr數組進行判定int i = 0;while(i < arr.length) {int curVal = arr[i];// 如果map中的鍵包含curVal，繼續判定，否則返回falseif (map.containsKey(curVal)) {// 取出curVal對應的數組，繼續內循環判定，如果有一個對應不上，返回false;內循環判定成功后，回到外循環，開啟下一次判定int[] piece = map.get(curVal);for (int value : piece) {if (arr[i] == value) {i++;} else {return false;}}} else {return false;}}// 前面的判定沒有問題，返回truereturn true;} }

3 復雜性分析

• 時間復雜度O(N)：N是數組arr的長度，循環遍歷1次；
• 空間復雜度O(N)：哈希表存儲pieces，占用O(N)空間；

最長不含重復字符的子字符串

1 題目描述

請從字符串中找出一個最長的不包含重復字符的子字符串，計算該最長子字符串的長度。

示例 1:

輸入: “abcabcbb”
輸出: 3
解釋: 因為無重復字符的最長子串是 “abc”，所以其長度為 3。

示例 2:

輸入: “bbbbb”
輸出: 1
解釋: 因為無重復字符的最長子串是 “b”，所以其長度為 1。

示例 3:

輸入: “pwwkew”
輸出: 3
解釋: 因為無重復字符的最長子串是 “wke”，所以其長度為 3。請注意，你的答案必須是 子串 的長度，“pwke” 是一個子序列，不是子串。

提示：

s.length <= 40000

2 解題（Java）

class Solution {public int lengthOfLongestSubstring(String s) {Map<Character, Integer> dic = new HashMap<>();int res = 0, tmp = 0;for(int right = 0; right < s.length(); right++) {int left = dic.getOrDefault(s.charAt(right), -1); // 獲取索引leftdic.put(s.charAt(right), right); // 更新哈希表tmp = tmp < right - left ? tmp + 1 : right - left; // dp[right-1] -> dp[right]res = Math.max(res,tmp); }return res;} }

3 復雜性分析

• 時間復雜度 O(N) ： 其中 N 為字符串長度，動態規劃需遍歷計算字符串各字符；
• 空間復雜度 O(1) ： 字符的 ASCII 碼范圍為 0 ~ 127 ，哈希表 dic 最多使用 O(128)=O(1)大小的額外空間；

第一個只出現一次的字符

1 題目描述

在字符串 s 中找出第一個只出現一次的字符。如果沒有，返回一個單空格。 s 只包含小寫字母。

示例:

s = “abaccdeff”
返回 “b”

s = “”
返回 " "

限制：

0 <= s 的長度 <= 50000

2 解題（Java）

class Solution {public char firstUniqChar(String s) {Map<Character, Boolean> dic = new HashMap<>();char[] cs = s.toCharArray();for (char c : cs) {dic.put(c, !dic.containsKey(c));}for (char c : cs) {if (dic.get(c)) return c;}return ' ';} }

3 復雜性分析

• 時間復雜度 O(N) ： N 為字符串 s 的長度；需遍歷 s 兩輪，使用 O(N) ；
• 空間復雜度 O(1) ： 由于題目指出 s 只包含小寫字母，因此最多有 26 個不同字符，HashMap 存儲需占用 O(26) = O(1) 的額外空間。

電話號碼的字母組合

1 題目描述

給定一個僅包含數字 2-9 的字符串，返回所有它能表示的字母組合。

給出數字到字母的映射如下（與電話按鍵相同）。注意 1 不對應任何字母。

示例:

輸入："23" 輸出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

說明:

盡管上面的答案是按字典序排列的，但是你可以任意選擇答案輸出的順序。

2 解題（Java）

2.1 解題思路

回溯算法：

用一個哈希表存儲每個數字對應的所有字母；

回溯過程維護一個StringBuilder ans，表示字母組合；

ans初始為空，每次取電話號碼的一位數字，然后從哈希表中獲得該數字對應的所有字母，并將其中一個加入ans中；

繼續處理電話號碼后一位數字，直到處理完電話號碼的所有數字，即得到一個完整的字母組合，并將其加入結果res中；

回退，遍歷其余的字母組合，依次加入res中，返回res即可；

注：

回溯算法主要用于尋找所有的可行解，如果發現一個解不可行，再回溯尋找其它解。而在本題中，由于每個數字對應的每個字母都可能進入字母組合，因此不存在不可行的解，相當于窮舉所有解。

2.2 代碼

class Solution {List<String> res = new ArrayList<>();StringBuilder ans = new StringBuilder();Map<Character, String> dic = new HashMap<Character, String>() {{put('2', "abc");put('3', "def");put('4', "ghi");put('5', "jkl");put('6', "mno");put('7', "pqrs");put('8', "tuv");put('9', "wxyz");}};String digits;public List<String> letterCombinations(String digits) {this.digits = digits;if (digits.length() == 0) return res;backTrack(0);return res;}public void backTrack(int index) {if (index == digits.length()) {res.add(ans.toString());} else {String letters = dic.get(digits.charAt(index));for (int i=0; i<letters.length(); i++) {ans.append(letters.charAt(i));backTrack(index+1);ans.deleteCharAt(index);}}} }

3 復雜性分析

• 時間復雜度O(3 ^ M * 4 ^ N)：其中 M 是輸入中對應3個字母的數字個數（包括數字 2、3、4、5、6、8），N 是輸入中對應4個字母的數字個數（包括數字 7、9），當輸入包含M個對應3個字母的數字和N個對應4個字母的數字時，不同的字母組合共有3 ^ M * 4 ^ N種，需要遍歷每一種字母組合；
• 空間復雜度O(M + N)：其中M是輸入中對應3個字母的數字個數，N是輸入中對應4個字母的數字個數，M+N是輸入數字的總個數。除了返回值以外，空間復雜度主要取決于哈希表以及回溯過程中的遞歸調用層數，哈希表的大小與輸入無關，可以看成常數，遞歸調用層數最大為M+N；

設計LRU緩存結構

1 題目描述

設計LRU緩存結構，該結構在構造時確定大小，假設大小為K，并有如下兩個功能

• set(key, value)：將記錄(key, value)插入該結構
• get(key)：返回key對應的value值

要求

set和get方法的時間復雜度為O(1);

某個key的set或get操作一旦發生，認為這個key的記錄成了最常使用的;

當緩存的大小超過K時，移除最不經常使用的記錄，即set或get最久遠的;

解釋

若opt=1，接下來兩個整數x, y，表示set(x, y)；

若opt=2，接下來一個整數x，表示get(x)，若x未出現過或已被移除，則返回-1；

對于每個opt2，輸出一個答案；

示例1

輸入

[[1,1,1],[1,2,2],[1,3,2],[2,1],[1,4,4],[2,2]],3

返回值

[1,-1]

說明

第一次操作后：最常使用的記錄為(“1”, 1) 第二次操作后：最常使用的記錄為(“2”, 2)，(“1”, 1)變為最不常用的
第三次操作后：最常使用的記錄為(“3”, 2)，(“1”, 1)還是最不常用的 第四次操作后：最常用的記錄為(“1”, 1)，(“2”, 2)變為最不常用的
第五次操作后：大小超過了3，所以移除此時最不常使用的記錄(“2”, 2)，加入記錄(“4”,4)，并且為最常使用的記錄，然后(“3”, 2)變為最不常使用的記錄

備注

2 解題（Java）

import java.util.*;public class Solution {private Map<Integer, DLinkedNode> cache = new HashMap<>();private int k;// 使用偽頭部和偽尾部節點private DLinkedNode head = new DLinkedNode();private DLinkedNode tail = new DLinkedNode();public int[] LRU (int[][] operators, int k) {this.k = k;head.next = tail;tail.prev = head;int len = 0;for (int i=0; i<operators.length; i++) {if (operators[i][0] == 2) len++;}int[] res = new int[len];for(int i = 0, j = 0; i < operators.length; i++) {if(operators[i][0] == 1) {set(operators[i][1], operators[i][2]);} else {res[j++] = get(operators[i][1]);}}return res;}public int get(int key) {if (cache.containsKey(key)) {DLinkedNode node = cache.get(key);moveToHead(node);return node.value;}return -1;}public void set(int key, int value) {if (cache.containsKey(key)) {DLinkedNode node = cache.get(key);node.value = value;moveToHead(node);} else {if (cache.size() == k) {removeTail();}DLinkedNode node = new DLinkedNode(key, value);cache.put(key, node);addToHead(node);}}private void addToHead(DLinkedNode node) {node.prev = head;node.next = head.next;head.next.prev = node;head.next = node;}private void moveToHead(DLinkedNode node) {node.prev.next = node.next;node.next.prev = node.prev;addToHead(node);}private void removeTail() {int rk = tail.prev.key;tail.prev.prev.next = tail;tail.prev = tail.prev.prev;cache.remove(rk);}class DLinkedNode {int key, value;DLinkedNode prev, next;public DLinkedNode() {}public DLinkedNode(int key, int value) {this.key = key; this.value = value;}} }

總結

以上是生活随笔為你收集整理的Leetcode_Map、Set的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。