HuangMuCheng的博客

LeetCode-001- 两数之和思路：使用HashMap来记录已经遍历过数要点：HashMap的使用创建：HashMap<key,value> map=new HashMap();常用函数：get(key)(获得value)，containsKey(key)（是否含有键），pull(key,value)代码：class Solution { public int[] twoSum(int[] nums, int target) { HashMap&lt

思路：直接相加，直到两个链表都是空，判断最后是否还有进位代码：class Solution { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode head = new ListNode(l1.val + l2.val); ListNode cur = head; while(l1.next != null || l2.next != null){

思路：题目要求给出最长不重复的连续子串，只需要设置左、右指针，然后通过由指针进行遍历，如果右指针所指的字母在之前出现过，那么把左指针设置为max(左指针，上一个出现过的位置的下一个），使用HashMap来存出现过的字母。代码：class Solution { public int lengthOfLongestSubstring(String s) { HashMap<Character,Integer>map=new HashMap(); int l

LeetCode-004-寻找两个正序数组的中位数思路：题目要求时间复杂度为 O(log (m+n))，那么首先想到的就是二分查找代码：class Solution { public double findMedianSortedArrays(int[] nums1, int[] nums2) { int len1 = nums1.length, len2 = nums2.length; int len = len1 + len2; if (l

思路：动态规划定义状态：dp[i][j]表示字符串s[i…j]是否为回文状态转移方程 dp[i][j]=dp[i+1][j-1]&&s[i]==s[j]三种情况 //头尾不等直接false if(arr[i]!=arr[j])dp[i][j]=false; else{ //中间长度小于等于1，直接true i

LeetCode-010-正则表达式匹配参考：「手画图解」动态规划，需要仔细的分情况讨论代码：public boolean isMatch(String s, String p) { char[] cs = s.toCharArray(); char[] cp = p.toCharArray(); // dp[i][j]:表示s的前i个字符，p的前j个字符是否能够匹配 boolean[][] dp = new boolean[cs.l

思路：双指针法，从两边向中间靠，易知，容量由短板决定，考虑两种情况：短边缩进：短边可能变长, 虽然底宽减一了，但是可能容量增加长边缩进：短边可能更短，底宽减一了，所以容量一定减少综上，选择短边缩进策略。代码：class Solution { public int maxArea(int[] height) { int res=0; int i=0,j=height.length-1; while(i!=j){ i

思路：固定一个，然后用双指针进行遍历即可，记得去重代码：class Solution { public List<List<Integer>> threeSum(int[] nums) { List<List<Integer>> ans=new ArrayList<>(); if(nums==null||nums.length<3)return ans; Arrays.sort(nu

思路：很容易想到使用for循环直接暴力解决，但是要知道，所给case长度为2，因此只有2层for，当长度为10时该怎么办，因此，由于长度不确定无法编写for代码，所以使用回溯法来解决，具体可以参考代码注释代码：class Solution { String[] letter_map = {"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};//按键 List<String> res = new ArrayList&

思路：为了保证只存在一个元素的链表，必须设置一个虚拟头节点然后双指针均指向该头节点，这里记为快慢指针，quick和slow首先quick先走n+1步（倒数第n），然后两个指针同时移动当quick到达null时，说明已到达尾部，共走了L+1步（L为链表长度）此时slow走了(L+1)-(n+1)=L-n步，指向待删节点的前一个，目的达成！最后返回虚拟头节点的next代码：/** * Definition for singly-linked list. * public class ListN

思路：1.使用栈进行括号匹配如果是左括号，入栈push()；如果是右括号，和栈顶进行匹配peek()；匹配成功则出栈pop()，匹配失败则返回false;最后检查栈是否为空，非空表示存在没匹配的括号代码：class Solution { public boolean isValid(String s) { Stack<Character> stack=new Stack<>(); for(char c:s.toCharArray

思路：代码：class Solution {public: ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { if(l1==NULL)return l2; if(l2==NULL)return l1; ListNode *l3=new ListNode(); ListNode *l4 = l3; l3=l4; while(l1&&am

思路：这里通过画图，可以分析出的结论：当前左右括号都有大于 0个可以使用的时候，才产生分支；产生左分支的时候，只看当前是否还有左括号可以使用；产生右分支的时候，还受到左分支的限制，右边剩余可以使用的括号数量一定得在严格大于左边剩余的数量的时候，才可以产生分支；在左边和右边剩余的括号数都等于 0 的时候结算。代码：class Solution { List<String> ans=new ArrayList<>(); public List<S

思路：归并排序即可，设置三个函数，所给函数，划分块的函数（调用自己然后划分成两两一组），以及一个链表合并函数代码：/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val,

思路：结合样例来分析，假设样例为 [1,3,5,4,1]：从后往前找，找到第一个下降的位置，记为 k。注意k 以后的位置是降序的。 在样例中就是找到 3从 k 往后找，找到最小的比 k 要大的数。 找到 4将两者交换。注意此时 k 以后的位置仍然是降序的。直接将 k 以后的部分翻转（变为升序）。注意：如果在步骤 1 中找到头部还没找到，说明该序列已经是字典序最大的排列。按照题意，我们要将数组重新排列成最小的排列。代码：class Solution { publ

思路：一般括号匹配的问题都会使用栈来解决，将左括号入栈，右括号匹配则出栈，然后标记为1，表示是有效匹配，只需找到连续为1的最长长度即可代码：class Solution { public int longestValidParentheses(String s) { int []mark=new int[s.length()];//用于标记是否为有效括号，初始化为0，有效为1 Stack<Integer> st=new Stack<>();

思路：考虑二分查找，由于题目已经说明是无重复数字的，举个例子：1 2 3 4 5 6 7 可以大致分为两类，第一类 2 3 4 5 6 7 1 这种，也就是 nums[start] <= nums[mid]。此例子中就是 2 <= 5。这种情况下，前半部分有序。因此如果 nums[start] <=target<nums[mid]，则在前半部分找，否则去后半部分找。第二类 6 7 1 2 3 4 5 这种，也就是 nums[start] > nums[mid]。此

LeetCode-034-在排序数组中查找元素的第一个和最后一个位置参考：https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/solution/yi-wen-dai-ni-gao-ding-er-fen-cha-zhao-j-ymwl/思路：分别使用二分法找出上下界即可代码class Solution { public int[] searchRange(int[]

思路：使用回溯法代码：class Solution { public List<List<Integer>> combinationSum(int[] candidates, int target) { List<List<Integer>>ans=new ArrayList<List<Integer>>(); List<Integer>combine=new ArrayL

思路：这里使用单调递减栈的做法，写起来简单些代码：class Solution { public int trap(int[] height) { Stack<Integer> st=new Stack<>();//单调栈，存储单调递减的墙 int current=0;//右边的墙 int sum=0;//总雨量 while(current<height.length){

思路：一般遇到需要列举所有排列组合的，考虑回溯法这里给个回溯法的一般模板result = []def backtrack(路径, 选择列表): if 满足结束条件: result.add(路径) return for 选择 in 选择列表: 做选择 backtrack(路径, 选择列表) 撤销选择代码：class Solution { public List<List

思路：转置+中线对称代码：class Solution { public void rotate(int[][] matrix) { int n=matrix.length; //转置 for(int i=0;i<n;i++){ for(int j=i;j<n;j++){ int tmp=matrix[i][j]; matrix[i][j]=m

思路：异位词就是指相同字母通过不同顺序组成的词，那么只需通过排序就可以判断是否异位。因此用一个hashmap来存储已经存在的异位词组代码：class Solution { public List<List<String>> groupAnagrams(String[] strs) { Map<String,List<String>> map=new HashMap<>(); for(int i=0;

思路：贪心法代码：class Solution { public int maxSubArray(int[] nums) { int max,cur;//分别表示最大和，和之前和 max=cur=nums[0]; for(int i=1;i<nums.length;i++){ cur=Math.max(cur+nums[i],nums[i]);//取当前和和当前值的最大 max=Math.max(

思路：以最大下标作为循环终止条件即可，不断更新可达的最大下标代码：class Solution { public boolean canJump(int[] nums) { int max=0;//最大下标 //循环终止条件为最大下标 for(int i=0;i<=max;i++){ int tmp=nums[i]+i;//当前可达下标 max=Math.max(max,tmp);//获得

思路：首先按区间左边进行排序，然后比较当前右边和下一个的左边，如果右<左，那么直接加上新区间，否则，比较两者右边，取最大值代码：class Solution { public int[][] merge(int[][] intervals) { if (intervals.length == 0) { return new int[0][2]; } Arrays.sort(intervals,new Compar

思路：直接使用排列组合进行计算即可，需要m-1次向下和n-1次向右，共m+n-2次，所以只需在m+n-2次选择m-1次向右即可,即C(m-1，m+n-2)代码：class Solution { public int uniquePaths(int m, int n) { long ans=1; for(int x=n,y=1;y<m;x++,y++){ ans*=x/y; } return (in

思路：只能向右向下，因此可以使用动态规划代码：class Solution { public int minPathSum(int[][] grid) { if (grid == null || grid.length == 0 || grid[0].length == 0) { return 0; } int m=grid.length; int n=grid[0].length; i

思路：第n个台阶只能从第n-1或者n-2个上来。到第n-1个台阶的走法 + 第n-2个台阶的走法 = 到第n个台阶的走法，已经知道了第1个和第2个台阶的走法，一路加上去。代码：class Solution { public int climbStairs(int n) { if(n<=2)return n; int n1=1,n2=2,tmp; for(int i=3;i<=n;i++){ tmp=n1;

思路：动态规划1、状态定义：dp[i][j]表示word1的前i个字母转换成word2的前j个字母所使用的最少操作。2、状态转移：i指向word1，j指向word2首先了解三种操作的状态转移:增：i+1和j相同，那么dp[i][j]=dp[i][j-1];删：i-1和j相同，那么dp[i][j]=dp[i-1][j];改：i和j相同，那么dp[i][j] = dp[i-1][j-1];若当前字母相同，则dp[i][j] = dp[i-1][j-1];否则取增删替三个

思路：用双指针分别指向头尾，0放头，2放尾，1就是剩下的，自然会在中间代码：class Solution { public void sortColors(int[] nums) { int p0=0,p2=nums.length-1; for(int i=0;i<=p2;i++){ while(i<=p2&&nums[i]==2){ swap(nums,i,p2);

思路：使用滑动窗口解决该问题这里简单地介绍一下什么叫做滑动窗口理论就是用一个可以滑动的窗口，该窗口有2个指针，来表示窗口范围，然后先用右指针来满足条件，然后用左指针来缩小答案范围。代码：class Solution { public String minWindow(String s, String t) { String res=""; int len1=s.length(),len2=t.length(); //conut表示当前覆

思路：使用迭代法，遍历数组逐个加入元素，如1,2,3第一轮循环：size=1，[ ]：[ ] [1]第二轮循环：size=2，[ ] [1]：[ ] [1] [2] [1,2]第三轮循环：size=4，[] [1] [2] [1,2]：[ ] [1] [2] [1,2] [3] [1,3] [2,3] [1,2,3]代码：class Solution { public List<List<Integer>> subsets(int[] nums) {.

思路：回溯法，向四个方向进行遍历，注意判断边界条件代码：class Solution { boolean [][]v; char [][]board; int[][] dir = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}}; char[] charArray; int rows; int cols; int len; public boolean exist(char[][] board, Str

思路：详细参考动画演示 单调栈 84.柱状图中最大的矩形 - 柱状图中最大的矩形 - 力扣（LeetCode） (leetcode-cn.com)使用单调栈解决：当前高度大于于栈顶高度，入栈；当前高度小于栈顶高度，出栈，计算面积 给数组首尾分别加上高度为0的柱，方便边界计算，且不用判断栈空 面积=栈顶高度*(当前元素的索引-栈顶前一个元素的索引-1)代码：class Solution { public int largestRectangleArea(int[] heights) .

思路：这道题和84题是同类问题，只是需要我们自己更新每一行的高度数组，并计算到达当前行的最大面积代码：class Solution { public int maximalRectangle(char[][] matrix) { int rows=matrix.length; if(rows==0)return 0; int cols=matrix[0].length; int []heights=new int[cols];

思路：参考迭代解法，时间复杂度 O(n)，空间复杂度 O(n) - 二叉树的后序遍历 - 力扣（LeetCode） (leetcode-cn.com)二叉树有三种常用的遍历方式，分别为先（根 -> 左 -> 右），中（左 ->根->右），后（左 ->右-> 根）这里顺便总结一下二叉树的三种遍历的递归和非递归写法1.递归：1.1先序遍历void dfs(TreeNode root) { visit(root); dfs(root.l...

思路：动态规划假设 n 个节点存在二叉排序树的个数是 G (n)，令 f(i) 为以 i 为根的二叉搜索树的个数，则G(n) = f(1) + f(2) + f(3) + f(4) + ... + f(n)当 i 为根节点时，其左子树节点个数为 i-1 个，右子树节点为 n-i，则f(i) = G(i-1)*G(n-i)综合两个公式可以得到 卡特兰数 公式G(n) = G(0)*G(n-1)+G(1)*(n-2)+...+G(n-1)*G(0)代码：class Solution

思路：1.递归法代码：class Solution { public boolean isValidBST(TreeNode root) { return helper(root,Long.MIN_VALUE,Long.MAX_VALUE); } boolean helper(TreeNode root,long min,long max){ if(root==null) return true; if(root.v

LeetCode-101-对称二叉树思路一棵树，判断左右节点是否满足对称，以及左右节点的左左右右，左右右左代码class Solution { public boolean isSymmetric(TreeNode root) { if(root==null)return true; return helper(root.left,root.right); } public boolean helper(TreeNode L,TreeNode