puspos的博客

问题给定一个非负整数数组，a1, a2, …, an, 和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 -中选择一个符号添加在前面。返回可以使最终数组和为目标数 S 的所有添加符号的方法数。例子思路方法1回溯方法2代码//方法1class Solution { private int res = 0;...

问题例子思路问题抽象为无向无权图，单词为结点，差一个字母的单词之间连边。问题变成找到从起点到终点的最短路径，如果存在的话。因此可以使用广度优先搜索方法。递归深度遍历，超时所以考虑采用广度遍历方法1方法2代码//方法1 我的dfs 超时class Solution { private int res = Integer.MAX_VALUE; public int ladderLength(String beginWord, String endWord

问题对链表进行插入排序。例子思路方法1用指针sorted指向已经排序的最后一个位置因为要插入，所有需要头结点和一个pre指针方法2代码//方法1class Solution { public ListNode insertionSortList(ListNode head) { if(head==null || head.next==null) return head; ListNode h = new ListNode(-

问题给定一个字符串，逐个翻转字符串中的每个单词。例子思路方法1先把各单词反转，然后整个数组反转方法2代码//方法1class Solution { public void reverseWords(char[] s) { int begin=0; for(int i=0; i<s.length; i++) { if(s[i]==' ') { if(i-1>=0

问题例子思路存在前导零，" 01"==11.0 11.1 1方法1方法2代码//方法1class Solution { public int compareVersion(String version1, String version2) { String[] arr1 = version1.split("\\."); String[] arr2 = version2.split("\\."); int i=0

问题例子思路方法1使用队列保存递增数组，为什么用队列？因为方便，直接poll即可，但缺点是空间复杂度是O(n)而不是O(logn)方法2使用栈，初始保存所有的左子树。获取next时，取栈顶元素的值，并把下一个最小的大于该值的结点放入栈next方法：看起来是O(n)，其实是O(1)，因为其中的循环加上初始化的循环，共放入栈中n个元素，总共会有O(n)次操作，均摊到每一次next()的话平均时间复杂度则是O(n)/n=O(1)代码//方法1class BSTIte

问题例子思路方法1方法2代码//方法1 我自己的class Solution { public List<List<Integer>> subsetsWithDup(int[] nums) { List<List<Integer>> list = new ArrayList<>(); list.add(new ArrayList<Integer>(

问题给定一个整数 n，生成所有由 1 … n 为节点所组成的二叉搜索树。例子思路方法1获取左子树集合和右子树集合，轮番组成树方法2代码//方法1class Solution { public List<TreeNode> generateTrees(int n) { if(n==0) return new ArrayList<TreeNode>(); return generate(1,n);

问题例子思路方法1首先对边界上每一个’O’做深度优先搜索【朝着四面搜索】，将与其相连的所有’O’改为’-’。然后遍历矩阵，将矩阵中所有’O’改为’X’,将矩阵中所有’-‘变为’O’方法2代码//方法1class Solution { public void solve(char[][] board) { if(board==null || board.length==0) return ; int m=board.length,

问题例子思路//->//.->//a/..->/最后一个不能是/方法1split("/")->"", “.”, “xx”, “…”遍历数组arr，如果是"…"，就把栈顶弹出，如果不是""和“."就放入栈方法2代码//方法1class Solution { public String simplifyPath(String path) { String[] arr = path.split("/"

问题例子思路方法1先序遍历：sb回溯，方法2先序遍历：不用回溯代码//方法1class Solution { private int res=0; public int sumNumbers(TreeNode root) { if(root==null) return 0; backtrack(root, new StringBuilder()); return res; } publi

问题给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素最多出现两次，返回移除后数组的新长度。不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。例子思路方法1方法2每个元素最多出现两次意味着：nums[i]!=nums[i-2]代码//方法1 我的class Solution { public int removeDuplicates(int[] nums) { if(nums

问题例子思路方法1方法2代码//方法1class Solution { public boolean search(int[] nums, int target) { if(nums==null || nums.length==0) return false; int i=0,j=nums.length-1; while(i<=j) { //处理重复数字 1，1，3，1

116. 填充每个节点的下一个右侧节点指针问题给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。初始状态下，所有 next 指针都被设置为 NULL。例子思路完美二叉树：除了叶子结点之外的每一个结点都有两个孩子结点方法1方法2117. 填充每个节点的下一个右侧节点指针 II问题不是完美二叉树代码

