文章目錄

• 前言
• 一、簡單題
• • 1. 兩數之和
  • 7. 整數反轉
  • 9. 回文數
  • 13. 羅馬數字轉整數
  • 14. 最長公共前綴
  • 20. 有效的括號
  • 21. 合并兩個有序鏈表
  • 26. 刪除有序數組中的重復項
  • 27. 移除元素
  • 28. 實現 strStr()
  • 35. 搜索插入位置
  • 38. 外觀數列
  • 53. 最大子序和
  • 58. 最后一個單詞的長度
  • 66. 加一
  • 70. 爬樓梯
  • 101. 對稱二叉樹
  • 110. 平衡二叉樹
  • 118. 楊輝三角
  • 217. 存在重復元素
  • 219. 存在重復元素 II
  • 283. 移動零
  • 509. 斐波那契數
  • 643. 子數組最大平均數 I
  • 976. 三角形的最大周長
  • 1137. 第 N 個泰波那契數
• 二、中等題
• • 2. 兩數相加
  • 3. 無重復字符的最長子串
  • 5. 最長回文子串
  • 6. Z 字形變換
  • 8. 字符串轉換整數 (atoi)
  • 17. 電話號碼的字母組合
  • 46. 全排列
  • 62. 不同路徑
  • 73. 矩陣置零
  • 94. 二叉樹的中序遍歷
  • 130. 被圍繞的區域
  • 144. 二叉樹的前序遍歷
  • 145. 二叉樹的后序遍歷
  • 198. 打家劫舍
  • 200. 島嶼數量
  • 445. 兩數相加 II
  • 486. 預測贏家
  • 503. 下一個更大元素 II
  • 567. 字符串的排列
  • 877. 石子游戲
• 總結

---

前言

???????從第一次進入力扣，和朋友們琢磨著第一題的兩數之和，到現在玩力扣有一個多學期了。雖然沒有系統的訓練，但還是見識到了一些基礎的算法。先把做過的題總結了，然后接下來就撿一些重點算法去打。

---

一、簡單題

1. 兩數之和

方法：暴力，快慢指針

class Solution {public int[] twoSum(int[] nums, int target) {int[] ans = new int[2];for (int i = 0;i < nums.length;++i){for (int j = i + 1;j < nums.length;++j) {if(nums[j] == target-nums[i]) {ans[0] = i;ans[1] = j;return ans;}}}return ans;} }

---

7. 整數反轉

方法：一位一位反轉（注意：判斷溢出）

