02 2022 档案
摘要：class Solution { public List<String> binaryTreePaths(TreeNode root) { List<String> result = new ArrayList(); if(root==null) return result; List<Intege
阅读全文
摘要：class Solution { public boolean isBalanced(TreeNode root) { if(root == null) return true; return getHeight(root)== -1 ? false : true; } private int ge
阅读全文
摘要：class Solution { public boolean isSymmetric(TreeNode root) { if(root == null) return true; return judge(root.left, root.right); } private boolean judg
阅读全文
摘要：翻转这个操作也是需要遍历，遍历无非dfs或者bfs，dfs无非前中后序遍历。这里采用前序遍历或者后序遍历，否则有的会被翻转两次。 最重要的是，翻转的时候传入的参数是root，而非要被翻转的两个节点。 class Solution { public TreeNode invertTree(TreeNo
阅读全文
摘要：public int lengthOfLIS(int[] nums) { int len = nums.length, ans = 1; int[] dp = new int[len]; dp[0] = 1; for(int i = 1; i < len; i++) { dp[i] = 1; for
阅读全文
摘要：public int maxProduct(int[] nums) { int len = nums.length, ans = nums[0]; int[] dpMax = new int[len], dpMin = new int[len]; dpMax[0] = nums[0]; dpMin[
阅读全文
摘要：class Solution { public int findLength(int[] nums1, int[] nums2) { int ans = 0, len1 = nums1.length, len2 = nums2.length; for(int i = 0; i < len1; i++
阅读全文
摘要：public int subarraySum(int[] nums, int k) { int len = nums.length, ans = 0, pre = 0; Map<Integer, Integer> map = new HashMap<>(); map.put(0,1); for(in
阅读全文
摘要：public List<List<Integer>> levelOrder(TreeNode root) { List<List<Integer>> res = new ArrayList(); if(root == null) return res; Deque<TreeNode> q = new
阅读全文
摘要：public List<Integer> largestValues(TreeNode root) { List<Integer> list = new ArrayList(); if(root == null) return list; Deque<TreeNode> q = new Linked
阅读全文
摘要：public List<Integer> rightSideView(TreeNode root) { List<Integer> list = new ArrayList(); if(root == null) return list; Deque<TreeNode> q = new Linked
阅读全文
摘要：public List<List<Integer>> levelOrder(Node root) { List<List<Integer>> res = new ArrayList(); if(root == null) return res; Deque<Node> q = new LinkedL
阅读全文
摘要：public List<List<Integer>> levelOrder(TreeNode root) { List<List<Integer>> res = new ArrayList(); if(root == null) return res; Deque<TreeNode> q = new
阅读全文
摘要：public Node connect(Node root) { Deque<Node> q = new LinkedList(); if(root == null) return root; q.offer(root); while(!q.isEmpty()) { int size = q.siz
阅读全文
摘要：public int maxDepth(TreeNode root) { int ans = 0; if(root == null) return 0; Deque<TreeNode> q = new LinkedList(); q.offer(root); while(!q.isEmpty())
阅读全文
摘要：public Node connect(Node root) { if(root == null) return root; Deque<Node> q = new LinkedList(); q.offer(root); while(!q.isEmpty()) { int size = q.siz
阅读全文
摘要：public int minDepth(TreeNode root) { int depth = 0; if(root == null) return depth; Deque<TreeNode> q = new LinkedList(); q.offer(root); while(!q.isEmp
阅读全文
摘要：public int mySqrt(int x) { int l = 0, r = x, ans = -1; while (l <= r) { int mid = l + (r-l)/2; if((long) mid * mid <= x) { ans = mid; l = mid +1; } el
阅读全文
摘要：public int search(int[] nums, int target) { // 第一段满足第二段不满足 x>=nums[0]，边界点就是满足这个性质的最后一个数字 int l = 0, r = nums.length-1; while (l < r) { int mid = l + r
阅读全文
摘要：public int[] searchRange(int[] nums, int target) { int[] ans = {-1,-1}; if(nums.length == 0) return ans; else if(nums.length == 1) { if(nums[0] == tar
阅读全文
摘要：public int countNodes(TreeNode root) { if(root == null) return 0; int left = countNodes(root.left); int right = countNodes(root.right); return left +
阅读全文
摘要：https://leetcode-cn.com/problems/single-element-in-a-sorted-array/ 解法1：二分法 题目中很明确的说了，需要O(logn)的算法，这简直就是二分的代名词。 二分的本质是需要去找一个性质，一半满足另一半不满足。 这个性质就是，相等的两个
阅读全文
摘要：层次遍历本质上是BFS，维护一个队列，把根节点加入队列，每一个节点出队的时候把它的子节点加入队列直到队列中没有节点。 1.leetcode102二叉树的层次遍历 public List<List<Integer>> levelOrder(TreeNode root) { List<List<Inte
阅读全文
摘要：之前介绍了二叉树三种遍历方式的recursion版本，现在使用iteration版本。 模板中最重要的就是：1.只有不是null的节点才能入栈2.如果null入栈了，说明它的栈下一个节点还没有处理过（加入结果集） https://programmercarl.com/%E4%BA%8C%E5%8F%
阅读全文
摘要：这是根据代码随想录的刷题顺序进行的刷题：https://programmercarl.com/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E9%80%92%E5%BD%92%E9%81%8D%E5%8E%86.html 递归版 递归中最重要的事儿： 参数的意义与类型 结
阅读全文
摘要：题目链接：https://leetcode-cn.com/problems/remove-element/ 方法1——首位指针 首指针在头，尾指针在末尾，如果首指针指的是val，则交换。 public int removeElement(int[] nums, int val) { int l =
阅读全文
摘要：public List<List<Integer>> combinationSum(int[] candidates, int target) { List<List<Integer>> ans = new ArrayList<>(); List<Integer> combine = new Arr
阅读全文
摘要：class Solution { public int coinChange(int[] coins, int amount) { int[] dp = new int[amount+1]; for(int i = 0; i < dp.length; i++) dp[i] = amount+1; /
阅读全文
摘要：public String minWindow(String s, String t) { // 穷尽每个字符，看是否含有这个子字符串 // 枚举所有子串，并放入 // 从字串出发，用双指针枚举-> Map<Character, Integer> smap = new HashMap<>(); Ma
阅读全文
摘要：public int[] intersection(int[] nums1, int[] nums2) { Set<Integer> set1 = new HashSet<>(), set2 = new HashSet<>(); for(int a: nums1) set1.add(a); List
阅读全文
摘要：public int[] dailyTemperatures(int[] temperatures) { int len = temperatures.length; LinkedList<Integer>[] table = new LinkedList[101]; for(int i = 30;
阅读全文
摘要：class Solution { public boolean isAnagram(String s, String t) { if (s.length() != t.length()) { return false; } int[] table = new int[26]; for (int i
阅读全文
摘要：public List<Integer> inorderTraversal(TreeNode root) { List<Integer> res = new ArrayList<Integer>(); inorder(root, res); return res; } public void ino
阅读全文
摘要：Map<Node, Node> map = new HashMap<>(); public Node copyRandomList(Node head) { if(head == null) return null; if(!map.containsKey(head)) { Node headNew
阅读全文
摘要：class Solution { public List<String> topKFrequent(String[] words, int k) { Map<String, Integer> map = new HashMap<>(); for(String word: words) map.put
阅读全文
摘要：private int capacity = 16; private int[] container; private boolean[] table; public MyHashMap() { this.container = new int[capacity]; this.table = new
阅读全文
摘要：public int[] dailyTemperatures(int[] temperatures) { int len = temperatures.length; LinkedList<Integer>[] table = new LinkedList[101]; for(int i = 30;
阅读全文
摘要：public int lengthOfLongestSubstring(String s) { // 开一个hashmap来维护情况，进行一个N*N的搜索 Map<Character, Boolean> map; int len = s.length(); if(len == 0) return 0
阅读全文
摘要：public List<List<Integer>> threeSum(int[] nums) { List<List<Integer>> ans = new ArrayList<>(); List<Integer> combine = new ArrayList<>(); dfs(nums, an
阅读全文
摘要：public void rotate(int[][] matrix) { int n = matrix.length, m= n-1; for(int i = 0; i < n/2; i++) { for(int j = 0; j < n/2; j++) { int tmp = matrix[i][
阅读全文
摘要：public int maxSubArray(int[] nums) { int len = nums.length,ans = nums[0]; int[] dp = new int[len]; dp[0] = nums[0]; for(int i = 1; i < len; i++) { dp[
阅读全文
摘要：public int maxProfit(int[] prices) { if(prices.length < 2) return 0; int ans = 0, beforeMin = prices[0]; for(int i =1; i < prices.length; i++) { int p
阅读全文
摘要：public int findDuplicate(int[] nums) { Arrays.sort(nums); System.out.println(Arrays.toString(nums)); int l = 0, r = nums.length - 1; while (l < r) { i
阅读全文
摘要：public int findInMountainArray(int target, MountainArray mountainArr) { int len = mountainArr.length(); int l = 0, r = len; while(l < r) { int mid = l
阅读全文
摘要：``java public List<List> combinationSum(int[] candidates, int target) { List<List> ans = new ArrayList<>(); List combine = new ArrayList<>(); dfs(cand
阅读全文
摘要：`private int m,n; private int[] dx = {-1, 0, 1, 0}; private int[] dy = {0, -1, 0, 1}; public int minPathSum(int[][] grid) { m = grid.length; n = grid[
阅读全文