问题给定一个链表和一个特定值 x，对链表进行分隔，使得所有小于 x 的节点都在大于或等于 x 的节点之前。你应当保留两个分区中每个节点的初始相对位置。例子思路方法1新创一个链表，遍历原链表，后插法用新链表保存所有<x的结点，并删除原来链表的所有<x的结点要点：既然删除结点，则必须设置一个头节点，和pre指针方法2代码//方法1class Solution { public ListNode partition(ListNode head, int

问题给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。有效的 IP 地址正好由四个整数（每个整数位于 0 到 255 之间组成），整数之间用 ‘.’ 分隔。例子思路关键点：每个整数处于[0, 255]不能出现以0开头的两位以上整数,比如012,08…方法1暴力方法2回溯代码//方法1class Solution { public List<String> restoreIpAddresses(String s) {

问题例子思路有从顶到下，和从下到上，其中从下到上更方便原因：从顶到下要处理特殊情况从下到上方法1方法2代码//方法1 从顶到下 空间复杂度O(n^2)class Solution { public int minimumTotal(List<List<Integer>> triangle) { if(triangle==null || triangle.size()==0) return 0; int[][]

问题例子思路要求时间复杂度为：O(logn)，则一定是用二分查找如何二分？nums[mid]<nums[mid+1]时，mid+1~len-1一定存在峰值，此时mid+2只有两种可能。一：小于mid+1，那么mid+1就是峰值二：大于mid+1，则继续向右推，如果一直到数组的末尾都是大于的，那么可以肯定最后一个元素是峰值，因为nums[nums.length]=负无穷方法1方法2代码//方法1class Solution { public int

问题例子思路dp[i]为在s中截止到下标i-1，是否truedp[i]=dp[j]==true && s[j,i]是否在list中方法1方法2代码//方法1class Solution { public boolean wordBreak(String s, List<String> list) { boolean[] dp = new boolean[s.length()+1];

问题例子00->0, 01->0, 100->0思路类似跳台阶dp[n]=dp[n-1]+dp[n-2]但是由限制条件：如果当前数字不是0，可以通过dp[i-1]得到，是0，就不能通过dp[i-1]得到如果和前一个数字组合为：10~26，则可以通过dp[i-2]得到，否则，不能通过dp[i-2]得到方法1方法2代码//方法1class Solution { public int numDecodings(String s) {

问题例子思路方法1方法2代码//方法1class Solution { public int canCompleteCircuit(int[] gas, int[] cost) { //rest为从下标0到i剩余油量，run为从起点到i剩余油量 int rest=0,run=0,start=0; for(int i=0; i<gas.length; i++) { run += gas[

问题根据一棵树的中序遍历与后序遍历构造二叉树。注意:你可以假设树中没有重复的元素例子思路方法1类似105，后序遍历最后一个是根结点的值，该值把中序遍历分为两半方法2代码//方法1class Solution { public TreeNode buildTree(int[] inorder, int[] postorder) { return make(inorder,0,inorder.length-1,postorder,0,postor

问题例子思路难点：当只保留到i下标的最大值时，[-2,3,-4]，得到24而不是3，怎么办？保留到i下标的最大值和最小值方法1方法2代码//方法1class Solution { public int maxProduct(int[] nums) { if(nums.length==0) return 0; int imax=1,imin=1;//到i下标之前最大的和最小的 int max = Integer.MIN_V

问题给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。例子思路方法1把有序链表变成有序数组，问题就变成了108题方法2找到中间结点，该结点的值创造根结点，然后从该结点分成前后两截【使用一个指针表示前一段最后一个结点的前一个结点】，分别得到左子树和右子树，返回root代码//方法1class Solution { public TreeNode s

问题给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中 没有重复出现 的数字。例子思路方法1非递归，两个指针，方便删除最后一个结点方法2递归代码//方法1class Solution { public ListNode deleteDuplicates(ListNode head) { if(head==null || head.next==null) return head; ListNode h = new L

问题给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。例子思路方法1层次遍历，每层的最后一个。如果是左视图，可层次遍历每层的第一个方法2代码//方法1class Solution { public List<Integer> rightSideView(TreeNode root) { if(root==null) return new ArrayList<Integer>();

