weixin_47188125的博客

如果考虑nums[i] nums[i][j] = nums[ i-1 ] [ j-nums[i] ]（2）确定递归公式 如果不考虑nums[i] nums[i][j] = nums[i-1][j]；（1）确定dp函数 dp[i][j]表示第i个数能否和前面的数（或自己单独）凑成j。（3）dp数组如何初始化 初始化目标对准第一行和第一列。（4）确定遍历顺序 先便利数组的数字，再遍历纵坐标。看到这个我们第一步要想到是，这是一个01背包问题。本质上就是求是否可以让数相加等于总和的一半。...

public ListNode detectCycle(ListNode head) { ListNode fast=head; ListNode slow=head; while(fast!=null&&fast.next!=null){ fast=fast.next.next; slow=slow.next; if(fast==slow){ ...

首先我们要知道二叉搜索树的性质：二叉搜索树是一个有序树：若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉搜索树这就决定了，二叉搜索树，递归遍历和迭代遍历和普通二叉树都不一样。递归class Solution { // 递归，普通二叉树 public TreeNode searchBST(TreeNode root, int val...

class Solution { public boolean isAnagram(String s, String t) { int []record=new int[26]; for(char c:s.toCharArray()){ record[c-'a']+=1; } for(char c:t.toCharArray()){ record[c-'a']-=1; ...

public class Solution { public ListNode detectCycle(ListNode head) { ListNode fast=head; ListNode slow=head; while(fast!=null&&fast.next!=null){ fast=fast.next.next; slow=slow.next; ...

这个矩阵有可能是长方形的，但是和正方形的螺旋矩阵差不多，只需要注意两点：即跳出循环的条件以及For循环的条件（1）他是矩阵，先创建二维数组new int[m][n];（2）数字是从左到右，从上到下，从右到左，从下到上的顺序（顺时针）（3）从左到右的时候，二维数组的第一个参数不变，第二个参数变（4）从上到下的时候，二维数组的第一个参数变， 第二个参数不变（5）从右到左的时候，二维数组的第一个参数不变，第二个参数变（6）从下到上的时候，二维数组的第一个参数变， 第二个参数不变（.

解题思路：（1）他是矩阵，先创建二维数组new int[n][n];（2）数字是从左到右，从上到下，从右到左，从下到上的顺序（顺时针）（3）从左到右的时候，二维数组的第一个n不变，第二个n变（4）从上到下的时候，二维数组的第一个n变， 第二个n不变（5）从右到左的时候，二维数组的第一个n不变，第二个n变（6）从下到上的时候，二维数组的第一个n变， 第二个n不变class Solution { public int[][] generateMatrix(int n) ..

方法一：蛮力法：通过两层for循环直接比较时间复杂度：$O(n^2)$ 空间复杂度：$O(1)$class Solution { public int minSubArrayLen(int target, int[] nums) { int result = Integer.MAX_VALUE; int sum=0; int subLength=0; int length=nums.length; for

方法一：蛮力法，把数组的所有树平方，再排序class Solution { public int[] sortedSquares(int[] nums) { int length=nums.length; for(int i=0;i<length;i++){ nums[i]=nums[i]*nums[i]; } Arrays.sort(nums); return nums; ..

class Solution { public List<List<Integer>> generate(int numRows) { List<List<Integer>> rest=new ArrayList<List<Integer>>(); for(int i=0;i<numRows;i++){ List<Integer> ...

思路（1）二维数组的行列是我们需要第一确认的数（2）通过rPos和cPos两个下标来确定新的二维数组class Solution { public int[][] matrixReshape(int[][] mat, int r, int c) { int rowLength=mat.length; int colLength=mat[0].length; if(rowLength*colLength!=r*c){ ...

解题思路：（1）首先需要给两个数组排序，方便从小到大进行比较（2）因为 元素的出现次数不一致的话需要取最小值，所以不可以单纯的使用for循环来判断数组的下边，因为for循环的下标不容易更改，需要用index1，index2分别来记录两个数组的下表（3）最重要的一点！！！！！！copyOfRange函数的使用！！！因为我们一开始固定好了数组的长度，如果我们的并集的结果 没有达到数组的长度，其他的默认值为0，所以我们需要把这些默认值去除掉Java中copyOfRange()函数深度理解..

这道题要理解有一定的困难，首先看到这样的题目肯定想到的就是遍历其次，需要有一个值来记录倾斜度,即 left+right再者，需要一个函数来帮忙辅助计算倾斜度，即findSum()class Solution { int findSum(TreeNode root){ if(root==null) return 0; return root.val + findSum(root.left) + findSum(root.right); ...

class Solution { public boolean findTarget(TreeNode root, int k) { if(root==null) return false; boolean result=false; List<Integer> list=new ArrayList<>(); pre(root,list); for(int i=0;i<list.siz...

class Solution { public boolean leafSimilar(TreeNode root1, TreeNode root2) { List<Integer> list1=new ArrayList<>(); List<Integer> list2=new ArrayList<>(); helper(root1,list1); helper(roo...

思路（1）用queue，先进先出的特性，实现广度优先搜索（2）利用lenght来记录每一行的节点有多少个class Solution { public List<Double> averageOfLevels(TreeNode root) { List<Double> result=new ArrayList<>(); Queue<TreeNode> q=new LinkedList<&...

class Solution { public int islandPerimeter(int[][] grid) { int islands = 0, neighbours = 0; for (int i = 0; i < grid.length; i++) { for (int j = 0; j < grid[i].length; j++) { if (grid[i][j] == ...

有两点需要注意（1）Queue<Node> 而不是treeNode！！！！！！（2）是node.children 不是node.leftclass Solution { public int maxDepth(Node root) { if(root == null) { return 0; } Queue<Node> queue = new LinkedList<>...

先通过for循环递归完，递归以后再加入到listclass Solution { List<Integer> list = new ArrayList<>(); public List<Integer> postorder(Node root) { if (root == null) return list; for(Node node: root.children) ...

class Solution { TreeNode curr; public TreeNode increasingBST(TreeNode root) { TreeNode first = new TreeNode(-1); //用first 来记录curr的初始位置 curr = first; dfs(root); return first.right; ...

递归递归递归！！！！！！！！！！！！！！！！！！！！class Solution { public TreeNode mergeTrees(TreeNode t1, TreeNode t2) { if (t1 == null) return t2; if (t2 == null) return t1; TreeNode node = new TreeNode(t1.val + t2.val); node.left = ...

第一次完完全全靠自己写出来的啊，虽然提交代码效率很差，但也值得纪念一下哈哈思路：先序遍历拿到所有的二叉树的值存放在list，然后再遍历list得到满足题目得数class Solution { public int rangeSumBST(TreeNode root, int low, int high) { List<Integer> list=new ArrayList<>(); List<Integer> resul.

public List<List<Integer>> pathSum(TreeNode root, int targetSum) { List<List<Integer>> res =new ArrayList<List<Integer>>(); pathSum(root,targetSum,new ArrayList<Integer>(),res); return r...

递归基本思想是从sum中减去当前节点的值，直到它到达叶子节点并且减法等于0，然后我们就知道我们命中了。否则最后的减法不能为 0。 public boolean hasPathSum(TreeNode root, int sum) { if(root == null) return false; if(root.left == null && root.right == null && sum - root.val =...

public TreeNode invertTree(TreeNode root) { if(root==null) return root; Stack<TreeNode> stack =new Stack(); stack.push(root); while(!stack.isEmpty()){ TreeNode node = stack.pop(); TreeNod...

最大深度 public int maxDepth(TreeNode root) { if(root==null) return 0; return 1+Math.max(maxDepth(root.left),maxDepth(root.right)); } }最小深度

对称树思路：递归思想（1）首先，题目中函数只有一个参数，我们无法做出题目，需要找一个助手（2）一直都是root1的左子树与root2的右子树，root1的右子树与root2的左子树进行比较class Solution { public boolean isSymmetric(TreeNode root) { if(root==null) return true; return isSymmetricHelper(root.left,root.

class Solution { public ListNode reverseList(ListNode head) { ListNode pre=null; ListNode cur=head; while(cur!=null){ ListNode temp=cur.next; cur.next=pre; pre=cur; cur=temp; ...

class Solution { public ListNode middleNode(ListNode head) { ListNode slow=head,fast=head; while(fast!=null&&fast.next!=null){ slow=slow.next; fast=fast.next.next; } return slow; ...

递归：不好之处，如果链表过长，会导致栈内存溢出

示例 ：输入： root = [3,9,20,null,null,15,7]输出： [[3],[9,20],[15,7]]拿到这道题目时我的思路即（1）需要两个集合，一个集合放一层的数据，另一个集合放所有的集合（2）需要一层一层的便利二叉树，应该需要用到for循环，每一层for循环里面需要放一个集合，来存储对应的数据我的问题一时半会不知道用什么数据结构来存储数据（应该是用Queue），暴露出自己对数据结构的不熟悉（1）此题使用Queue的原因是Queue是先进先.

在做leetCode的时候，遇到算法题目二叉树的三种遍历，要求不能使用递归的方式，要使用迭代，弄了好久才知道什么时候才该出栈，什么时候才该入栈，写下这篇博客来记录一下自己的学习先序遍历直接出栈，然后判断有无右孩子中序遍历直接出栈，然后判断有无右孩子后序遍历出栈条件当确保当前节点无右孩子或者上一个出栈的节点就是该节点的右孩子我是算法小白，想学习JAVA版本的算法我推荐看这个，然后根据他的一章节一章节去算对应的算法挺好的腾讯课堂...