猫敷雪

每次根据当前的两个指针对应的高度计算面积，然后移动较短的指针向内靠拢。移动较短的指针是因为面积取决于最短的高度，因此移动较短的指针才有可能增加面积。假设这些柱子之间会积水，那么每根柱子上能积多少水，取决于它左边和右边最高的柱子。这是因为水会被高的柱子“挡住”，从而在矮的柱子处积水。的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。该算法的时间复杂度为 O(n)，因为每次只移动一个指针。移动到数组的末尾，同时保持非零元素的相对顺序。**注意：**答案中不可以包含重复的三元组。，判断是否存在三元组。

完全按照题目的意思，每次把末尾的元素移动到开头，当然移动前需要把所有元素后移一位，把第一个位置腾出来。转动数组，将数组的最后一个元素移动到开头，重复操作 k 次。新开辟数组，增加空间复杂度。

由于 2 是超过半数的数，它的二进制是 010，所以对于从右边数第一列一定是 0 超过半数，从右边数第二列一定是 1 超过半数，从右边数第三列一定是 0 超过半数。当然，我们可以只统计 1 的个数，让每一位开始默认为 0，如果发现某一列的 1 的个数超过半数，就将当前位改为 1。这样经过充分时间的游戏后，最后的结果是确定的，一定是超过半数的那个队伍留在了最后。，0 或者 1，然后这些超过半数的二进制位组成一个数字，就是我们要找的数。遍历每一位，如果某一位上1的个数超过 n//2，则将该位设置为1。

题目描述：困难给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是回文。返回符合要求的 最少分割次数 。解法 动态规划cut[i] is the minimum of cut[j - 1] + 1 (j <= i), if [j, i] is palindrome.If [j, i] is palindrome, [j + 1, i - 1] is palindrome, and c[j] == c[i].a b a | c c