问题给定一个大小为 n 的数组，找出其中所有出现超过 ⌊ n/3 ⌋ 次的元素。说明: 要求算法的时间复杂度为 O(n)，空间复杂度为 O(1)。例子思路方法1>1/3的数，最多为2个，根据投票法，选出来两个最多的，然后把>1/3的数放入list方法2代码//方法1class Solution { public List<Integer> majorityElement(int[] nums) { List<Int

问题给出一个完全二叉树，求出该树的节点个数。例子思路方法1不管是不是完全二叉树都可以用方法2利用完全二叉树特性：满二叉树个数：2^h-1，左右子树高度差不超过1如果左子树高度==右子树高度，则：左子树是满的，结点个数为：2^dep_left-1+1(根)，然后计算右子树的个数如果左子树高度!=右子树高度，则说明右子树是满的，但是高度比左子树低，结点个数为：2^dep_right-1+1(根)，然后计算左子树的个数代码//方法1class Solution {

问题给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。例子思路方法1方法2代码//方法1//方法2...

问题假设按照升序排序的数组在预先未知的某个点上进行了旋转。( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。假设数组中不存在重复的元素。要求时间复杂度O(log n)例子思路因为要求时间复杂度为O(logn)，所以为二分法方法1数组可以从中间分为有序和无序的。中间数<最右边的数？如果是，表明[mid,]为有序，否则[,mid]为有序看目标数是否在有

问题例子思路方法1滑动窗口方法2代码//方法1class Solution { public boolean check(int[] arr) { for(int n : arr){ if(n!=0) return false; } return true; } p...

问题给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。返回 s 所有可能的分割方案。例子思路方法1回溯查看是不是回文字符串方法2代码//方法1class Solution { public List<List<String>> partition(String s) { List<List...

问题给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组。如果不存在符合条件的连续子数组，返回 0。例子思路方法1方法2代码//方法1class Solution { public int minSubArrayLen(int s, int[] nums) { if(nums.length...

问题例子思路方法1遍历二维数组，当前位置为‘1’，表明是个新的岛屿，结果数量+1，然后把该岛变成水方法2代码//方法1class Solution { public int numIslands(char[][] grid) { if(grid.length==0) return 0; int res = 0; ...

问题例子思路同207课程表，使用数组保存每次删除【确定上】的课程方法1$$$$方法2$$$$代码//方法1class Solution { public int[] findOrder(int numCourses, int[][] prerequisites) { int[] res = new int[numCourses];...

问题例子思路课程安排图是否是 有向无环图(DAG)使用拓扑排序（广度遍历，深度遍历）拓扑排序（Topological Sorting）可得到一个有向无环图（DAG, Directed Acyclic Graph）的所有顶点的线性序列，该序列满足：每个顶点出现且只出现一次。若存在一条从顶点 A 到顶点 B 的路径，那么在序列中顶点 A 出现在顶点 B 的前面。广度遍历使用...

问题例子思路冷冻：即买入卖出后的over状态每天的状态：当天卖出，当天冷冻，当天买入，当前是买入后的无操作。可压缩为3中状态：当前卖出，当天冷冻，当天持有状态转换:卖出的前一天：必须是持有状态持有的前一天，持有或者是冷冻【因为卖出后，必须冷冻才能再次买入】冷冻的前一天：冷冻或者卖出方法1 O(n) O(n)$$$$方法2 O(n) O(1)$$$$...

问题例子思路对于根节点root，偷它时，则不能再偷子结点，只能偷孙子结点如果不偷，可偷子结点比较两种方式哪种偷的多方法1$$$$直接递归方法2$$$$由于有大量的重复计算，所以保存计算的结果代码//方法1 public int rob(TreeNode root) { if(root==null) return 0;...

问题例子思路直接遍历结点的话，因为random是随机的，有没有创建不知道，所以使用辅助map，旧结点，新结点【遍历结点，复制一份，并放在map中与原结点进行映射】，则原结点之间的映射关系，就是新节点之间的映射关系方法1$$$$方法2$$$$代码//方法1/*// Definition for a Node.class Node { int v...

问题例子思路遍历树a，把a的子树结构和b进行比较比较时，只要b进行到null，不管a进行到是不是null，返回true方法1$$$$方法2$$$$代码//方法1class Solution { private boolean res = false; public boolean isSubStructure(TreeNode A, ...