dadongwudi的博客

【问题描述】[简单]【解答思路】1. 排序平方后排序 没有使用排序的特性时间复杂度：O(NlogN) 空间复杂度：O(1)class Solution { public int[] sortedSquares(int[] A) { int[] ans = new int[A.length]; for (int i = 0; i < A.length; ++i) { ans[i] = A[i] * A[i];

【问题描述】[中等]【解答思路】1. BFS层次遍历思想 （通用）时间复杂度：O(N) 空间复杂度：O(N) public Node connect(Node root) { if (root == null) return root; Queue<Node> queue = new LinkedList<>(); queue.add(root); while (!queu

【问题描述】[中等]【解答思路】1. 递归时间复杂度：O(N) 空间复杂度：O(N)class Solution { public ListNode swapPairs(ListNode head) { if(head == null || head.next == null){ return head; } ListNode next = head.next; head.next = swap

【问题描述】[简单]【解答思路】计数法1. minfreq存放最终重复字母的个数 freq存放每次遍历字符串的字母个数2. minfreq初始化最大值，每遍历一个字符串后，比较minfreq[i]、freq[i]的大小，minfreq[i]更新为两者的最小值。3. 根据minfreq，输出答案时间复杂度：O(N^2) 空间复杂度：O(N)class Solution { public List<String> commonChars(String[] A) {

【问题描述】[中等]【解答思路】1. 动态规划时间复杂度：O(N) 空间复杂度：O(N)class Solution { public int minimumOperations(String leaves) { if (leaves == null || leaves == "") { // 排除 不合法参数情况 return 0; } int length = leaves.length();

【问题描述】[中等]【解答思路】1. 三指针时间复杂度：O(N) 空间复杂度：O(1)class Solution { public void sortColors(int[] nums) { int n = nums.length; int p0 = 0, p2 = n - 1; for (int i = 0; i <= p2; ++i) { while (i <= p2 &&

【问题描述】[中等]【解答思路】1. 层次遍历 public Node connect(Node root) { if (root == null) return root; Queue<Node> queue = new LinkedList<>(); queue.add(root); while (!queue.isEmpty()) { //每一层的数量

【问题描述】[中等]【解答思路】copyOfRangeclass Solution { public TreeNode constructFromPrePost(int[] pre, int[] post) { if(pre==null || pre.length==0) { return null; } return dfs(pre,post); } private TreeNode dfs(int

【问题描述】[中等]【解答思路】public class Solution { public TreeNode buildTree(int[] inorder, int[] postorder) { int inLen = inorder.length; int postLen = postorder.length; // 特判 if (inLen != postLen) { throw new R

【问题描述】[中等]【解答思路】时间复杂度：O(N^2) 空间复杂度：O(N^2)class Solution { public int longestCommonSubsequence(String text1, String text2) { int m = text1.length(), n = text2.length(); int[][] dp = new int[m + 1][n + 1]; for (int i =

【问题描述】[中等]【解答思路】1. 位运算复杂度class Solution { List<Integer> t = new ArrayList<Integer>(); List<List<Integer>> ans = new ArrayList<List<Integer>>(); public List<List<Integer>> subsets(int[] num

【问题描述】[简单]【解答思路】1. DFS递进思想 一步一步递进/先序遍历求所有节点值之和 public int sumOfTrees(TreeNode root) { if (root == null) { return 0; } int leave = root.val; int left = sumOfTrees(root.left); int right = sumOfTre

【问题描述】[中等]【解答思路】1. DFS繁琐版本class Solution { public boolean exist(char[][] board, String word) { boolean flag = false; int row= board.length; int col= board[0].length; boolean[][] used = new boolean[row][col];

【问题描述】[中等]【解答思路】回溯 剪树枝 当和超过n 或 个数超过k1. 正向求和 优化前class Solution { public List<List<Integer>> ans = new LinkedList(); public List<List<Integer>> combinationSum3(int k, int n) { dfs(0,k,0,n,1,new LinkedList<Inte

【问题描述】[中等]【解答思路】1. 减法import java.util.ArrayDeque;import java.util.ArrayList;import java.util.Arrays;import java.util.Deque;import java.util.List;public class Solution { public List<List<Integer>> combinationSum2(int[] candidate

【问题描述】[中等]【解答思路】1. 回溯import java.util.ArrayDeque;import java.util.ArrayList;import java.util.Deque;import java.util.List;public class Solution { public List<List<Integer>> combinationSum(int[] candidates, int target) {

【问题描述】[中等]【解答思路】1. 回溯时间复杂度：O(N^2) 空间复杂度：O(1)class Solution { List<List<Integer>> lists = new ArrayList<>(); public List<List<Integer>> combine(int n, int k) { List<Integer> list = new ArrayLis

【问题描述】[中等]【解答思路】1. 堆复杂度class Solution { public int[] topKFrequent(int[] nums, int k) { Map<Integer, Integer> occurrences = new HashMap<Integer, Integer>(); for (int num : nums) { occurrences.put(num, occur

一、拓扑排序拓扑排序是基于依赖关系的节点，根据依赖关系而生成的序列。节点和依赖关系往往要生成有向无环图。类似的问题有：穿衣服裤子的先后关系，生成穿衣序列/专业课程与前置课程形成的课程学习序列/代码编译依赖关系形成的编译顺序序列。public class Graph { private int v; // 顶点的个数 private LinkedList<Integer> adj[]; // 邻接表 public Graph(int v) { this.v = v;

【问题描述】[简单]【解答思路】1. DFS时间复杂度：O(N^2) 空间复杂度：O(N^2)class Solution { public List<String> binaryTreePaths(TreeNode root) { List<String> paths = new ArrayList<String>(); constructPaths(root, "", paths); retu

【问题描述】[困难]【解答思路】1. 主副对角线列 标记复杂度import java.util.ArrayDeque;import java.util.ArrayList;import java.util.Deque;import java.util.List;public class Solution { private int n; // 记录某一列是否放置了皇后 private boolean[] col; // 记录主对角线上的单元格是否放

【问题描述】[中等]【解答思路】1.递归复杂度class Solution { public boolean PredictTheWinner(int[] nums) { return total(nums,0,nums.length-1,1) >=0; } //turn 标记轮到谁了 正数表示先手 负数表示后手 public int total( int[]nums ,int start,int end,int turn){

【问题描述】[中等]【解答思路】当 xx 号房间中有 yy 号房间的钥匙时，我们就可以从 xx 号房间去往 yy 号房间。如果我们将这 nn 个房间看成有向图中的 nn 个节点，那么上述关系就可以看作是图中的 xx 号点到 yy 号点的一条有向边。这样一来，问题就变成了给定一张有向图，询问从 00 号节点出发是否能够到达所有的节点。用visit数组或者Set记录已经访问的节点1. DFS使用深度优先搜索的方式遍历整张图，统计可以到达的节点个数，并利用数组 vis 标记当前节点是否访问过，以防止

【问题描述】[简单]【解答思路】1. 遍历开辟一个新字符串。然后从头到尾遍历原字符串，直到找到空格为止，此时找到了一个单词，并能得到单词的起止位置。随后，根据单词的起止位置，可以将该单词逆序放到新字符串当中。如此循环多次，直到遍历完原字符串，就能得到翻转后的结果。时间复杂度：O(N) 空间复杂度：O(1)class Solution { public String reverseWords(String s) { StringBuffer ret = new Str

【问题描述】[中等]【解答思路】1. 字符串哈希复杂度class Solution { public String shortestPalindrome(String s) { int n = s.length(); int base = 131, mod = 1000000007; int left = 0, right = 0, mul = 1; int best = -1; for (int i

【问题描述】[中等]【解答思路】1. 递归（超时）class Solution { int res = Integer.MAX_VALUE; public int coinChange(int[] coins, int amount) { if(coins.length == 0){ return -1; } findWay(coins,amount,0); // 如果没有任何一种硬币组合能

【问题描述】[简单]【解答思路】遍历方向 看是否回到原点 或者 “上下” “左右”两个方向的数量是否相等1. 方向时间复杂度：O(N) 空间复杂度：O(1)class Solution { public boolean judgeCircle(String moves) { int x = 0,y= 0; int len = moves.length(); if(len == 0){ return true;

【问题描述】[中等]【解答思路】递归复杂度class Solution { Map<String, PriorityQueue<String>> map = new HashMap<String, PriorityQueue<String>>(); List<String> itinerary = new LinkedList<String>(); public List<String&

【问题描述】[中等]【解答思路】用哈希表/数组存储每个数字对应的所有可能的字母，然后进行回溯操作。回溯过程中维护一个字符串，表示已有的字母排列（如果未遍历完电话号码的所有数字，则已有的字母排列是不完整的）。该字符串初始为空。每次取电话号码的一位数字，从哈希表中获得该数字对应的所有可能的字母，并将其中的一个字母插入到已有的字母排列后面，然后继续处理电话号码的后一位数字，直到处理完电话号码中的所有数字，即得到一个完整的字母排列。然后进行回退操作，遍历其余的字母排列。回溯算法用于寻找所有的可行解，如果发

【问题描述】[中等]【解答思路】1. 二进制枚举 + 哈希复杂度class Solution { List<Integer> temp = new ArrayList<Integer>(); List<List<Integer>> ans = new ArrayList<List<Integer>>(); Set<Integer> set = new HashSet<Intege

【问题描述】[简单]【解答思路】1. 内置位计数功能时间复杂度：O(1) 空间复杂度：O(1)class Solution { public int hammingDistance(int x, int y) { return Integer.bitCount(x ^ y); }}2. 移位时间复杂度：O(1) 空间复杂度：O(1)class Solution { public int hammingDistance(int x,

【问题描述】[中等]【解答思路】1. 暴力逐位与 ，只需要判断i= 0 或 i == 2147483647 的话，就跳出 for 循环即可。时间复杂度：O(N) 空间复杂度：O(1)public int rangeBitwiseAnd(int m, int n) { //m 要赋值给 i，所以提前判断一下 if(m == Integer.MAX_VALUE){ return m; } int res = m; for (int i

【问题描述】[困难]【解答思路】回溯时间复杂度：O(1) 空间复杂度：O(1)class Solution { static final int TARGET = 24; static final double EPSILON = 1e-6; static final int ADD= 0,MULTIPLY=1,SUBTRACT = 2,DIVIDE= 3; public boolean judgePoint24(int[] nums

树1.树、二叉树2.二叉查找树3.平衡二叉树、红黑树4.递归树一、树1.树的常用概念根节点、叶子节点、父节点、子节点、兄弟节点，还有节点的高度、深度以及层数，树的高度。2.概念解释节点：树中的每个元素称为节点父子关系：相邻两节点的连线，称为父子关系根节点：没有父节点的节点叶子节点：没有子节点的节点父节点：指向子节点的节点子节点：被父节点指向的节点兄弟节点：具有相同父节点的多个节点称为兄弟节点关系节点的高度：节点到叶子节点的最长路径所包含的边数节点的深度：根节点到节点的路径所

【问题描述】[中等]【解答思路】1. 暴力首先明确如何判断一个字符串是否为回文字符串。第一个字符与最后一个字符相同，第二个字符与倒数第二个字符相同…关于中心位置轴对称。本题要求一共有多少个回文子串，那么就需要判断，索引[i, j]的子串是不是回文子串，遍历所有这样[i, j]进行判断就可以找到回文子串的总数。这是暴力的做法。首先如何判断[i, j]的子串是回文串，根据定义来判断即可。定义boolean isPalindrome(char[] chars, int start, int end)

【问题描述】[中等]【解答思路】1. 分治 快慢指针复杂度class Solution { public TreeNode sortedListToBST(ListNode head) { return buildTree(head, null); } public TreeNode buildTree(ListNode left, ListNode right) { if (left == right) { r

【问题描述】[简单]【解答思路】千万不要想复杂了 不是三维空间 是一维空间 ！本题要求将给定的二维数组中指定的「色块」染成另一种颜色。「色块」的定义是：直接或间接相邻的同色方格构成的整体。可以发现，「色块」就是被不同颜色的方格包围的一个同色岛屿。我们从色块中任意一个地方开始，利用广度优先搜索或深度优先搜索即可遍历整个岛屿。注意：当目标颜色和初始颜色相同时，我们无需对原数组进行修改。1. 广度优先搜索我们从给定的起点开始，进行广度优先搜索。每次搜索到一个方格时，如果其与初始位置的方格颜色相

【问题描述】[中等]【解答思路】其实就是深拷贝的一个实现，深拷贝就是对于所有的指针成员，不能仅仅是赋值，还有重新分配空间。深拷贝反应在本题中就是，所有的结点需要重新new出来，而不是直接赋值。整体的思路依然是dfs，跑遍原图中每个结点，然后根据原结点生成新结点。要注意的地方就是，因为图存在环，所以要标记访问过的结点，避免重复形成死循环：如果该结点已经被访问过，则不再遍历该结点，而是直接将指针值赋给自己邻接点数组----浅拷贝；如果该结点没有被访问过，则继续dfs遍历该结点，并将产生的新结点

【问题描述】[中等]【解答思路】1.时间复杂度：O(N^2) 空间复杂度：O(1)2.时间复杂度：O(N) 空间复杂度：O(1)【总结】1.2.3.转载

【问题描述】[困难]【解答思路】1. 递归 动态规划通俗易解的图 要把中间那块抽出来 单独递归2.时间复杂度：O(N) 空间复杂度：O(1)【总结】1.2.3.转载