题目描述（中等难度）给一个字符串，然后在任意位置切割若干次，保证切割后的每个字符串都是回文串。输出所有满足要求的切割结果。解法一 回溯public class Palindrome_Partitioning2 { public static List<List<String>> partition(String s){ List<List<String>> res = new ArrayList<>();

题目描述（困难难度）二叉树的后序遍历，会用到之前 94 题 中序遍历和 144 题 先序遍历的一些思想。解法一 递归和之前的中序遍历和先序遍历没什么大的改变，只需要改变一下 ans.add 的位置。public class postorderTraversal { public static List<Integer> postorderTraversal(TreeNode root){ List<Integer> ans = new ArrayLi

题目描述（困难难度）给你一个只包含 '(' 和 ')' 的字符串，找出最长有效（格式正确且连续）括号子串的长度。给一个一堆括号的字符串，然后返回最长的合法的括号的长度。关于括号的问题，我们在 20 题和 22 题也讨论过。解法一 暴力解法列举所有的字符串，然后判断每个字符串是不是符合。当然这里可以做个优化就是，因为合法字符串一定是偶数个，所以可以只列举偶数长度的字符串。列举从 0 开始的，长度是 2、4、6 ……的字符串，列举下标从 1 开始的，长度是 2、4、6 ……的字符串，然后循环下去。当然

一样，给定一个数组，代表每天的价格。区别在于 121 题只能进行一次买入卖出。但是这道题可以不停的买入、卖出，但是只有卖出了才能继续买入。就用最简单的思想，我们穿越回去了过去，知道了未来每天的股票价格，要怎么操作呢？只要当前天相对于前一天上涨了，我们就前一天买入，当前天卖出。考虑了上边的所有情况，就可以写代码了。其实不用考虑那么多，再直接点，还有一种持续下跌的情况。需要考虑两种特殊情况。

题目描述 中等难度找出二叉树中每一行的最大值，保存到数组中。解法一 BFS官渡优先遍历一般直接和队列联系起来。import java.util.*;class TreeNode{ int val; TreeNode left; TreeNode right; TreeNode(int val){this.val=val;}}//BFSpublic class Find_Largest_Value_in_Each_Tree_Row { publi

题目描述(简单难度)给一个数组，存在一个数字超过了半数，找出这个数。解法一这种计数问题，直接就会想到HashMap，遍历过程中统计每个数字出现的个数即可。可以确定的是，超过半数的数字一定有且只有一个。所以在计数过程中如果出现了超过半数的数字，我们可以立刻返回。import java.util.HashMap;public class Majority_Element { public static int majorityElement(int[] nums){ Has

题目描述（中等难度）有一点点像围棋，把被x围起来的o变成x，边界的o一定不会被围起来。如果o和边界的o连通起来，那么这些o就都算作不被围起来，比如下边的例子。X X X X XO O O X XX X X O XX O X X X上边的例子就只需要变化1个o.解法一把相邻的o看做是联通的图，然后从每一个o开始做DFS。如果遍历完成后没有到达边界的o，我们就把当前o改成x。如果遍历过程中达到了边界的o，直接结束DFS，当前的o就不用操作。然后继续考虑下一个o，继续做一次DFS。pu

题目描述（中等难度）从根节点到叶子节点的路径组成一个数字，计算所有的数字和。思路分析和112题有点像，112题时给出一个sum，然后去找这条路径。但本质上都是一样的，只需要对二叉树进行遍历，遍历过程中记录当前路径的和就可以。说到遍历，无非就是BFS和DFS，如果进行BFS，过程中我们需要维护多条路径的和，所以我们选择DFS。说到DFS的话，可以用递归，也可以用实现，递归会更好理解一些，所以这里就只介绍递归。说到递归，既可以利用回溯的思想，也可以用分治的思想，这里就用这两种方式写一下，关于回溯、分

题目描述（困难难度）给一个数组，求出连续的数字最多有多少个，时间复杂度要求是0(n).解法一首先想一下最直接的暴力破解。我们可以用一个hashset把给的数组保存起来。然后再考虑数组的每个数，比如这个数是n，然后看n+1在不在hashset中，然后再看n+2在不在，接下来n+3、n+4、直到在hashset中找不到，记录当前的长度。然后继续考虑下一个数，并且更新最长的长度。public int longestConsecutive(int[] nums) { HashSet<Inte

题目描述(简单难度)反转二叉树，将二叉树所有的节点的左右两个孩子交换。解法一 递归class TreeNode{ int val; TreeNode left; TreeNode right; TreeNode(int x){ val=x; }}public class Invert_Binary_Tree { public static TreeNode invertTree(TreeNode root){ if

题目描述（中等难度）二叉树的先序遍历。思路分析之前做过 94 题 的中序遍历，先序遍历的话代码可以直接拿过来用，只需要改一改 list.add 的位置。解法一 递归递归很好理解了，代码也是最简洁的。public List<Integer> preorderTraversal(TreeNode root) { List<Integer> list = new ArrayList<>(); preorderTraversalHelper(root

题目描述（简单难度）判断两个字符串是否是异构，也就是两个字符串包含的字母是完全相同的，只是顺序不一样.解法一 HashMap最通用的解法，通过 HashMap 记录其中一个字符串每个字母的数量，然后再来判断和另一个字符串中每个字母的数量是否相同。import java.util.HashMap;public class Valid_Anagram { public static boolean isAnagram(String s,String t){ HashMap&l

题目描述（简单难度）设计数据结构的题，设计一个栈，除了栈特有的功能，入栈、出栈、查看栈顶元素，还需要增加一个功能，得到当前栈里边最小的元素。解法一要实现一个 stack，那么我们还能用 java 自带的 stack 吗？也不用纠结，这道题的关键其实是实现「得到最小值这个功能」，所以为了代码简洁些，我们就直接使用系统自带的 stack 了。这道题最直接的解法就是我们可以用两个栈，一个栈去保存正常的入栈出栈的值，另一个栈去存最小值，也就是用栈顶保存当前所有元素的最小值。存最小值的栈的具体操作流程如下：

题目描述（简单难度）转动数组，将数组的最后一个元素移动到开头，重复操作k次。解法一完全按照题目的意思，每次把末尾的元素移动到开头，当然移动前需要把所有元素后移一位，把第一个位置腾出来。此外如果k大于数组的长度，k是等效于k % n的。举个例子，nums=[1 2 3 ],k=4,操作4次和操作4 % 3=1 次是一样的效果。public class Rotate_Array { public static int[] rotate(int[] nums,int k) {

题目描述（简单难度）将所有的 0 移动到末尾，并且保持其他数字的相对顺序不变。解法一我的第一反应是利用两个指针，一个指针指向开头，一个指针指向末尾非零元素，然后从开头指针遍历，如果遇到 0 就和末尾指向的元素相交换，末尾指针向前移动到非零元素。这就保证末尾指针后边元素全部是 0，当首尾指针相遇的时候结束。但是上边的想法会使得其他数字的相对顺序改变了，我们可以逆转一下思路。不是将0 放到末尾，而是将所有非零元素放到开头，这样就保证末尾剩下的都是 0 了。同样利用双指针，指针 i 用于遍历数组，指

题目描述（中等难度）141 题 的升级版，之前只需要判断是否有环，现在需要把环的入口点找到，也就是直线和圆的交接点。思路的话，还是之前的两种思路。解法一 HashMap遍历链表，并且把遍历过的节点用 HashSet 存起来，如果遍历过程中又遇到了之前的节点，说明这个节点就是我们要找到入口点。如果到达了 null 就说明没有环。public ListNode detectCycle(ListNode head) { HashSet<ListNode> set = new Hash

题目描述（简单难度）判断一个链表是否有环。解法一最直接的方法，遍历链表，并且把遍历过的节点用 HashSet 存起来，如果遍历过程中又遇到了之前的节点就说明有环。如果到达了 null 就说明没有环。import java.util.HashSet;class ListNode{ int val; ListNode next; ListNode(int x){val=x;}}public class Linked_List_Cycle { public st

题目描述（简单难度）单链表倒置。解法一 迭代首先看一下原链表。总共需要添加两个指针，pre 和 next。初始化 pre 指向 NULL 。然后就是迭代的步骤，总共四步，顺序一步都不能错。next 指向 head 的 next ，防止原链表丢失head 的 next 从原来链表脱离，指向 pre 。pre 指向 headhead 指向 next次迭代就完成了，如果再进行一次迭代就变成下边的样子。可以看到整个过程无非是把旧链表的 head 取下来，添加的新链表头部。代码

题目描述（困难难度）给定两个单词，一个作为开始，一个作为结束，还有一个单词列表。然后依次选择单词，只有当前单词到下一个单词只有一个字母不同才能被选择，然后新的单词再作为当前单词，直到选到结束的单词。输出这个的最短路径，如果有多组，则都输出。思路分析这道题有些难讲清楚，一个原因就是解法的代码会很长，这里理一下整个的思路。如果我们从开始的单词，把与之能够转换的单词连起来，它就会长成下边的样子。橙色表示结束单词，上图橙色的路线就是我们要找的最短路径。所以我们要做的其实就是遍历上边的树，然后判断当前节

题目描述（简单难度）判断一个字符串是否是回文串，忽略掉除了字母和数字外的字符。解法一两个指针，一个指针从头进行，一个指针从尾部进行。依次判断两个指针的字符是否相等，同时要跳过非法字符。需要注意的是，两个指针不用从头到尾遍历，当两个指针相遇的时候就意味着这个字符串是回文串了。还需要注意的是'A' == 'a'，也就是大写字母和小写字母是相同的。public boolean isPalindrome(String s) { int len = s.length(); s = s.to

题目描述（困难难度）考虑一条路径，可以从任意节点开始，每个节点最多经过一次，问经过的节点的和最大是多少。解法一 递归首先看到二叉树的题，肯定就是想递归了。递归常规的思路，肯定是递归考虑左子树的最大值，递归考虑右子树的最大值。public int maxPathSum(TreeNode root) { if (root == null) { return Integer.MIN_VALUE; } //左子树的最大值 int left = maxPath

题目描述（困难难度）依旧是买卖股票的延伸，但比 121 题 ， 122 题 难度高了不少。这道题的意思是，给一个数组代表股票每天的价格。你最多可以买入卖出两次，但只有卖出了才可以再次买入，求出最大的收益是多少。解法一开始的想法是求出收益第一高和第二高的两次买卖，然后加起来。对于普通的情况是可以解决的，但是对于下边的情况1 5 2 8 3 10第一天买第二天卖，第三天买第四天卖，第五天买第六天卖，三次收益分别是 4，6，7，最高的两次就是 6 + 7 = 13 了，但是我们第二天其实可以不卖出，

先写个暴力的，看看对题目的理解对不对。用两个循环，外层循环表示买入时候的价格，内层循环表示卖出时候的价格，遍历所有的情况，期间更新最大的收益。给一个数组，看作每天股票的价格，然后某一天买入，某一天卖出，最大收益可以是多少。可以不操作，收入就是。这种数组优化，经常就是考虑双指针的方法，从而使得两层循环变成一层。思考一下怎么定义指针的含义。用两个指针， buy 表示第几天买入，sell 表示第几天卖出。代码的话就很好写了。

题目描述（简单难度）和 118 题 一样，依旧是杨辉三角。区别在于之前是输出所有层的数，这道题只需要输出第 k 层的数。解法一和 118 题 一样，我们只需要一层一层的求。但是不需要把每一层的结果都保存起来，只需要保存上一层的结果，就可以求出当前层的结果了。public List<Integer> getRow(int rowIndex) { List<Integer> pre = new ArrayList<>(); List<Inte

题目描述（简单难度）其实就是杨辉三角，当前元素等于上一层的两个元素的和。解法一用两层循环，注意一下我们下标是从 0 开始还是从 1 开始，然后就可以写出来了。import java.util.ArrayList;import java.util.List;public class Pascal_Triangle { public static List<List<Integer>> generate(int numRows){ List&lt

题目描述（中等难度）给定一个二叉树，然后每个节点有一个 next 指针，将它指向它右边的节点。和 116 题 基本一样，区别在于之前是满二叉树。解法一 BFS直接把 116 题 题的代码复制过来就好，一句也不用改。利用一个栈将下一层的节点保存。通过pre指针把栈里的元素一个一个接起来。public Node connect(Node root) { if (root == null) { return root; } Queue<Node> q

题目描述（中等难度）给定一个满二叉树，每个节点多了一个next指针，然后将所有的next指针指向它的右边的节点。并且要求空间复杂度是O(1)。解法一 BFS如果没有要求空间复杂度这道题就简单多了，我们只需要用一个队列做BFS。然后按顺序将每个节点连起来就可以了。public Node connect(Node root) { if (root == null) { return root; } Queue<Node> queue = new Li

题目描述（中等难度）把一个二叉树展开成一个链表，展开顺序如图所示。解法可以发现展开的顺序其实就是二叉树的先序遍历.我们需要两步完成这道题。将左子树插入到右子树的地方将原来的右子树接到左子树的最右边节点考虑新的右子树的根节点，一直重复上边的过程，直到新的右子树为 null可以看图理解下这个过程。 1 / \ 2 5 / \ \3 4 6//将 1 的左子树插入到右子树的地方 1 \ 2 5 /

题目描述（中等难度）112 题 的升级版，给定一个sum，输出从根节点开始到叶子节点，和为sum 的所有路径可能。直接在 112 题 的基础上改了，解法没有新内容，大家可以过去看一看。解法一 递归112 题 的解法是下边的样子。public boolean hasPathSum(TreeNode root, int sum) { if (root == null) { return false; } return hasPathSumHelper(ro

题目描述（简单难度）给定一个sum，判断是否有一条从根节点到叶子节点的路径，该路径上所有数字的和等于sum。解法一 递归这道题其实和 111 题 是一样的，大家可以先看 111 题 的分析，这道题无非是把 111 题 递归传递的depth改为了sum的传递。如果不仔细分析题目，代码可能会写成下边的样子。public boolean hasPathSum(TreeNode root, int sum) { if (root == null) { return false;

题目描述（简单难度）返回从根节点到叶子节点最小深度。解法一 递归和 104 题 有些像，当时是返回根节点到叶子节点的最大深度。记得当时的代码很简单。public int maxDepth(TreeNode root) { if (root == null) { return 0; } return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;}这道题是不是只要把Math.max，改成M

题目描述（简单难度）判断一棵树是否是平衡二叉树，平衡二叉树定义如下：它是一棵空树或它的左右两个子树的高度差的绝对值不超过 1，并且左右两个子树都是一棵平衡二叉树。解法一直接按照定义来吧，并且多定义一个求高度的函数，之前在 104 题 做过。class TreeNode{ int val; TreeNode left; TreeNode right; TreeNode(int x){val=x;}}public class Balanced_Binary_Tree { pu

题目描述（中等难度）和 108 题 是一样的，都是给定一个升序序列，然后生成二分平衡查找树。区别在于 108 题给定的是数组，这里给的是链表。解法一大家先看一下 108 题 吧，算法的关键是取到中间的数据做为根节点。而这里链表的话，由于不支持随机访问，所以会麻烦些。最简单的思路就是我们把链表先用线性表存起来，然后题目就转换成 108 题了。为了方便，把上一道题的数组参数改为List 。import java.util.ArrayList;class TreeNode{ int val;

题目描述（简单难度）给一个升序数组，生成一个平衡二叉搜索树。平衡二叉树定义如下：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 二叉搜索树定义如下：若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值；若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值；任意节点的左、右子树也分别为二叉查找树；没有键值相等的节点。解法一 递归如果做了 98 题 和 99 题，那么又看到这里的升序数组，然后应该会想到一个点，二

题目描述（简单难度）树的层次遍历，和 102 题 的不同之处是，之前输出的数组顺序是从根部一层一层的输出，现在是从底部，一层一层的输出。解法一 DFS把102 题 的DFS贴过来看一下。public List<List<Integer>> levelOrder(TreeNode root) { List<List<Integer>> ans = new ArrayList<>(); DFS(root, 0, ans);

题目描述（中等难度）思路分析可以先看一下 105 题，直接在 105 题的基础上改了，大家也可以先根据 105 题改一改。105 题给的是先序遍历和中序遍历，这里把先序遍历换成了后序遍历。区别在于先序遍历的顺序是 根节点 -> 左子树 -> 右子树。后序遍历的顺序是 左子树 -> 右子树 -> 根节点。我们当然还是先确定根节点，然后在中序遍历中找根节点的位置，然后分出左子树和右子树。对于之前的解法一，传数组的两个边界，影响不大，只要重新计算边界就可以了。解法一常规