qq_19875729的博客

Linkedlist

https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number/submissions/这道题目涉及到了字符String的相关操作，很久没回忆了，有点生疏，不过最后还是可以自己做出来了。需要注意以下几点：String的长度需要变化的时候，记得使用StringBuilder类，而不是Linkedlist<String>字符的'1','2'等数字转化为int的时候并不与int的1，2对应，需要减去'0'来得到相对的

第一次感觉我的思路比参考答案要清晰一点诶。清晰在递归函数的终止条件那儿，这样就不需要传入这么多的参数了。//按照回溯算法处理本题的话，我现在只能想到利用递归函数来处理// 函数参数：（k, n, 开始遍历位置startIndex）// 返回：result// 终止条件：if(path.size == k) return;// 处理逻辑：// for(int i = startIndex; i < n - (k - path.size()) + 1; i++){//

LinkedList地址变动会使得与之相关的变量都跟着出现变动。

下面的注释是我写题的第一版草稿，还有错误的地方，比如说return的值，修改比较多的是middle生成的地方，还有什么时候初始化roothttps://leetcode-cn.com/problems/trim-a-binary-search-tree/submissions/// 怪不得我说和构造平衡二叉树的题目有点像，就直接从中间分割就行了// int middle = right - left / 2 + left; 偶数就是偏左，奇数因为略去小数位，就是中间// 递归函数：//

leetcode-中等题-669. 修剪二叉搜索树这个比405简单，两次AC //与405的删除节点是差不多意思，只不多删除节点是某一个点，而这里是一段 // 传入参数：root low high// 返回：root// 终止条件：遇到空节点，则返回(不是处理节点的操作)// 处理逻辑：（当遍历到cur.val不在[low, high]时）// 1.左右都空，直接cur == null（后期可查看是否可以省略）(答：不可，因为要引用cur.val)// 2.其他，

https://leetcode-cn.com/problems/delete-node-in-a-bst/https://leetcode-cn.com/problems/delete-node-in-a-bst/这里需要考虑的条件挺多的，但实际码起来好像也不算太难，最后注意cur指针的变化会使得后面return的时候会丢失值，所以使用root来return// 首先是要寻找key所在位置，BFT可以使用中序遍历// 考虑递归函数：// 传入参数：root key// 返回：root

https://leetcode-cn.com/problems/insert-into-a-binary-search-tree/因为是BST，所以我第一个想到的就是 按照大小来往下走。用的是迭代的方法，至于遍历，还没想好，不过这个题自己写出来了。记得使用虚拟头节点保留根节点。class Solution { public TreeNode insertIntoBST(TreeNode root, int val) { TreeNode dummyNode = root;