class Solution {public int reverse(int x) {int ans = 0;while (x != 0) {// 判斷當前值是否溢出if ((ans * 10) / 10 != ans) {ans = 0;break;}// 反轉當前位ans = ans * 10 + x % 10;x = x / 10;}return ans;} }

---

9. 回文數

方法：反轉此數，判斷反轉前后是否相等

class Solution {public boolean isPalindrome(int x) {if (x < 0){// 負數直接返回falsereturn false;}int ans = 0, m = x;while (m != 0) {// 反轉x為ansans = ans * 10 + m % 10;m = m / 10;}if (x == ans){return true;}else{return false;}} }

---

13. 羅馬數字轉整數

方法：循環嵌套switch開關，選擇對應的轉換值

class Solution { public:int romanToInt(string s) {int ans = 0;for (int i = 0;i<s.size();i++) {switch (s[i]){case 'I': {if (s[i + 1] == 'V') { ans += 4; i++; break; }if (s[i + 1] == 'X') { ans += 9; i++; break; }ans += 1; }break;case 'V':ans += 5; break;case 'X': {if (s[i + 1] == 'L') { ans += 40; i++; break; }if (s[i + 1] == 'C') { ans += 90; i++; break; }ans += 10;}break;case 'L':ans += 50; break;case 'C': {if (s[i + 1] == 'D') { ans += 400; i++; break; }if (s[i + 1] == 'M') { ans += 900; i++; break; }ans += 100;}break;case 'D':ans += 500; break;case 'M':ans += 1000; break;}}return ans;} };

---

14. 最長公共前綴

方法：按住第一個串，將其逐個字符與后面的串中對應下標字符比較
注意：當首串當前字符下標與后面某個串的串長相等時，即可不再比較

class Solution {public String longestCommonPrefix(String[] strs) {if (strs == null || strs.length == 0) {return "";}for (int i = 0; i < strs[0].length(); ++i){// 按住第一個串char c = strs[0].charAt(i);for (int j = 1;j < strs.length; ++j){// 將其與后面的串縱向比較if (i == strs[j].length() || strs[j].charAt(i) != c){return strs[0].substring(0, i);}}}return strs[0];} }

---

20. 有效的括號

方法：左括號逐個進棧，右括號逐個與棧頂左括號匹配

關鍵點：

以棧的形式使用Deque（java）

當左括號比右括號多時，匹配結束棧不為空

class Solution {public boolean isValid(String s) {Deque<Character> stack = new LinkedList<>();for (int i = 0; i < s.length(); ++i){// 若是左括號"(", "[", "{", 入棧 if (s.charAt(i) == '(' || s.charAt(i) == '[' || s.charAt(i) == '{'){stack.push(s.charAt(i));}// 若是右括號")", "]", "}", 判斷后出棧 if (s.charAt(i) == ')'){if (!stack.isEmpty() && stack.peek() == '('){stack.pop();}else{return false;}}else if (s.charAt(i) == ']'){if (!stack.isEmpty() && stack.peek() == '['){stack.pop();}else{return false;}}else if (s.charAt(i) == '}'){if (!stack.isEmpty() && stack.peek() == '{'){stack.pop();}else{return false;}}}// 若左括號比右括號多，則不匹配，即棧不為空return stack.isEmpty();} }

---

21. 合并兩個有序鏈表

方法：雙指針+啞元

class Solution { public:ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {ListNode *ehead=new ListNode;//啞節點ehead（頭節點） ListNode *e=ehead;while(l1&&l2){ //l1在第一條鏈移動，l2在第二條鏈移動if(l1->val<=l2->val){e->next=l1;l1=l1->next;}else{e->next=l2;l2=l2->next;} e=e->next;}e->next = l1 == nullptr ? l2 : l1; //連接后續節點ehead=ehead->next; //去啞節點return ehead;} };

---

26. 刪除有序數組中的重復項

方法：快慢指針

關鍵點：

快指針負責跳過重復元素

慢指針負責把不重復的元素記錄在數組前端

class Solution { public:int removeDuplicates(vector<int>& nums) {if(nums.size()==0)return 0;int i=0,j,flag=1;for(j=i+1;j<=nums.size()-1;++j){//j慢指針，i快指針if(nums[j]<=nums[i])continue;else {nums[++i]=nums[j];flag++;//有賦值則標記加1}}return flag;} };

---

27. 移除元素

方法：快慢指針

關鍵點：

慢指針負責找目標val值

快指針負責將val值移動到數組后端

class Solution {public int removeElement(int[] nums, int val) {int i = 0, flag;for (; i<nums.length; ++i){//慢指針遍歷數組if (nums[i] == val) {//如果出現val值，動用快指針flag=1;for (int j = i; flag==1 && j < nums.length; ++j)//快指針if (nums[j] != val) {//搜索第一個與val值不同的元素，兩者交換int temp = nums[j];nums[j] = nums[i];nums[i] = temp;flag = 0;}if (flag == 1)break;//如果快指針一趟循環后無交換，意味數組已成型}}return i;//慢指針移動次數=新數組長度} }

---

28. 實現 strStr()

關鍵點（滑動窗口）：

維護窗口起始位start

使用substring截斷進行比較

public class Solution {public int strStr(String haystack, String needle) {int n = needle.length();int h = haystack.length();for (int start = 0; start < h - n + 1; start++) { // 維護長度n的窗口if (haystack.substring(start, start + n).equals(needle)) {return start;}}return -1;} }

---

35. 搜索插入位置

方法：暴力

class Solution {public int searchInsert(int[] nums, int target) {for (int i = 0; i < nums.length; ++i){if (nums[i] < target){continue;}else{return i;}}return nums.length;} }

---

38. 外觀數列

class Solution {public String countAndSay(int n) {// 遞歸終止條件if (n == 1) {return "1";}// 獲取到上一層的字符串String s = countAndSay(n - 1);StringBuilder result = new StringBuilder();// 記錄每個數字的開始索引int start = 0;for (int i = 1; i < s.length(); i++) {// 當數字發生改變時執行if (s.charAt(i) != s.charAt(start)) {result.append(i - start).append(s.charAt(start));start = i;}}// 字符串最后一個數字result.append(s.length() - start).append(s.charAt(start));return result.toString();} }

---

53. 最大子序和

關鍵點（動態規劃）：

pre維護的窗口的含義

class Solution {public int maxSubArray(int[] nums) {int pre = 0, maxAns = nums[0];for (int x : nums) {pre = Math.max(pre + x, x);// pre維護一個滑窗的子序和（正整數）maxAns = Math.max(maxAns, pre);// 挑選pre滑過的子序和中最大的一個}return maxAns;} }

---

58. 最后一個單詞的長度

方法：暴力

class Solution {public int lengthOfLastWord(String s) {int count = 0;s = s.toLowerCase();for (int i = s.length() - 1; i >= 0; --i){if (s.charAt(i) >= 'a' && s.charAt(i) <= 'z'){// 計算字母數量count++;}else if (count > 0){// 從第一個不屬于最后一個單詞的字母的字符截斷break; }}return count;} }

---

66. 加一

關鍵點（暴力）：

因為是加1，固不進位即可返回

溢出需構建長度為原數組長度+1的新數組，首元素初始化為1即可

class Solution {public int[] plusOne(int[] digits) {for (int i = digits.length - 1; i >= 0; i--) {digits[i]++;// 加一或進位digits[i] = digits[i] % 10;// 保證數組元素為單位數if (digits[i] != 0) return digits;// 無進位，返回}digits = new int[digits.length + 1];// 循環結束證明溢出，構建新數組digits[0] = 1;return digits;} }

---

70. 爬樓梯

關鍵點（動態規劃）：方程 F（n）= F（n - 1）- F（n - 2）

class Solution {public int climbStairs(int n) {int p = 0, q = 0, r = 1;for (int i=0; i<n; ++i){// 滾動數組p = q;// 記錄n-2的狀態q = r;// 記錄n-1的狀態r = p + q;// 動態規劃方程：f(n)=f(n-1)+f(n-2)}return r;} }

---

101. 對稱二叉樹

關鍵點（雙指針）：

遞歸的傳參方式：check(p.left, q.right) && check(p.right, q.left)

遞歸的出口判斷：&& 要在 || 前面，幫 || 過濾兩個節點都是空的情況

class Solution {public boolean isSymmetric(TreeNode root) {return check(root, root);}public boolean check(TreeNode p, TreeNode q) {// 如果傳來的兩個節點都為空，則兩個父節點都沒有這個對稱位上的子節點，對稱if (p == null && q == null) { return true;}// 如果只有一個節點為空，則兩個父節點中只有一個存在此子節點，則不對稱if (p == null || q == null) { return false;}// 如果都不為空，則將比較當前節點值val得出的結果與下一次遞歸返回結果做&&return p.val == q.val && check(p.left, q.right) && check(p.right, q.left);} }

---

110. 平衡二叉樹

關鍵點：
在計算二叉樹的算法基礎上加判斷：兩個子樹的高度絕對值是否滿足題目定義。

class Solution {public boolean isBalanced(TreeNode root) {return hightree(root) != -1;}public static int hightree(TreeNode root) {int H, H1, H2;if (root == null){H = 0;}else {H1 = hightree(root.left);H2 = hightree(root.right);if (H1 == -1 || H2 == -1){// 兩個子樹都不滿足，直接返回return -1;}if (Math.abs(H1 - H2) > 1){// 用高度平衡二叉樹的定義作判斷return -1;}H = (H1 > H2 ? H1 : H2) + 1;}return H;} }

---

118. 楊輝三角

關鍵點：

找規律

每次構建answer時需重新分配其內存

沒有搞懂第二點為什么不能用List.clear()代替

class Solution {public List<List<Integer>> generate(int numRows) {List<List<Integer>> answers = new ArrayList<List<Integer>>();for (int i = 0; i < numRows; ++i){List<Integer> answer = new ArrayList<>();for (int j = 0; j <= i; ++j){if (j == 0 || j == i){answer.add(1);}else{answer.add(answers.get(i - 1).get(j - 1) + answers.get(i - 1).get(j));}}answers.add(answer);//answer.clear();}return answers;} }

---

217. 存在重復元素

關鍵點：Set中不能添加重復元素

class Solution {public boolean containsDuplicate(int[] nums) {Set<Integer> set = new HashSet<Integer>();for (int x : nums){if (!set.add(x)){return true;}}return false;} }

---

219. 存在重復元素 II

關鍵點（滑動窗口）：

用Set作為滑動窗口，若窗口內存在重復元素，則true

前進右窗：add（nums【i】），前進左窗：remove（nums【i - k】）

class Solution {public boolean containsNearbyDuplicate(int[] nums, int k) {Set<Integer> set = new HashSet<Integer>();for(int i = 0; i < nums.length; ++i) {if (set.contains(nums[i])) {return true;}set.add(nums[i]);// 前進右窗口if (set.size() > k) {set.remove(nums[i - k]);// 前進左窗口}}return false;} }

---

283. 移動零

關鍵點（雙指針）：

一次循環代替兩次，將復雜度O(n^2)降O(n)

快指針前進的條件：遇到0或完成一次賦值

class Solution {public void moveZeroes(int[] nums) {int a = 0, b = 0;// 慢指針a，快指針bwhile (b < nums.length) {if (nums[b] == 0){// 快指針b遇到0就跳b++;continue;}nums[a++] = nums[b++];// a、b完成一次賦值就跳}while (a < b) { // 填補尾部的0nums[a++] = 0;}} }

---

509. 斐波那契數

（略）

int fib(int N){if(N==0)return 0;if(N==1)return 1;return fib(N-1)+fib(N-2); }

---

643. 子數組最大平均數 I

關鍵點（滑動窗口）：

維護一個長度為k的窗口，在每次移動此窗口前，求窗口內元素平均值，取Max

class Solution {public double findMaxAverage(int[] nums, int k) {double sum = 0, maxAvg = 0;for (int i = 0; i < nums.length; ++i) {sum += nums[i];// 前進右窗口if (i == k - 1){maxAvg = sum / k;}if (i >= k){sum -= nums[i - k];// 前進左窗口maxAvg = Math.max(sum / k, maxAvg);// 求最大平均數}}return maxAvg;} }

---

976. 三角形的最大周長

方法：排序、按順序找符合條件的三角形，其周長即為數組內最大

class Solution {public int largestPerimeter(int[] A) {Arrays.sort(A);// 從大到小排序for (int i = A.length - 1; i >= 2; --i) {if (A[i - 2] + A[i - 1] > A[i]) { // 用三角形定義逐個判斷return A[i - 2] + A[i - 1] + A[i];}}return 0;} }

---

1137. 第 N 個泰波那契數

方法：動態規劃

int tribonacci(int n) {if (n < 3)return n==0?0:1;int x=0, y=1, z=1, tep;for(int i=0;i<n-2;++i){tep=x+y+z;x=y;y=z;z=tep;}return z; }

---

二、中等題

2. 兩數相加

關鍵點：雙指針，尾插，補零相加

class Solution {public ListNode addTwoNumbers(ListNode l1, ListNode l2) {ListNode head = null,tail = null; // 初始化返回鏈頭尾為nullint carry = 0; // 初始化進位符while (l1 != null || l2 != null){ int s1 = l1 == null ? 0 : l1.val; // 兩個鏈表都為null時停止int s2 = l2 == null ? 0 : l2.val; // 只有一條鏈為null則將另外一條鏈對應位補零int sum = s1 + s2 + carry; // 計算當前和if (head == null){ // 分配頭尾節點的空間head = tail = new ListNode(sum % 10);}else{ // 尾插鏈節點，tail永遠指向最后的節點tail.next = new ListNode(sum % 10);tail = tail.next;}carry = sum / 10; // 計算進位// 前進鏈1指針if (l1 != null){ l1 = l1.next;}// 前進鏈2指針if (l2 != null){ l2 = l2.next;}}// 溢出則補齊最高if (carry > 0){tail.next = new ListNode(1);}return head; // 返回鏈頭} }

---

3. 無重復字符的最長子串

關鍵點（滑動窗口）：

右窗口臨近元素的加入條件：!occ.contains(s.charAt(rk + 1))

左窗口移除元素的邏輯：剛好不包含rk+1處的重復元素

class Solution {public int lengthOfLongestSubstring(String s) {// HashSet，不可加入重復的元素Set<Character> occ = new HashSet<Character>();int n = s.length();int rk = -1, ans = 0;for (int i = 0; i < n; ++i) {if (i != 0) {// 左窗口向右移除一個字符，跳過下面while繼續進行for，直至窗口剛好不包含當前重復元素occ.remove(s.charAt(i - 1));}// 判斷rk+1是否大于n，以及HashSet中是否存在字符串rk+1處的字符while (rk + 1 < n && !occ.contains(s.charAt(rk + 1))) {// 加入HashSet，前進右窗口occ.add(s.charAt(rk + 1));++rk;}// 第 i 到 rk 個字符是一個極長的無重復字符子串，從這些極長的子串中Max一個最長子串ans = Math.max(ans, rk - i + 1);}return ans;} }

---

5. 最長回文子串

關鍵點（動態規劃）：

dp的填表方向：列自左往右，行自上往下

獲取更大的回文子串判斷條件：j - i + 1 > ans.length()

class Solution {public static String longestPalindrome(String s) {if (s.length() <= 1)return s; // 若串長小于等于1，返回原串boolean[][] dp = new boolean[s.length()][s.length()];String ans = "";for (int i = 0;i < s.length();++i){// 初始化dp數組對角線dp[i][i] = true;}ans = s.substring(1, 2);// 假設接下來沒有找到回文子串，則返回此處初始化為首字符的ansfor (int j = 1;j < s.length();++j){// 填表，列從左往右for (int i = 0;i < j;++i){// 行從上往下if (j == i + 1){// 對于長度為2的串，判斷其是否為回文串dp[i][j] = s.charAt(i)==s.charAt(j);}else{// 對于其他串，結合dp表以及當前兩個端點元素是否相等進行判斷dp[i][j] = (s.charAt(i)==s.charAt(j) && dp[i + 1][j - 1]);}// 獲取更大的回文子串if (dp[i][j] && j - i + 1 > ans.length()){ans = s.substring(i, j + 1);}}}return ans;} }

---

6. Z 字形變換

關鍵點：找規律（ 詳情見 Z字形變換（LeetCode第6題））

class Solution { public:string convert(string s, int numRows) {if (numRows == 1)return s;string ans("");int down = 2 * numRows - 4, up = 2;//設置up、down的初值for (int i = 0; i < numRows; i++) {int k = i,flag = 1;//第一行和最后一行的循環if (i == 0 || i == numRows - 1) {while (k < s.size()) {ans+=s[k];k = k + 2*numRows-2;}continue;}//中間行(第一行和最后一行之間的行)的循環elsewhile (k < s.size()) {ans += s[k];flag++ % 2 == 1 ? k = k+down : k = k+up;//用flag判斷每次循環讀取需跳躍的值}down -= 2;up += 2;//每結束一次中間行的循環up和down要變一次}return ans;} };

---

8. 字符串轉換整數 (atoi)

方法：有限狀態機（不是很會，抄的題解，知道有這回事）

class Solution {public int myAtoi(String str) {Automaton automaton = new Automaton();int length = str.length();for (int i = 0; i < length; ++i) {automaton.get(str.charAt(i));}return (int) (automaton.sign * automaton.ans);} }class Automaton {public int sign = 1;public long ans = 0;private String state = "start";private Map<String, String[]> table = new HashMap<String, String[]>() {{put("start", new String[]{"start", "signed", "in_number", "end"});put("signed", new String[]{"end", "end", "in_number", "end"});put("in_number", new String[]{"end", "end", "in_number", "end"});put("end", new String[]{"end", "end", "end", "end"});}};public void get(char c) {state = table.get(state)[get_col(c)];if ("in_number".equals(state)) {ans = ans * 10 + c - '0';ans = sign == 1 ? Math.min(ans, (long) Integer.MAX_VALUE) : Math.min(ans, -(long) Integer.MIN_VALUE);} else if ("signed".equals(state)) {sign = c == '+' ? 1 : -1;}}private int get_col(char c) {if (c == ' ') {return 0;}if (c == '+' || c == '-') {return 1;}if (Character.isDigit(c)) {return 2;}return 3;} }

---

17. 電話號碼的字母組合

關鍵點（dfs+狀態重置）：

Map、StringBuffer類型的使用

當dfs層數到達號碼串長時，剪枝

class Solution {public List<String> letterCombinations(String digits) {List<String> answers = new ArrayList<String>();if (digits.length() == 0) {return answers;}// 初始化Map為號碼與字母串的映射Map<Character, String> phoneMap = 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");}};dfs(answers, phoneMap, digits, 0, new StringBuffer());return answers;}public void dfs(List<String> answers, Map<Character, String> phoneMap, String digits, int deepth, StringBuffer path) {if (deepth == digits.length()) {answers.add(path.toString());} else {char digit = digits.charAt(deepth);// 獲取此層號碼String letters = phoneMap.get(digit);// 獲取此號碼映射的字母串for (int i = 0; i < letters.length(); i++) {// 按號碼映射的字母串的順序將字母加入路徑（入棧）path.append(letters.charAt(i));// dfs搜索下一層dfs(answers, phoneMap, digits, deepth + 1, path);// 狀態重置(出棧)path.deleteCharAt(deepth);}}} }

46. 全排列

關鍵點（dfs）：狀態變量，狀態重置，以棧的形式使用Deque（java）

class Solution {public List<List<Integer>> permute(int[] nums) {List<List<Integer>> res=new ArrayList<>();if (nums.length==0){return res;}//狀態變量path（棧），used[]，deepthDeque<Integer> path=new ArrayDeque<>();boolean[] used=new boolean[nums.length];int deepth=0;dfs(nums,res,path,used,deepth);return res;}private void dfs(int[] nums,List<List<Integer>> res,Deque<Integer> path,boolean[] used,int deepth) {if(deepth==nums.length){//“剪枝”res.add(new ArrayList<>(path));return;}for(int i=0;i<nums.length;++i){if(used[i]==true){continue;}path.addLast(nums[i]);used[i]=true;dfs(nums,res,path,used,deepth+1);path.removeLast();//狀態重置used[i]=false;}} }

---

62. 不同路徑

關鍵點（動態規劃）：

先填首行與首列

再依次列從左往右，行從上往下填表

class Solution {public int uniquePaths(int m, int n) {int[][] dp=new int[m][n];for(int i=0;i<m;++i){//首行dp[i][0]=1;}for(int i=0;i<n;++i){//首列dp[0][i]=1;}for(int i=1;i<m;++i){//填表for(int j=1;j<n;++j){dp[i][j]=dp[i-1][j]+dp[i][j-1];}}return dp[m-1][n-1];} }

---

73. 矩陣置零

關鍵點：行列標記數組，先標記再替換

class Solution {public void setZeroes(int[][] matrix) {int m = matrix.length, n = matrix[0].length;boolean[] row = new boolean[m];boolean[] col = new boolean[n];for (int i = 0; i < m; i++) {// 標記for (int j = 0; j < n; j++) {if (matrix[i][j] == 0) {row[i] = col[j] = true;}}}for (int i = 0; i < m; i++) {// 替換for (int j = 0; j < n; j++) {if (row[i] || col[j]) {matrix[i][j] = 0;}}}} }

---

94. 二叉樹的中序遍歷

(數據結構基礎)

class Solution {public List<Integer> inorderTraversal(TreeNode root) {List<Integer> answer=new ArrayList();if(root==null)return answer;PT(answer,root);return answer;}public void PT(List<Integer> answer,TreeNode root){if(root.left!=null)PT(answer,root.left);answer.add(root.val);if(root.right!=null)PT(answer,root.right)；} }

---

130. 被圍繞的區域

關鍵點（dfs）：

從上下左右四個方向深度優先搜索邊界的O以及與其相連的O，并替換成‘#’

填充所有未被搜索到的O（被圍繞的O），再將#還原為O（邊界O）

class Solution {public void solve(char[][] board) {if (board == null || board.length == 0) return;int m = board.length;int n = board[0].length;for (int i = 0; i < m; i++) {for (int j = 0; j < n; j++) {// 從邊緣o開始搜索boolean isEdge = i == 0 || j == 0 || i == m - 1 || j == n - 1;if (isEdge && board[i][j] == 'O') {dfs(board, i, j);}}}for (int i = 0; i < m; i++) {for (int j = 0; j < n; j++) {if (board[i][j] == 'O') {// 將被圍繞的O填充board[i][j] = 'X';}if (board[i][j] == '#') {// 將邊界的O還原board[i][j] = 'O';}}}}public void dfs(char[][] board, int i, int j) {if (i < 0 || j < 0 || i >= board.length || j >= board[0].length || board[i][j] == 'X' || board[i][j] == '#') {// board[i][j] == '#' 說明已經搜索過了. return;}board[i][j] = '#';dfs(board, i - 1, j); // 上dfs(board, i + 1, j); // 下dfs(board, i, j - 1); // 左dfs(board, i, j + 1); // 右} }

---

144. 二叉樹的前序遍歷

（數據結構基礎）

class Solution {public List<Integer> preorderTraversal(TreeNode root) {List<Integer> answer=new ArrayList();if(root==null)return answer;PT(answer,root);return answer;}public void PT(List<Integer> answer,TreeNode root){answer.add(root.val);if(root.left!=null)PT(answer,root.left);if(root.right!=null)PT(answer,root.right);} }

---

145. 二叉樹的后序遍歷

（數據結構基礎）

class Solution {public List<Integer> postorderTraversal(TreeNode root) {List<Integer> answer=new ArrayList();if(root==null)return answer;PT(answer,root);return answer;}public void PT(List<Integer> answer,TreeNode root){if(root.left!=null)PT(answer,root.left);if(root.right!=null)PT(answer,root.right);answer.add(root.val);} }

---

198. 打家劫舍

關鍵點（動態規劃）：

狀態轉移方程：dp[i]=max(dp[i?2]+nums[i],dp[i?1])

邊界條件：dp[0]=nums[0]，dp[1]=max(nums[0],nums[1])
?

class Solution {public int rob(int[] nums) {if(nums.length==0)return 0;if(nums.length==1)return nums[0];if(nums.length==2)return Math.max(nums[0],nums[1]);int[] dp=new int[nums.length];dp[0]=nums[0];// 只有一個房子dp[1]=Math.max(nums[0],nums[1]);// 只有兩個房子for(int i=2;i<nums.length;++i){dp[i]=Math.max(dp[i-2]+nums[i],dp[i-1]);}return dp[nums.length-1];} }

?

---

200. 島嶼數量

思路：

遍歷二維數組，遇到1，島嶼數量+1

DFS將與其連起來的1替換成0，退出DFS繼續遍歷二維數組

class Solution {public int numIslands(char[][] grid) {int num_Islands=0;for(int i=0;i<grid.length;++i){for(int j=0;j<grid[0].length;++j){if(grid[i][j]=='1'){// 遇到1++num_Islands;dfs(grid,i,j);}}}return num_Islands;}public void dfs(char[][] grid,int i,int j){if(i<0||j<0||i>grid.length-1||j>grid[0].length-1||grid[i][j]=='0'){return;// 越界則返回}grid[i][j]='0';// 替換0dfs(grid,i-1,j);// 上dfs(grid,i+1,j);// 下dfs(grid,i,j-1);// 左dfs(grid,i,j+1);// 右} }

---

445. 兩數相加 II

關鍵點（棧）：

保證位數對齊：將兩個數的每個位數都分別入棧，然后從兩個棧頂開始相加

class Solution {public ListNode addTwoNumbers(ListNode l1, ListNode l2) {Deque<Integer> s1=new ArrayDeque<>();while (l1 != null) {// 入棧s1.addLast(l1.val);l1 = l1.next;}Deque<Integer> s2 = new ArrayDeque<>();while (l2 != null) {// 入棧s2.addLast(l2.val);l2 = l2.next;}ListNode answer = new ListNode(0);int carry = 0;while (!s1.isEmpty() || !s2.isEmpty()) {int sum = (s1.isEmpty() ? 0 : s1.removeLast())+(s2.isEmpty() ? 0 : s2.removeLast()) + carry;// 出棧ListNode newnode = new ListNode(sum % 10);newnode.next = answer.next;// 頭插answer.next = newnode;if (sum >= 10){carry = sum/10;}else{carry = 0;}}if (carry != 0) {// 若還有進位ListNode newnode = new ListNode(1);newnode.next = answer.next;answer.next = newnode;}return answer.next;} }

---

486. 預測贏家

關鍵點（動態規劃）：

先設計暴力解法，再用dp數組記錄重復運算進行優化

class Solution {public boolean PredictTheWinner(int[] nums) {int[][] dp=new int[nums.length][nums.length];for(int i=0;i<nums.length;++i){dp[i][i]=nums[i];//初始化dp表的對角線}for(int i=nums.length-2;i>=0;--i){for(int j=i+1;j<=nums.length-1;++j){dp[i][j]=Math.max(nums[i]-dp[i+1][j],nums[j]-dp[i][j-1]);//填表,計算所有子問題的凈勝分}}return dp[0][nums.length-1]>=0;//得出結果（最終凈勝分是否大于等于0）} } /*優化前的暴力解法，遞歸中含有重復子問題public boolean PredictTheWinner(int[] nums) {return Thinking(nums,0,nums.length-1)>=0;}public int Thinking(int[] nums,int start,int end) {if(start==end){return nums[start];}int choseleft=nums[start]-Thinking(nums,start+1,end);//選左的凈勝分int choseright=nums[end]-Thinking(nums,start,end-1);//選右的凈勝分return Math.max(choseleft,choseright);//返回一個高的凈勝分} */

---

503. 下一個更大元素 II

（暴力，單調棧為更優解）

//暴力 class Solution {public int[] nextGreaterElements(int[] nums) {int[] ans=new int[nums.length];//用nums初始化新數組ansfor(int n=0;n<nums.length;++n){int count=0;for(int i=(n+1)%nums.length;i<nums.length;i=(i+1)%nums.length){if(++count>=nums.length){//找不到ans[n]=-1;break;}if(nums[n]<nums[i]){//找到ans[n]=nums[i];break;}}}return ans;} }

---

567. 字符串的排列

關鍵點（滑動窗口）：

用長度為26的一維數組維護一個滑動窗口

窗口在l2滑動的過程，只要滿足窗口內各字母數量與l1內各字母數相符，即匹配成功

class Solution {public boolean checkInclusion(String s1, String s2) {if (s1.length() > s2.length())return false;//因為字符串都是a-z的字母，所以我們可以使用一個長度為26的int數組來存儲每個字母出現的個數int[] s1map = new int[26];int[] s2map = new int[26];for (int i = 0; i < s1.length(); i++) {//這里char類型加減使用Ascii碼，-'a'正好對應a-z在數組中的索引，值為該字母出現的次數s1map[s1.charAt(i) - 'a']++;s2map[s2.charAt(i) - 'a']++;}//滑動窗口//窗口大小為s1.length，索引從[0 —— s1.length-1]到[s2.length-s1.length —— s2.length-1]for (int i = 0; i < s2.length() - s1.length(); i++) {//如果匹配，直接返回if (isMatch(s1map, s2map)) {return true;}//如果不匹配，窗口向后移動一位//窗口加入下一個字母s2map[s2.charAt(i + s1.length()) - 'a']++;//窗口移除第一個字母s2map[s2.charAt(i) - 'a']--;}//最后比較i = s2.length-s1.length的情況return isMatch(s1map,s2map);}/*** 這里兩個數組的長度都為26* @param charArray1* @param charArray2* @return*/private static boolean isMatch(int[] charArray1,int[] charArray2 ){for (int i = 0; i < charArray1.length; i++) {//這里只要出現一個字母個數不一樣，就直接返回falseif (charArray1[i] != charArray2[i]) {return false;}}return true;} }

---

877. 石子游戲

（預測贏家的同類題，此處可用數學解，略）

class Solution {public boolean stoneGame(int[] piles) {return true;} } //dp法見 486.預測贏家

---

總結

???????認識了很多算法，像動態規劃、滑動窗口、Dfs、回溯、雙指針…認識了很多數據結構，像Java的Set、Deque、ArrayList、LinkedList…

???????我身邊有很多人，參加過很多競賽，獲得過很多榮譽。有人問過我說：他們各方面都比你優秀，努力程度也不比你差，為啥還要努力？我說，有意義的是過程，結果是大家都看得到的，只有過程是真正屬于自己的，即使未來不青睞我，我也要繼續，因為：

???????“強大者應持謙卑之心不可因力量而跋扈，
???????????????弱小者應持上進之心不可因不敵而麻木。”

繼續打題、繼續前進…
（未完待續）

總結

以上是生活随笔為你收集整理的力扣（简单+中等）50题整理总结的全部內容，希望文章能夠幫你解決所遇到的問題。

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