https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/这两道题目差别在于一个二叉树有序，一个无序。那么，无序的就所有的分支都回溯完，无序的则可以使用中序遍历，往特定的方向去回溯，减少递归次数。236.class Solution { public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {

https://leetcode-cn.com/problems/find-mode-in-binary-search-tree/本来思路是挺简单的，就是把所有的值加入到哈希表里面，记数，选取最前面的众数，但是这样子做需要的空间比较大，答案偏偏选难的方法，我觉得这个方法和那种遍历数组时使用单指针保留最大值是一个道理。这里的众数，其实就是最大值的一个体现。所以，涉及到最大或者最小值那种问题的时候，一般都可以用一个数来代替一个数组，但是需要实时更新这个数。第一次的垃圾代码，if里面重复了。。。很无语，虽然不

优化前代码：使用了数组class Solution { public int getMinimumDifference(TreeNode root) { List<TreeNode> arr = new LinkedList<TreeNode>(); traverse(root, arr); int res = arr.get(1).val - arr.get(0).val; for(int i = 1; i

https://leetcode-cn.com/problems/validate-binary-search-tree/// 同样地，利用BST的性质，将树转变为有序数组// 先遍历左子树，中，右子树// 依次入列// 若发现相邻树不是有序递增，就返回错误class Solution { public boolean isValidBST(TreeNode root) { List<TreeNode> arr = new LinkedList<Tree

https://leetcode-cn.com/problems/search-in-a-binary-search-tree/就是一个简单的左中右遍历。// 二叉搜索树最大特点就是有序，左中右有序，即中序遍历是右序的，节点的数值从左到右有序// 此外，它还有性质：// 1. 左节点比根节点小// 2. 右节点比根节点大// 所以，利用这个性质，就在遍历的时候少走弯路，即（逻辑）// 1. root.val < val 时, 往右遍历// 2. root.val >

https://leetcode-cn.com/problems/merge-two-binary-trees/本质还是递归的题目，越做越熟了。// 中左右的方式遍历，即前序遍历// 传递值：两个根节点// 终止条件：// 两个为空，返回null// 内部逻辑：// 如果一个为空，另一个不是空，则返回不是空的值// 如果两个都有值，那就两个值相加// root.left = mergeTrees(root1.left, root2.left);//

https://leetcode-cn.com/problems/maximum-binary-tree/这道题比构造二叉树简单了一半，因为只需要两个指针来指定新数组就行了。这次还优化了一下代码，把遍历变少了，具体看第二版。// 区间定义：左闭右开// 传入参数：（nums， 左指针， 右指针）// 返回 TreeNode// 终止条件：// 1. 左指针等于右指针，即没有数，返回null// 2. 右指针 - 左指针 == 1， 只有一个参数，返回叶子节点// 内部逻辑：

https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/这个题目因为区间的问题把我给整麻了。根据解析，需要假定区间是左闭右开即[x, y)所以，对于右区间里面y这个值不好处理，需要考虑指针越界的问

113. 路径总和 II/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, TreeNod

https://leetcode-cn.com/problems/path-sum/submissions/// 遍历顺序：中左右// 每遍历一个，记录一个作为路径，并把总和算出来// 需要递归和回溯、// 先尝试写出所有路径的递归、回溯算法// 函数参数：(结点值， 单条路径， 目标和) 返回（void）class Solution { public boolean hasPathSum(TreeNode root, int targetSum) { if(r

https://leetcode-cn.com/problems/find-bottom-left-tree-value/这道题目使用层序遍历是比较简单的了。递归还得再研究一下。// 用层序遍历的方法，每一层先入列// 一个个出列，每出列一次，就入列子节点，并记录最新的左子节点（如果非空）class Solution { public int findBottomLeftValue(TreeNode root) { if(root.left == null &&

https://leetcode-cn.com/problems/sum-of-left-leaves/submissions/题解如注释。掌握一门技术才能永远被人看得起。部门领导真tm恶心，说调你就调你，见我是新人好欺负。一群傀儡，难怪你发展不起来，搞的创新全是一堆虚的东西，亏空公司，这样的企业早倒闭早好md。// 函数参数：（头结点） 返回一个整形的数值，表示该节点的左叶子之和// 终止条件：如果遍历到空节点，就结束，返回0// 处理内部逻辑：如何统计左叶子// 1.统计左子树的左叶

https://leetcode-cn.com/problems/subtree-of-another-tree/submissions/这个题目和100. 相同的树 的相似度比较像，既然子树的比较方法可以使用相同的树的递归，那么这道题目我称之为'递中递'。尽管知道了方法，也知道可能其中要使用到或运算，但最后还是写不出来，参考了大神的代码：思路：判断是否是相同的树这个用在单次递归里面的两个非空的头结点然后以此递归到左，右递归的结果做或运算，因为只要有一个成立，就是另一个子树。class S

https://leetcode-cn.com/problems/same-tree/submissions/这还是写不出来，害//递归调用//传入参数：两个树的节点//终止条件：两个树为null,一边没有，节点值不等//内部逻辑：//对比左子节点，右节点//中左右//class Solution { public boolean isSameTree(TreeNode p, TreeNode q) { if(p == null && q == nu

https://leetcode-cn.com/problems/balanced-binary-tree/submissions//** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val =

https://leetcode-cn.com/problems/count-complete-tree-nodes/递归的题目，左右中的后序遍历思想。/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) {

https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/逻辑是当没有左右孩子节点的时候，+1深度，递归的思想。/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNod

https://leetcode-cn.com/problems/maximum-depth-of-n-ary-tree/几天没更新博客了，都忘了之前写的内容，这里用的应该是层序遍历来找最大深度，不难。/*// Definition for a Node.class Node { public int val; public List<Node> children; public Node() {} public Node(int _val) {

https://leetcode-cn.com/problems/binary-tree-paths/从这里开始，学习回溯算法，这是和递归有很大关联的算法。/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val)

https://leetcode-cn.com/problems/symmetric-tree/这道题目可以递归、迭代，我尝试了递归，不太好理解，只是照着印象打出来了一次，具体的思路下面写有。递归的算法我写完之后，对于迭代算法，我看了源码，自己尝试去解析，如第二段代码，感觉递归的代码更好理解一点。递归算法 //递归需要考虑三个条件 //1.传入参数：比较左右结点以及他们的孩子，因此要传入两个参数：左节点、右节点 //2.终止条件：当递归到空指针时停止 //3.函数内在处理逻辑： //1)判断

https://leetcode-cn.com/problems/invert-binary-tree/递归即可中序遍历不行，因为左右结点在交换之后会重复class Solution { public TreeNode invertTree(TreeNode root) { if(root == null) return root; sawp(root); invertTree(root.left); invertTree(

https://leetcode-cn.com/problems/binary-tree-level-order-traversal/没什么难度层序遍历，思路清晰多了每次出列一个节点，若节点有左右子节点，将他们入列。队列空了就停止考虑到要分层输出，因此每一次遍历结束之后，统计队列里下一层的长度，逐层输出。/** * Definition for a binary tree node. * public class TreeNode { * int val; * Tree

用迭代的方法来做的思路是：谁后读取，谁就先入栈，以此把三个节点入栈。三个节点中的头结点入栈之后，还要加入一个null作为空指针标记，以便下次弹出的时候直接读取。每次新一轮循环，把最先读取的那个node弹出作为头，然后重复第一步的操作我用图模拟了一下：前序遍历：class Solution { public List<Integer> preorderTraversal(TreeNode root) { List<Integer> res = n

这里的递归的第一课，可以说是个非常好的例子。怎么理解递归呢？递归函数的编写确实是个非常难的问题，但经过学习后发现，只要抓住一下几点就可以写出来了：确定终点条件。因为终点决定了递归何时结束，所以这里二叉树的重点就是遍历到root是空指针。缩小到一个局部来攥写函数，比如二叉树前序遍历（中左右），这时思考中是否会继续进入下一轮的递归，发现不用，但凡是中就读出来。那么左呢？左有可能会进入下一轮递归，于是将左这个值传入递归的参数中。右同左。细品，你细品，通过上面两点，你依次练习前中后序遍历，相信你也能搞懂

https://leetcode-cn.com/problems/remove-all-adjacent-duplicates-in-string/栈应用的简单题，注意最后出栈顺序相反，所以要倒转一下字符串。class Solution { public String removeDuplicates(String s) { Stack<Character> queue = new Stack<>(); StringBuffer res =

https://leetcode-cn.com/problems/implement-stack-using-queues/挺简单的就是每次添加的时候，把所有的数入列临时队列这样添加的数就到队头了。class MyStack { LinkedList<Integer> myStack; LinkedList<Integer> temp; public MyStack() { myStack = new LinkedList<&gt

题目链接这道题其实是也不难，前中后缀表达式好像之前学习的时候就知道是可以使用栈来解决的转换过程注意判断字符串类String的时候应该使用equals()方法class Solution { public int evalRPN(String[] tokens) { Stack<Integer> stack = new Stack<>(); for(int i = 0; i < tokens.length; i++){

队列的操作可以参考一下篇，它在Linkedlist类里面已经有实现。https://blog.youkuaiyun.com/Fly_as_tadpole/article/details/86536539主要就是和栈的push.pop一类的方法区分开，它的入列方法是offer，出列方法是poll。题目链接这道题目的方法比较难，需要使用到一个双向队列，解决办法如下：https://leetcode-cn.com/problems/sliding-window-maximum/solution/shuang-xi

https://leetcode-cn.com/problems/implement-queue-using-stacks/今天学习用两个栈实现队列，主要就是熟悉一下栈的基本操作吧？这种蛮简单的。import java.util.*;class MyQueue { Stack<Integer> stackIn = new Stack<>();//压入栈 Stack<Integer> stackOut = new Stack<>();//

题目链接：(https://leetcode-cn.com/problems/remove-element/)这个题目我看了一下暴力解法，貌似比较简单，所以思考之后我决定自己尝试写出来。我的思路：1.遍历数组2.遇到指定值的就将后面的数前移一位，并将size-13.由于前移了一位，遍历的位置不变化，即i-1，重新扫描该位置4.最后一个数不适合这个操作，应该直接判断是否与目标值相等，然后再次调整size的值教训：遍历的时候，一般整个数组的遍历条件都是i < nums.length,最后注

https://leetcode-cn.com/problems/zuo-xuan-zhuan-zi-fu-chuan-lcof/comments/这道题目也是简单的，直接在String上面去操作就行了，我就偷懒了。主要是学习一下优秀的解法，就是在原有的字符串上面操作，不使用额外空间的做法。我的解法：class Solution { public String reverseLeftWords(String s, int n) { //先把s转换成char数组

https://leetcode-cn.com/problems/reverse-words-in-a-string/好吧今天又傻一天，可变字符串的交换给我整傻了，再没有像原来的String那么好操作了，写出了个稀巴烂的代码，回头复习一下别人的优质解法。我的解法：class Solution { public String reverseWords(String s) { //初级解法 //先分割 //由后往前拼接 String[