LeetCode：“剑指 Offer”

刷题小菜鸡，花了几天时间做了一遍 LeetCode 上给出的 “剑指 Offer” 在此做一下记录

LeetCode主页：贤余超

剑指 Offer 03. 数组中重复的数字

  1. // 方法1：
  2. // hash表来做:空间换时间的思想
  3. // 时间复杂度 O(n)
  4. // 空间复杂度 O(n)
  5. public int findRepeatNumber(int[] nums) {
  6.     Set<Integer> hashset = new HashSet<>();
  8.     for(int i=0; i<nums.length; i++){
  9.         if(hashset.contains(Integer.valueOf(nums[i]))){
  10.             return nums[i];
  11.         }
  12.         hashset.add(Integer.valueOf(nums[i]));
  13.     }
  15.     return -1;
  16. }
  18. // 方法2：
  19. // 先排序再去比较
  20. // 时间复杂度 O(nlogn + n)
  21. // 空间复杂度 O(1)
  22. public int findRepeatNumber(int[] nums) {
  24.     Arrays.sort(nums);
  26.     for(int i=0; i<nums.length-1; i++){
  27.         if(nums[i] == nums[i+1]){
  28.             return nums[i];
  29.         }
  30.     }
  31.     return -1;
  32. }
  34. // 方法3：
  35. // 原地交换算法：一个萝卜对应一个坑
  36. // 时间复杂度：O(n)
  37. // 空间复杂度：O(1)
  38. public int findRepeatNumber(int[] nums) {
  39.     int tmp;
  41.     for(int i=0; i<nums.length; i++){
  42.         while(nums[i] != i){
  43.             if(nums[i] == nums[nums[i]]){
  44.                 return nums[i];
  45.             }
  46.             tmp = nums[i];
  47.             nums[i] = nums[tmp];
  48.             nums[tmp] = tmp;
  49.         }
  50.     }
  51.     return -1;
  52. }

剑指 Offer 04. 二维数组中的查找

  1. // 方法1：
  2. // 先来个暴力法
  3. // 时间复杂度：O(m*n)
  4. // 空间复杂度：O(1)
  5. public boolean findNumberIn2DArray(int[][] matrix, int target) {
  7.     for(int m=0; m<matrix.length; m++){
  8.         for(int n=0; n<matrix[m].length; n++){
  9.             if(target == matrix[m][n]){
  10.                 return true;
  11.             }
  12.         }
  13.     }
  15.     return false;
  16. }
  18. // 方法2：
  19. // 从右上角开始往左下角走，类似二叉搜索树，右上角为根节点
  20. // 时间复杂度：O(m+n)
  21. // 空间复杂度：O(1)
  22. public boolean findNumberIn2DArray(int[][] matrix, int target) {
  24.     if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
  25.         return false;
  26.     }
  28.     int rows = matrix.length, cols = matrix[0].length;
  29.     int row = 0, col = cols-1;  // 从右上角开始
  30.     while(row < rows && col >=0){
  31.         if(target == matrix[row][col]){
  32.             return true;
  33.         }else if(target < matrix[row][col]){
  34.             // 当前值大于target则往左边：左子树方向
  35.             col --;
  36.         }else{
  37.             // 当前值小于target则往右边：右子树方向
  38.             row ++;
  39.         }
  40.     }
  42.     return false;
  43. }

剑指 Offer 05. 替换空格

  1. // 方法1：正常解法
  2. // 时间复杂度：O(n)
  3. // 空间复杂度：O(n)
  4. public String replaceSpace(String s) {
  6.     StringBuffer sb = new StringBuffer();
  8.     for(int i=0; i<s.length(); i++){
  9.         char c = s.charAt(i);
  10.         if(c == ' '){
  11.             sb.append("%20");
  12.         }else{
  13.             sb.append(c);
  14.         }
  15.     }
  17.     return sb.toString();
  18. }
  20. // 方法2：库函数
  21. public String replaceSpace(String s) {
  22.     return s.replace(" ", "%20");
  23. }

剑指 Offer 06. 从尾到头打印链表

  1. // 方法1：两次遍历
  2. // 时间复杂度：O(2n)
  3. // 空间复制度：O(n)
  4. public int[] reversePrint(ListNode head) {
  6.     if(head == null){
  7.         return new int[0];
  8.     }
  10.  	// 第一次遍历
  11.     List<Integer> tmp = new ArrayList<>();
  12.     while(head != null){
  13.         tmp.add(head.val);
  14.         head = head.next;
  15.     }
  17.     // 第二次遍历
  18.     int[] res = new int[tmp.size()];
  19.     for(int i=tmp.size()-1, j=0; i>=0; i--){
  20.         res[j++] = tmp.get(i);
  21.     }
  23.     return res;
  24. }
  26. // 方法2：使用栈
  27. // 时间复杂度：O(n)
  28. // 空间复制度：O(n)
  29. public int[] reversePrint(ListNode head) {
  31.     Stack<Integer> stack = new Stack<>();
  33.     while(head != null){
  34.         stack.push(head.val);
  35.         head = head.next;
  36.     }
  38.     int[] res = new int[stack.size()];
  39.     int size = stack.size();
  40.     for(int i=0; i<size; i++){
  41.         res[i] = stack.pop();
  42.     }
  44.     return res;
  45. }
  47. // 方法3：递归，其实也是栈
  48. // 时间复杂度：O(n)
  49. // 空间复制度：O(n)
  50. List<Integer> tmp = new ArrayList<Integer>();
  52. public int[] reversePrint(ListNode head) {
  53.     recur(head);
  54.     int[] res = new int[tmp.size()];
  56.     for(int i = 0; i < res.length; i++){
  57.         res[i] = tmp.get(i);
  58.     }
  59.     return res;
  60. }
  62. private void recur(ListNode head) {
  63.     if(head == null) return;
  64.     // 递归调用
  65.     recur(head.next);
  66.     // 递归回来的时候加入，最后的一个节点最先到这里
  67.     tmp.add(head.val);
  68. }

剑指 Offer 07. 重建二叉树

树专题中对重建二叉树的题目有涉及

  1. // 复杂度分析：
  2. // 空间复杂度：建了一个hash表，递归过程中也需要空间 O(n)
  3. // 时间复杂度：还是相当于遍历了一棵树 O(n)
  4. // 加速inorder中对于的根节点的下标寻找
  5. private Map<Integer, Integer> indexMap;
  7. public TreeNode buildTree(int[] preorder, int[] inorder) {
  8.     // 前序遍历：[root [root.left] [root.right]]
  9.     // 中序遍历：[[root.left] root [root.right]]
  10.     if (preorder.length == 0 || inorder.length ==0 || preorder.length != inorder.length){
  11.         return null;
  12.     }
  14.     indexMap = new HashMap<>();
  16.     // 加速根据前序遍历中根节点在中序遍历的结果中找该节点的过程
  17.     for(int i=0; i<preorder.length; i++){
  18.         indexMap.put(inorder[i], i);
  19.     }
  21.     return helper(preorder, 0, preorder.length-1, inorder, 0, inorder.length-1);
  23. }
  25. private TreeNode helper(int[] preorder, int pre_s, int pre_e, int[] inorder, int in_s, int in_e){
  27.     if(pre_s > pre_e){
  28.         // 递归结束条件
  29.         return null;
  30.     }
  32.     // 很显然，前序遍历的第一个元素就是根节点
  33.     TreeNode root = new TreeNode(preorder[pre_s]);
  34.     // 找到根节点在中序遍历的位置，这样就能分左右子树了
  35.     int index = indexMap.get(preorder[pre_s]);
  37.     // 左子树的长度
  38.     int len = index  - in_s;
  39.     root.left = helper(preorder, pre_s+1, pre_s+len, inorder, in_s, index-1);
  40.     root.right = helper(preorder, pre_s+1+len, pre_e, inorder, index+1, in_e);
  42.     return root;
  43. }

剑指 Offer 09. 用两个栈实现队列

  1. // 复杂度分析：
  2. // 时间复杂度 入队：O(1)  出队：O(n)
  3. // 空间复杂度：O(n)
  4. LinkedList<Integer> stack1; // 入队都在这里
  5. LinkedList<Integer> stack2; // 出队的时候都从这里出
  7. public CQueue() {
  8.     // // stack1
  9.     // stack1 = new Stack<>();
  10.     // // stack2
  11.     // stack2 = new Stack<>();
  13.     // Stack能做的事LinkedList都能做
  14.     // stack1
  15.     stack1 = new LinkedList<>();
  16.     // stack2
  17.     stack2 = new LinkedList<>();
  18. }
  20. public void appendTail(int value) {
  21.     stack1.push(value);
  22. }
  24. public int deleteHead() {
  25.     // 弹出做特殊处理，都是从2弹出
  26.     if(stack2.isEmpty()){
  27.         // 当2为空，则把1中的全部给2
  28.         while(!stack1.isEmpty()){
  29.             stack2.push(stack1.pop());
  30.         }
  31.     }
  33.     if(stack2.isEmpty()){
  34.         return -1;
  35.     }else{
  36.         return stack2.pop();
  37.     }
  38. }

剑指 Offer 10- I. 斐波那契数列

  1. // 求余运算规则: (a+b)%c  --->  (a%c + b%c)%c
  2. // 时间复杂度：O(n)
  3. // 空间复杂度：O(1)
  4. public int fib(int n) {
  6.     if(n==0){
  7.         return 0;
  8.     }
  9.     if(n == 1){
  10.         return 1;
  11.     }
  13.     int a = 0, b = 1;
  14.     for(int i=2; i<=n; i++){
  15.         int tmp = b;
  16.         // 这里就相当于用了上面的公式
  17.         b = (a+b) % 1000000007;
  18.         a = tmp;
  19.     }
  21.     return b;
  22. }

剑指 Offer 10- II. 青蛙跳台阶问题

  1. // 和上一题基本一样，不做分析
  2. public int numWays(int n) {
  4.     if(n == 0 || n == 1){
  5.         return 1;
  6.     }
  8.     int a=1, b=1;
  9.     for(int i=2; i<=n; i++){
  10.         int tmp = b;
  11.         b = (a+b) % 1000000007;
  12.         a = tmp;
  13.     }
  15.     return b;
  16. }

剑指 Offer 11. 旋转数组的最小数字

  1. // 方法0：啊？这？
  2. // 时间复杂度：O(nlogn)
  3. // 空间复杂度：O(1)
  4. public int minArray(int[] numbers) {
  6.     if(numbers.length == 0){
  7.         return 0;
  8.     }
  9.     Arrays.sort(numbers);
  11.     return numbers[0];
  12. }
  14. // 正确解法：二分查找
  15. // 时间复杂度：O(logn)，但是由于后续使用了线性查找，最坏的情况下会到O(n)
  16. // 空间复杂度：O(1)
  17. public int minArray(int[] numbers) {
  19.     if(numbers.length <= 0){
  20.         return 0;
  21.     }
  23.     // 开始二分
  24.     int left = 0, right = numbers.length-1;
  25.     while(left <= right){
  26.         int mid = left + (right - left) / 2;
  28.         if(numbers[mid] > numbers[right]){
  29.             left = mid+1;
  30.         }else if(numbers[mid] < numbers[right]){
  31.             right = mid;
  32.         }else if(numbers[mid] == numbers[right]){
  33.             // 直接线性查找好了
  34.             return findMin(numbers, left, right);
  35.         }
  36.     }
  37.     return left >= numbers.length ? numbers[numbers.length-1] : numbers[left];
  38. }
  40. private int findMin(int[] numbers,int start,int end){
  41.     int result = numbers[start];
  42.     for(int i = start;i <= end;i++){
  43.         if (numbers[i] < result) result = numbers[i];
  44.     }
  45.     return result;
  46. }

剑指 Offer 12. 矩阵中的路径

  1. // dfs+回溯的思想
  2. // 时间复杂度: 不太好分析
  3. // 空间复杂度：即递归的深度，也不太好分析
  4. public boolean exist(char[][] board, String word) {
  6.     char[] words = word.toCharArray(); 
  8.     for(int i=0; i<board.length; i++){
  9.         for(int j=0; j<board[0].length; j++){
  10.             if(dfs(board, words, i, j, 0)) return true;
  11.         }
  12.     }
  14.     return false;
  15. }
  17. private boolean dfs(char[][] board, char[] words, int i, int j, int k){
  19.     if(i >= board.length || i < 0 || j >=board[0].length || j < 0 || board[i][j] != words[k]){
  20.         return false;
  21.     }
  23.     if(k == words.length - 1){
  24.         return true;
  25.     }
  27.     // 回溯：
  28.     // 到这里说明的是第k个已经相等了，接下来要判断第k+1个字符了
  29.     board[i][j] = '\0';  // 用于剪枝操作
  30.     boolean res = dfs(board, words, i+1, j, k+1) || dfs(board, words, i-1, j, k+1) ||
  31.         dfs(board, words, i, j+1, k+1) || dfs(board, words, i, j-1, k+1);
  32.     board[i][j] = words[k];
  33.     return res;
  34. }

剑指 Offer 13. 机器人的运动范围

  1. // 方法1：dfs+回溯思想
  2. // 时间复杂度 O(mn)
  3. // 空间复杂度:O(mn)
  4. public int movingCount(int m, int n, int k) {
  5.     boolean[][] visited = new boolean[m][n];
  6.     return dfs(visited, m, n, k, 0, 0);
  7. }
  9. private int dfs(boolean[][] visited, int m, int n, int k, int i, int j){
  10.     // 判断是否能到这个坐标
  11.     if(i >= m || j >= n || visited[i][j] || (bitSum(i) + bitSum(j) > k)) {
  12.         return 0;
  13.     }
  15.     // 能到这里，则继续向左边/下边走
  16.     visited[i][j] = true;
  17.     return dfs(visited, m, n, k, i+1, j) + dfs(visited, m, n, k, i, j+1) + 1;
  18. }
  20. private int bitSum(int n){
  22.     int sum = 0;
  23.     while(n != 0){
  24.         sum += n%10;
  25.         n /= 10;
  26.     }
  28.     return sum;
  29. }
  31. // 方法2：bfs
  32. // 时间复杂度 O(mn)
  33. // 空间复杂度:O(mn)
  34. public int movingCount(int m, int n, int k) {
  36.     boolean[][] visited = new boolean[m][n];
  37.     int res = 0;
  38.     // bfs求解
  39.     Queue<int[]> queue = new LinkedList<>();
  40.     // 坐标 i j  数位和: i的数位和  j的数位和
  41.     queue.add(new int[]{0, 0, 0, 0});
  43.     while(!queue.isEmpty()){
  44.         int[] point = queue.poll();
  45.         int i=point[0], j=point[1], s_i=point[2], s_j=point[3];
  46.         if( i>=m || j>=n || k<s_i+s_j || visited[i][j]){
  47.             continue;
  48.         }
  50.         visited[i][j] = true;
  51.         res ++;
  52.         queue.add(new int[]{i+1, j, bitSum(i+1), bitSum(j)});
  53.         queue.add(new int[]{i, j+1, bitSum(i), bitSum(j+1)});
  54.     }
  56.     return res;
  57. }
  59. private int bitSum(int n){
  61.     int sum = 0;
  62.     while(n != 0){
  63.         sum += n%10;
  64.         n /= 10;
  65.     }
  67.     return sum;
  68. }

剑指 Offer 14- I. 剪绳子

  1. // 动态规划：
  2. // 时间复杂度 O(n^2)
  3. // 空间复杂度:O(n)
  4. public int cuttingRope(int n) {
  6.     // 明确状态： d[i] 绳子长为i时的最大值
  7.     int[] dp = new int[n+1];
  9.     // base case
  10.     dp[0] = 0;  // 长度为0当然为0
  11.     dp[1] = 0;  // 长度为1时，不能切分
  13.     // 状态转移
  14.     for(int i=2; i<=n; i++){       // 状态1的转移：绳子的长度增大
  15.         for(int j=1; j<i; j++){    // 状态2的转移：把绳切成 i*(i-j)
  16.             int cut_more = dp[i-j] * j;  // i-j这段能切的最大值*j这段的最大值
  17.             int cut_two = (i-j) * j;     // 不继续切了，切成两段
  18.             dp[i] = Math.max(dp[i], Math.max(cut_more, cut_two));
  19.         }
  20.     }
  22.     return dp[n];
  23. }

剑指 Offer 14- II. 剪绳子 II

  1. // 和上一题不同，次数已经不能再使用动态规划了
  2. // 参考：Java贪心 思路讲解 —— fanhua
  3. // 最优：3  次优：2 等价于 4  最差：1
  4. // 结合公式：(x*y)%p = ((x%p) * (y%p))%p
  5. // 时间复杂度：O(n)
  6. // 空间复杂度：O(1)
  7. public int cuttingRope(int n) {
  9.     // base case
  10.     if(n == 2){
  11.         return 1;
  12.     }
  13.     if(n == 3){
  14.         return 2;
  15.     }
  17.     long res = 1;
  18.     while(n > 4){  // 每次都拆一个3，3是最优的情况
  19.         res = res * 3;
  20.         res %= 1000000007;
  21.         n -= 3;
  22.     }
  23.     // 最后还剩下长度4/2这种长度，直接乘上就行
  24.     return (int) (res * n % 1000000007);
  25. }

剑指 Offer 15. 二进制中1的个数

  1. // 方法1：与运算
  2. // 时间复杂度：O(n)
  3. // 空间复杂度：O(1)
  4. public int hammingWeight(int n) {
  6.     int ans = 1;  // 标志位
  7.     int res = 0;
  8.     for(int i=1; i<=32; i++){
  9.         if((n & ans) != 0){
  10.             res++;
  11.         }
  12.         ans = ans << 1;
  13.     }
  14.     return res;
  15. }
  17. // 方法2：另一种方式进行与运算
  18. // 时间复杂度：O(n)
  19. // 空间复杂度：O(1)
  20. public int hammingWeight(int n) {
  21.     int res = 0;
  22.     while(n != 0) {
  23.         res += n & 1;
  24.         // java中的无符号右移
  25.         n >>>= 1;
  26.     }
  27.     return res;
  28. }

剑指 Offer 16. 数值的整数次方

  1. // 方法1：暴力法
  2. // 直接超出时间限制.... 1.00000   2147483647
  3. // 时间复杂度：O(n)
  4. // 空间复杂度：O(1)
  5. public double myPow(double x, int n) {
  7.     double res = 1;
  8.     boolean flag = false;
  9.     if(n < 0){
  10.         flag = true;
  11.         n = -n;
  12.     }
  14.     for(int i=n; i>=1; i--){
  15.         res *= x;
  16.     }
  17.     if(flag){
  18.         res = 1/res;
  19.     }
  20.     return res;
  21. }
  23. // 快速幂算法：递归形式
  24. // 依靠了公式: 偶数：x^n = (x^2)^(n/2)  奇数：x^n = x(x^2)^(n/2)
  25. // 时间复杂度：O(logn)
  26. // 空间复杂度：O(1),这里忽略了递归占用的空间
  27. public double myPow(double x, int n) {
  28.     // 如果n等于0，直接返回1
  29.     if (n == 0)
  30.         return 1;
  31.     // 如果n小于0，把它改为正数，并且把1/x提取出来一个
  32.     // 这是因为最小值溢出的问题
  33.     if (n < 0)
  34.         return 1/x * myPow(1 / x, -n - 1);
  35.     // 根据n是奇数还是偶数来做不同的处理
  36.     return (n % 2 == 0) ? myPow(x * x, n / 2) : x * myPow(x * x, n / 2);
  37. }
  39. // 快速幂算法：迭代形式
  40. // 时间复杂度：O(logn)
  41. // 空间复杂度：O(1)
  42. public double myPow(double x, int n) {
  43.     double res = 1.0;
  44.     long t = n;
  45.     if(t < 0){
  46.         t = -t;
  47.     }
  48.     while(t > 0){
  49.         if(t % 2 == 1){
  50.             // 奇数的情况多*一个x
  51.             res *= x;
  52.         }
  53.         // 变为 x^2 , 则t就可以减半了
  54.         x *= x;
  55.         t /= 2;
  56.     }
  57.     return n < 0 ? 1.0 / res : res;
  58. }

剑指 Offer 17. 打印从1到最大的n位数

  1. // 不考虑大数问题时解题：
  2. // 时间复杂度：0(10^n)
  3. // 空间复杂度：0(1) 返回结果不计入
  4. public int[] printNumbers(int n) {
  5.     int max = 9;// 最大的n位数，最终肯定是n个9
  6.     for(int i=2; i<=n; i++){
  7.         max = max * 10;
  8.         max += 9;
  9.     }
  11.     // 打印出结果
  12.     int[] res = new int[max];
  13.     for(int i=1; i<=max; i++){
  14.         res[i-1] = i;
  15.     }
  17.     return res;
  18. }
  20. // 考虑大数问题解题：分析如下
  21. // 即当n较大时，max会超出int32的取值范围
  22. // 无论是什么类型，都会越界，因此使用String类型
  23. // 因此通过全排列的方式来组成数字，即回溯算法的思想
  24. // 时间复杂度：0(10^n)
  25. // 空间复杂度：0(10^n)
  27. // 代码：
  28. // 用于存储满足条件的字符串
  29. List<Integer> list;
  30. StringBuilder sb;
  32. public int[] printNumbers(int n) {
  34.     // 存储符合条件的'数'  '数'的类型是字符串
  35.     list = new ArrayList<>();  // 用LinkedList的最后一个案例会超时
  36.     sb = new StringBuilder();
  38.     // 这里进行回溯
  39.     dfs(n, 0);
  41.     int[] res = new int[list.size()];
  42.     // 存入数组
  43.     for (int i = 0; i < res.length; i++) {
  44.         res[i] = list.get(i);
  45.     }
  46.     return res;
  47. }
  49. private void dfs(int n, int index) {
  50.     // 递归结束的条件
  51.     if(index == n){
  52.         while (sb.length() != 0 && sb.charAt(0) == '0') {
  53.             // 将左边多余的0删除
  54.             sb.deleteCharAt(0);
  55.         }
  56.         // 将字符串形式的'数'，转化为整数
  57.         if(sb.length() != 0){
  58.             list.add(Integer.valueOf(sb.toString()));
  59.         }
  60.         return;
  61.     }
  63.     for(int j=0; j<10; j++){
  64.         // 深度搜索下一位
  65.         sb.append(j);
  66.         dfs(n, index + 1);
  67.         if(sb.length() != 0){
  68.             sb.deleteCharAt(sb.length() - 1);
  69.         }
  70.     }
  71. }

剑指 Offer 18. 删除链表的节点

  1. // 正常遍历：
  2. // 时间复杂度：0(n)
  3. // 空间复杂度：0(1)
  4. public ListNode deleteNode(ListNode head, int val) {
  6.     if(head == null){
  7.         return head;
  8.     }
  10.     // 特殊处理：头结点就是要删除的节点
  11.     if(head.val == val){
  12.         return head.next;
  13.     }
  15.     ListNode ans = new ListNode(-1);
  16.     ans.next = head;
  18.     while(head.next != null){
  19.         if(head.next.val == val){
  20.             head.next = head.next.next;
  21.             return ans.next;
  22.         }
  23.         head = head.next;
  24.     }
  26.     return ans.next;
  27. }

剑指 Offer 19. 正则表达式匹配

  1. // 方法1：递归
  2. public boolean isMatch(String s, String p) {
  4.     if(p.length() == 0){
  5.         return s.length() == 0;
  6.     }
  8.     // 匹配首位字符
  9.     boolean fist = false;
  10.     if(s.length() != 0){
  11.         char s1 = s.charAt(0);
  12.         char p1 = p.charAt(0);
  13.         fist = (s1 == p1);
  14.         if(p1 == '.'){
  15.             // . 在这里判断了
  16.             fist = true;
  17.         }
  18.     }
  20.     if(p.length() >= 2 && p.charAt(1) == '*'){
  21.         // 判断是否有*
  22.         return isMatch(s, p.substring(2, p.length())) ||
  23.                 (fist && isMatch(s.substring(1, s.length()), p));
  24.     }else{
  25.         return fist && isMatch(s.substring(1, s.length()), p.substring(1, p.length()));
  26.     }
  27. }
  29. // 方法2：上述方法的改进带个备忘录的dp
  30. int[][] cache;  // 0 没算过  1 为true -1 为false
  31. public boolean isMatch(String s, String p) {
  33.     cache = new int[s.length()+1][p.length()+1];
  35.     for(int i=0; i<=s.length(); i++){
  36.         for(int j=0; j<=p.length(); j++){
  37.             cache[i][j] = 0;
  38.         }
  39.     }
  41.     return dp(s, 0, p, 0);
  42. }
  44. private boolean dp(String s, int i, String p, int j){
  46.     if(cache[i][j] != 0){
  47.         return cache[i][j] == 1 ? true : false;
  48.     }
  50.     if(j == p.length()){
  51.         return i == s.length();
  52.     }
  54.     // 匹配首位字符
  55.     boolean fist = false;
  56.     if(i < s.length()){
  57.         fist = (s.charAt(i) == p.charAt(j));
  58.         if(p.charAt(j) == '.'){
  59.             fist = true;
  60.         }
  61.     }
  63.     boolean ans = false;
  64.     if(p.length() - j >= 2 && p.charAt(j+1) == '*'){
  65. 		ans = dp(s, i, p, j+2) ||          // 直接掉过*
  66.                 (fist && dp(s, i+1, p, j));  // 第一个字符是匹配的，则继续匹配任意多个
  67.     }else{
  68.         ans = fist && dp(s, i+1, p, j+1);
  69.     }
  71.     if(ans){
  72.         cache[i][j] = 1;
  73.     }else{
  74.         cache[i][j] = -1;
  75.     }
  77.     return ans;
  78. }

剑指 Offer 20. 表示数值的字符串

这种题目真的很烦人，直接看答案+CV的

  1. public boolean isNumber(String s) {
  2.     if(s == null || s.length() == 0){
  3.         return false;
  4.     }
  5.     // 标记是否遇到相应情况
  6.     boolean numSeen = false;
  7.     boolean dotSeen = false;
  8.     boolean eSeen = false;
  9.     // 去除空格转换为字符数组
  10.     char[] str = s.trim().toCharArray();
  11.     for(int i = 0;i < str.length; i++){
  12.         if(str[i] >= '0' && str[i] <= '9'){
  13.             // 出现数组了标记一下
  14.             numSeen = true;
  15.         }else if(str[i] == '.'){
  16.             // .之前不能出现.或者e
  17.             if(dotSeen || eSeen){
  18.                 return false;
  19.             }
  20.             dotSeen = true;
  21.         }else if(str[i] == 'e' || str[i] == 'E'){
  22.             // e之前不能出现e，必须出现数
  23.             if(eSeen || !numSeen){
  24.                 return false;
  25.             }
  26.             eSeen = true;
  27.             numSeen = false; // 重置numSeen，排除123e或者123e+的情况,确保e之后也出现数
  28.         }else if(str[i] == '-' || str[i] == '+'){
  29.             //+-出现在0位置或者e/E的后面第一个位置才是合法的
  30.             if(i != 0 && str[i-1] != 'e' && str[i-1] != 'E'){
  31.                 return false;
  32.             }
  33.         }else{//其他不合法字符
  34.             return false;
  35.         }
  36.     }
  37.     return numSeen;
  38. }

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

  1. // 方法1：暴力法
  2. // 时间空间复杂度：O(n)
  3. public int[] exchange(int[] nums) {
  5.     int[] res = new int[nums.length];
  6.     int left = 0, right = nums.length-1;
  7.     for(int i=0; i<nums.length; i++){
  8.         if(nums[i] % 2 == 0){
  9.             res[right] = nums[i];
  10.             right--;
  11.         }else{
  12.             res[left] = nums[i];
  13.             left++;
  14.         }
  15.     }
  16.     return res;
  17. }
  19. // 方法2：双指针
  20. // 时间复杂度：O(n)
  21. // 空间复杂度：O(1)
  22. public int[] exchange(int[] nums) {
  24.     int left = 0, right = nums.length-1;
  25.     while(left < right){
  26.         // 左指针向右遍历找到第一个偶数
  27.         while(nums[left]%2==1 && left < right){
  28.             left ++;
  29.         }
  31.         // 右指针向左遍历找到第一个奇数
  32.         while(nums[right]%2==0 && left < right){
  33.             right --;
  34.         }
  36.         // 交换左右指针指向的值
  37.         if(left < right){
  38.             int tmp = nums[left];
  39.             nums[left] = nums[right];
  40.             nums[right] = tmp;
  41.         }
  42.     }
  44.     return nums;
  45. }

剑指 Offer 22. 链表中倒数第k个节点

  1. // 快慢指针/双指针
  2. // 时间复杂度：O(n)
  3. // 空间复杂度：O(1)
  4. public ListNode getKthFromEnd(ListNode head, int k) {
  5.     if(head == null){
  6.         return null;
  7.     }
  9.     ListNode node1 = head;
  10.     ListNode node2 = head;
  11.     // 先让快指针走个k步
  12.     while(k-- != 0){
  13.         node1 = node1.next;
  14.     }
  16.     // 然后快慢指针一起走，当快指针走到头的时候，返回慢指针即可
  17.     while(node1 != null){
  18.         node2 = node2.next;
  19.         node1 = node1.next;
  20.     }
  22.     return node2;
  23. }

剑指 Offer 24. 反转链表

  1. // 正常迭代反转
  2. // 时间复杂度：O(n)
  3. // 空间复杂度：O(1)
  4. public ListNode reverseList(ListNode head) {
  5.     ListNode curr = head;
  6.     ListNode pre = null;
  7.     ListNode temp = null;
  9.     while(curr != null){
  10.         temp = curr.next;
  11.         curr.next = pre;
  12.         pre = curr;
  13.         curr = temp;
  14.     }
  15.     return pre;
  16. }

剑指 Offer 25. 合并两个排序的链表

  1. // 正常迭代反转
  2. // 时间复杂度：O(n)
  3. // 空间复杂度：O(1)
  4. public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
  6.     ListNode res = new ListNode(-1);
  7.     ListNode head = new ListNode(-1);
  8.     res = head;
  10.     while(l1 != null && l2 != null){
  12.         if(l1.val <= l2.val){
  13.             head.next = l1;
  14.             l1 = l1.next;
  15.         }else{
  16.             head.next = l2;
  17.             l2 = l2.next;
  18.         }
  20.         head = head.next;
  21.     }
  23.     // 口少口巴
  24.     head.next = l1==null ? l2 : l1;
  26.     return res.next;
  27. }

剑指 Offer 26. 树的子结构

  1. // 树专题中双递归的技巧
  2. // 时间复杂度：O(mn),其中m为A的节点数量，n为B的节点数量，每次都是以A作为根节点去匹配B数的n个节点
  3. // 空间复杂度：O(m) 最大递归深度
  4. public boolean isSubStructure(TreeNode A, TreeNode B) {
  6.     if(A==null || B==null){
  7.         return false;
  8.     }
  10.     // 递归遍历A树与B树进行判断
  11.     return dfs(A, B) || isSubStructure(A.left, B) || isSubStructure(A.right, B);
  12. }
  14. private boolean dfs(TreeNode A, TreeNode B){
  16.     if(A == null && B != null){
  17.         // A已经空了，B还有节点，很显然B不是A的子结构
  18.         return false;
  19.     }else if(B == null){
  20.         // B已经空了，A还有节点，能递归到这里，说明B是A的子结构
  21.         return true;
  22.     }else if(A.val != B.val){
  23.         // 值不同，那就不用看了，B必不是A的子结构
  24.         return false;
  25.     }
  26. 	// 继续迭代
  27.     return dfs(A.left, B.left) && dfs(A.right, B.right);
  28. }

剑指 Offer 27. 二叉树的镜像

  1. // bfs
  2. // 时间复杂度：O(n)
  3. // 空间复杂度：O(n)
  4. public TreeNode mirrorTree(TreeNode root) {
  6.     if(root == null){
  7.         return null;
  8.     }
  10.     Queue<TreeNode> queue = new LinkedList<>();
  11.     queue.offer(root);
  13.     while(!queue.isEmpty()){
  15.         int size = queue.size();
  16.         for(int i=0; i<size; i++){
  17.             TreeNode node = queue.poll();
  19.             if(node.right != null){
  20.                 queue.offer(node.right);
  21.             }
  23.             if(node.left != null){
  24.                 queue.offer(node.left);
  25.             }
  27.             // 这里反转一下就好了,自顶向下，
  28.             TreeNode tmp = node.left;
  29.             node.left = node.right;
  30.             node.right = tmp;
  31.         }
  32.     }
  34.     return root;
  35. }
  37. // dfs
  38. // 时间复杂度：O(n)，每个节点都还是要被遍历到
  39. // 空间复杂度：O(n)，递归所需的空间
  40. public TreeNode mirrorTree(TreeNode root) {
  41.     if(root == null){
  42.         return root;
  43.     }
  45.     // 借助个临时节点来避免覆盖后找不到左（右）节点
  46.     TreeNode tmp = root.left;
  47.     // 递归反转
  48.     root.left = mirrorTree(root.right);
  49.     root.right = mirrorTree(tmp);
  51.     return root;
  52. }

剑指 Offer 28. 对称的二叉树

  1. // bfs：建立两个队列
  2. // 时间复杂度：O(n)
  3. // 空间复杂度：O(2n)，这里建立了两个队列
  4. public boolean isSymmetric(TreeNode root) {
  6.     if(root == null){
  7.         return true;
  8.     }
  10.     // 从左到右层序遍历
  11.     Queue<TreeNode> queue1 = new LinkedList<>();
  12.     // 从右到左层序遍历
  13.     Queue<TreeNode> queue2 = new LinkedList<>();
  14.     queue1.offer(root);
  15.     queue2.offer(root);
  17.     while(!queue1.isEmpty()){
  19.         int size1 = queue1.size();
  20.         int size2 = queue2.size();
  21.         if(size1 != size2){
  22.             return false;
  23.         }
  25.         for(int i=0; i<size1; i++){
  26.             TreeNode node1 = queue1.poll();
  27.             TreeNode node2 = queue2.poll();
  29.             if(node1 == null && node2 == null){
  30.                 continue;
  31.             }
  33.             // 对每个节点进行比较
  34.             if((node1 == null && node2 != null)||
  35.                 (node2 == null && node1 != null)||
  36.                 (node1.val != node2.val)){
  37.                 return false;
  38.             }
  40.             queue1.offer(node1.left);
  41.             queue1.offer(node1.right);
  43.             queue2.offer(node2.right);
  44.             queue2.offer(node2.left);
  45.         }
  46.     }
  48.     return true;
  49. }
  51. // dfs：
  52. // 时间复杂度：O(n)
  53. // 空间复杂度：O(n)，递归消耗
  54. public boolean isSymmetric(TreeNode root) {
  55.     if (root == null)
  56.         return true;
  57.     // 1.明确：递归的函数要干什么？
  58.     // 函数的作用是判断传入的两个树是否镜像
  59.     // 输入：TreeNode left, TreeNode right
  60.     // 输出：是：true，不是：false
  61.     return helper(root.left, root.right);
  62. }
  64. public boolean helper(TreeNode root1, TreeNode root2) {
  65.     // 2.明确：递归停止的条件是什么
  66.     if (root1 == null && root2 == null){
  67.         // 左节点和右节点都为空 -> 倒底了都长得一样 ->true
  68.         return true;
  69.     }
  70.     if (root1 == null || root2 == null){
  71.         // 左节点为空的时候右节点不为空，或反之 -> 长得不一样-> false
  72.         return false;
  73.     }
  74.     if (root1.val != root2.val){
  75.         // 左右节点值不相等 -> 长得不一样 -> false
  76.         return false;
  77.     }
  78.     // 3.明确：从某层到下一层的关系是什么
  79.     // 要想两棵树镜像，那么一棵树左边的左边要和二棵树右边的右边镜像，一棵树左边的右边要和二棵树右边的左边镜像
  80.     // 调用递归函数传入左左和右右 调用递归函数传入左右和右左
  81.     // 只有左左和右右镜像且左右和右左镜像的时候，我们才能说这两棵树是镜像的
  82.     return helper(root1.left, root2.right) && helper(root1.right, root2.left);
  83. }

剑指 Offer 29. 顺时针打印矩阵

  1. // 直接遍历,最好画图理解一下这个过程
  2. // 时间复杂度：O(m*n)
  3. // 空间复杂度：O(1)
  4. public int[] spiralOrder(int[][] matrix) {
  6.     if(matrix == null || matrix.length == 0 || matrix[0].length == 0){
  7.         return new int[0];
  8.     }
  10.     // 存储当前最外层的边界,从最外层开始遍历，每遍历完最外层就对下面的参数修改
  11.     int rows = matrix.length-1, cols = matrix[0].length-1, row = 0, col = 0;
  12.     int size = (rows+1)*(cols+1);
  13.     int[] res = new int[size];
  15.     int index = 0;
  16.     while(row <= rows && cols <= cols){
  18.         // 上
  19.         for(int i=col; i <= cols; i++){
  20.             res[index++] = matrix[row][i];
  21.             // 元素个数相同，则无需再遍历了，直接返回
  22.             if(index == size) return res;
  23.         }
  25.         // 右
  26.         for(int i=row+1; i<=rows; i++){
  27.             res[index++] = matrix[i][cols];
  28.             if(index == size) return res;
  29.         }
  31.         // 下
  32.         for(int i=cols-1; i>=col; i--){
  33.             res[index++] = matrix[rows][i];
  34.             if(index == size) return res;
  35.         }
  37.         // 左
  38.         for(int i=rows-1; i>row; i--){
  39.             res[index++] = matrix[i][col];
  40.             if(index == size) return res;
  41.         }
  43.         // 遍历完最外层就修改下面的参数，开始遍历内层
  44.         row++; col++; rows--; cols--;
  46.     }
  48.     return res;
  49. }

剑指 Offer 30. 包含min函数的栈

  1. // 题目要求的是调用 min、push 及 pop 的时间复杂度都是 O(1)
  2. class MinStack {
  4.     /** initialize your data structure here. */
  5.     Stack<Integer> stack1, stack2;
  6.     public MinStack() {
  7.         // 这里建立两个栈来实现 min 为O(1)的复杂度
  8.         stack1 = new Stack<>();
  9.         stack2 = new Stack<>();
  10.     }
  12.     public void push(int x) {
  13. 		// 栈1存储的是正常的元素
  14.         stack1.push(x);
  15.         // 栈2专门存储最小元素
  16.         if(stack2.isEmpty() || x <= stack2.peek()){
  17.             // 设法维护好 栈B的元素，使其保持非严格降序
  18.             stack2.push(x);
  19.         }
  20.     }
  22.     public void pop() {
  23.         // 栈1弹出元素的时候，若栈2的元素相同也需要弹出
  24.         if(stack1.pop().equals(stack2.peek())){
  25.             stack2.pop();
  26.         }
  27.     }
  29.     public int top() {
  30.         // 栈1存储的是正常的元素
  31.         return stack1.peek();
  32.     }
  34.     public int min() {
  35.         // 栈2专门存储最小元素
  36.         return stack2.peek();
  37.     }
  38. }

剑指 Offer 31. 栈的压入、弹出序列

  1. // 复杂度分析：
  2. // 时间：O(n)
  3. // 空间：O(n)
  4. public boolean validateStackSequences(int[] pushed, int[] popped) {
  6.     // Stack<Integer> stack = new Stack<>();
  7.     // Java里面所有和栈相关的操作都应该用Deque，避免使用Stack
  8.     Deque<Integer> stack = new LinkedList<>();
  10.     // 判断合不合法，用个栈试一试
  11.     int pop_index = 0;
  12.     for(int i=0; i<pushed.length; i++){
  13.         // 压栈是顺序是固定的
  14.         stack.push(pushed[i]);
  15.         // 当栈顶的元素和此时出栈序列的元素相同时，则出栈
  16.         while(!stack.isEmpty() && stack.peek() == popped[pop_index]){
  17.             stack.pop();
  18.             pop_index ++;
  19.         }
  20.     }
  22.     // 最后更具栈是否为空来判断出栈序列是否合法
  23.     if(stack.isEmpty()){
  24.         return true;
  25.     }else{
  26.         return false;
  27.     }
  28. }

剑指 Offer 32 - I. 从上到下打印二叉树

  1. // 标准的层序遍历
  2. // 时间复杂度：O(n)
  3. // 空间复杂度：O(n)
  4. public int[] levelOrder(TreeNode root) {
  6.     if(root == null){
  7.         return new int[0];
  8.     }
  10.     List<Integer> res = new ArrayList<>();
  11.     Queue<TreeNode> queue = new LinkedList<>();
  12.     queue.offer(root);
  14.     while(!queue.isEmpty()){
  16.         int size = queue.size();
  17.         for(int i=0; i<size; i++){
  18.             TreeNode node = queue.poll();
  20.             res.add(node.val);
  22.             if(node.left != null){
  23.                 queue.offer(node.left);
  24.             }
  25.             if(node.right != null){
  26.                 queue.offer(node.right);
  27.             }
  28.         }
  29.     }
  31.     int[] ans = new int[res.size()];
  32.     for(int i=0; i<res.size(); i++){
  33.         ans[i] = res.get(i);
  34.     }
  35.     return ans;
  36. }

剑指 Offer 32 - II. 从上到下打印二叉树 II

  1. // 和上一题一样的层序遍历
  2. public List<List<Integer>> levelOrder(TreeNode root) {
  4.     List<List<Integer>> res = new LinkedList<>();
  5.     if(root == null){
  6.         return res;
  7.     }
  8.     Queue<TreeNode> queue = new LinkedList<>();
  9.     queue.offer(root);
  11.     while(!queue.isEmpty()){
  13.         int size = queue.size();
  14.         List<Integer> oneLayer = new LinkedList<>();
  15.         for(int i=0; i<size; i++){
  16.             TreeNode node = queue.poll();
  18.             oneLayer.add(node.val);
  20.             if(node.left != null){
  21.                 queue.offer(node.left);
  22.             }
  23.             if(node.right != null){
  24.                 queue.offer(node.right);
  25.             }
  26.         }
  27.         res.add(oneLayer);
  28.     }
  29.     return res;
  30. }

剑指 Offer 32 - III. 从上到下打印二叉树 III

  1. // 方法1：bfs
  2. // 时间复杂度：O(n)
  3. // 空间复杂度：O(n)
  4. public List<List<Integer>> levelOrder(TreeNode root) {
  6.     List<List<Integer>> res = new LinkedList<>();
  7.     if(root == null){
  8.         return res;
  9.     }
  10.     Queue<TreeNode> queue = new LinkedList<>();
  11.     queue.offer(root);
  12.     boolean flag = true;
  14.     while(!queue.isEmpty()){
  15.         int size = queue.size();
  16.         List<Integer> oneLayer = new LinkedList<>();
  17.         for(int i=0; i<size; i++){
  18.             TreeNode node = queue.poll();
  20.             oneLayer.add(node.val);
  21.             if(node.left != null){
  22.                 queue.offer(node.left);
  23.             }
  24.             if(node.right != null){
  25.                 queue.offer(node.right);
  26.             }
  27.         }
  28.         // 区分一下层,做到之字形的效果
  29.         if(flag){
  30.             res.add(oneLayer);
  31.         }else{
  32.             List<Integer> tmp = new LinkedList<>();
  33.             for(int i=oneLayer.size()-1; i>=0; i--){
  34.                 tmp.add(oneLayer.get(i));
  35.             }
  36.             res.add(tmp);
  37.         }
  38.         flag = !flag;
  39.     }
  40.     return res;
  41. }
  43. // 方法2：双端队列
  44. // 时间复杂度：O(n)
  45. // 空间复杂度：O(n)
  46. public List<List<Integer>> levelOrder(TreeNode root) {
  48.     List<List<Integer>> res = new LinkedList<>();
  49.     if(root == null){
  50.         return res;
  51.     }
  52.     Queue<TreeNode> queue = new LinkedList<>();
  53.     queue.offer(root);
  54.     boolean flag = true;
  56.     while(!queue.isEmpty()){
  57.         int size = queue.size();
  58.         // 使用双端队列
  59.         LinkedList<Integer> oneLayer = new LinkedList<>();
  60.         for(int i=0; i<size; i++){
  61.             TreeNode node = queue.poll();
  62. 			// 在这里分辨层
  63.             if(flag){
  64.                 // add == addLast 添加到队尾
  65.                 oneLayer.add(node.val);
  66.             }else{
  67.                 oneLayer.addFirst(node.val);
  68.             }
  69.             if(node.left != null){
  70.                 queue.offer(node.left);
  71.             }
  72.             if(node.right != null){
  73.                 queue.offer(node.right);
  74.             }
  75.         }
  76.         res.add(oneLayer);
  77.         flag = !flag;
  78.     }
  79.     return res;
  80. }

剑指 Offer 33. 二叉搜索树的后序遍历序列

  1. // dfs递归解题：后续遍历有 [[root.left][root.right]root]
  2. // 时间复杂度：O(n^2) 递归深度n，递归函数中还要进行左右子树的判断
  3. // 空间复杂度：O(n) n为数的节点个数，递归的深度
  4. public boolean verifyPostorder(int[] postorder) {
  6.     return dfs(postorder, 0, postorder.length-1);
  7. }
  9. private boolean dfs(int[] postorder, int s, int e){
  11.     if(s>=e){
  12.         // 单节点
  13.         return true;
  14.     }
  15. 	// 找到二叉搜索树的根节点
  16.     int root = postorder[e];
  18.     // 左子树树的跨度
  19.     int left_index = s;
  20.     while(postorder[left_index] < root) left_index++;
  21.     // 右子树的跨度
  22.     int right_index = left_index;
  23.     while(postorder[right_index] > root) right_index++;
  25.     // 判断：最终左子树+右子树的长度是否满足二叉搜索树
  26.     if(right_index != e){
  27.         return false;
  28.     }
  29.     // 递归判断左子树是否有效
  30.     boolean left = dfs(postorder, s, left_index-1);
  31.     // 递归判断右子树是否有效
  32.     boolean right = dfs(postorder, left_index, e-1);
  34.     return left && right;
  35. }

剑指 Offer 34. 二叉树中和为某一值的路径

  1. // 正常的dfs/回溯思想
  2. // 时间复杂度：O(n)
  3. // 空间复杂度：O(n)
  4. List<List<Integer>> res;
  5. public List<List<Integer>> pathSum(TreeNode root, int sum) {
  6.     res = new LinkedList<>();
  7.     if(root == null){
  8.         return res;
  9.     }
  11.     List<Integer> path = new LinkedList<>();
  12.     dfs(root, sum, path, 0);
  14.     return res;
  16. }
  18. private void dfs(TreeNode root, int sum, List<Integer> path, int target){
  20.     if(root==null){
  21.         return;
  22.     }
  24.     // 叶子节点
  25.     if(root.left == null && root.right == null){
  26.         if(target+root.val == sum){
  27.             // 满足一个路径
  28.             path.add(root.val);
  29.             List<Integer> tmp = new LinkedList(path);
  30.             res.add(tmp);
  31.             path.remove(path.size()-1);
  32.         }
  33.         return;
  34.     }
  36.     // 非叶子节点
  37.     target += root.val;
  38.     path.add(root.val);
  39.     dfs(root.left, sum, path, target);
  40.     dfs(root.right, sum, path, target);
  41.     path.remove(path.size() - 1);
  43. }

剑指 Offer 35. 复杂链表的复制

  1. // 方法1：建立一个hash表，两次遍历完成复制
  2. // 时间复杂度：O(2n)
  3. // 空间复杂度：O(2n)
  4. public Node copyRandomList(Node head) {
  6.     // 虚拟头
  7.     Node ans = new Node(-1);
  8.     ans.next = head;
  10.     Node tmp;
  11.     // node1: 原节点  node2：新节点
  12.     HashMap<Node, Node> hashMap = new HashMap<>();
  13. 	// 第一次遍历链表，记录节点
  14.     while(head != null){
  15.         tmp = new Node(head.val);
  16.         hashMap.put(head, tmp);
  17.         head = head.next;
  18.     }
  20.     // 在第二次遍历，完成新链表的指向操作
  21.     head = ans.next;
  22.     while(head != null){
  23.         // 拿出新的节点
  24.         tmp = hashMap.get(head);
  25.         // next指针的指向
  26.         tmp.next = hashMap.get(head.next);
  27.         // 随机指针的指向
  28.         tmp.random = hashMap.get(head.random);
  29.         head = head.next;
  30.     }
  32.     return hashMap.get(ans.next);
  33. }
  35. // 方法2：原地操作，出去必要的输出占用，只占用常量级别的空间
  36. // 时间复杂度：O(n)
  37. // 空间复杂度：O(1) 除去必要的输出
  38. public Node copyRandomList(Node head) {
  40.     if(head == null){
  41.         return head;
  42.     }
  44.     // 虚拟头
  45.     Node ans = new Node(-1);
  46.     ans.next = head;
  48.     // 将拷贝节点放到原节点后面
  49.     // 例如1->2->3这样的链表就变成了这样1->1'->2->2'->3->3'
  50.     while(head != null){
  51.         Node tmp = new Node(head.val);
  52.         tmp.next = head.next;
  53.         head.next = tmp;
  54.         head = tmp.next;
  55.     }
  57.     // 把拷贝节点的random指针安排上
  58.     head = ans.next;
  59.     while(head != null){
  60.         if(head.random != null){
  61.             head.next.random = head.random.next;
  62.         }
  63.         head = head.next.next;
  64.     }
  66.     // 分离拷贝节点和原节点，变成1->2->3和1'->2'->3'两个链表，后者就是答案
  67.     head = ans.next;
  68.     Node res = new Node(-1);  // 需要返回的虚拟头
  69.     res.next = head.next;
  70.     while(head != null){
  71.         Node tmp = head.next.next;
  72.         if (tmp == null){
  73.             // 到末尾了，但还是要回复原链表最后一个节点指向的null
  74.             head.next = tmp;
  75.             break;
  76.         }
  77.         // 修改新链表的指向
  78.         head.next.next = tmp.next;
  79.         // 恢复原链表的指向
  80.         head.next = tmp;
  81.         // 向后遍历原连表，继续断开接上
  82.         head = tmp;
  83.     }
  85.     return res.next;
  86. }

剑指 Offer 36. 二叉搜索树与双向链表

  1. // 复杂度分析：
  2. // 时间：O(n)
  3. // 空间：O(n)
  4. Node head, pre;
  5. public Node treeToDoublyList(Node root) {
  6.     if(root == null) return root;
  8.     // dfs递归修改指向
  9.     dfs(root);
  11.     // 进行头节点和尾节点的相互指向
  12.     head.left = pre;
  13.     pre.right = head;
  15.     return head;
  16. }
  18. private void dfs(Node root){
  20.     if(root==null) return;
  21.     // 递归遍历树的左节点
  22.     dfs(root.left);
  23.     // 二叉搜索树中序遍历是有序的，处理中间节点，左边的比你小，右边的比你大
  24.     if(pre == null){
  25.         // pre用于记录双向链表中位于root左侧的节点，即上一次迭代中的root,当pre==null时，root左侧没有节点,即此时root为双向链表中的头节点
  26.         // 第一次遍历到最左节点，记录此时的root为head
  27.         head = root;
  28.     }else{
  29.         // 反之，pre!=null时，root左侧存在节点pre，需要进行pre.right=root的操作。
  30.         pre.right = root;
  31.     }
  33.     // 这里只需要指明left即可
  34.     root.left = pre;
  35.     // 更新pre
  36.     pre = root;
  37.     // 递归遍历树的右节点
  38.     dfs(root.right);
  39. }

剑指 Offer 37. 序列化二叉树

  1. // 复杂度分析：
  2. // 序列化： 层序遍历时间，空间复杂度都为O(n)
  3. // 反序列化： 还是遍历的所有的节点且用到了队列，空间复杂度都为O(n)
  4. public class Codec {
  6.     // Encodes a tree to a single string.
  7.     public String serialize(TreeNode root) {
  9.         StringBuilder sb = new StringBuilder();
  10.         if(root == null){
  11.             return null;
  12.         }
  14.         sb.append("[");
  16.         // 层序遍历
  17.         Queue<TreeNode> queue = new LinkedList<>();
  18.         queue.offer(root);
  20.         while(!queue.isEmpty()){
  21.             int size = queue.size();
  23.             for(int i=0; i<size; i++){
  24.                 TreeNode node = queue.poll();
  26.                 if(node == null){
  27.                     sb.append("null,");
  28.                     continue;
  29.                 }else{
  30.                     sb.append(node.val + ",");
  31.                 }
  33.                 queue.offer(node.left);
  34.                 queue.offer(node.right);
  35.             }
  36.         }
  38.         String substring = sb.substring(0, sb.length() - 1);
  39.         substring = substring + "]";
  41.         return substring;
  43.     }
  45.     // Decodes your encoded data to tree.
  46.     public TreeNode deserialize(String data) {
  48.         if(data == null){
  49.             return null;
  50.         }
  52.         String s_data = data.substring(1, data.length() - 1);
  53.         String[] datas = s_data.split(",");
  55.         Queue<TreeNode> queue = new ArrayDeque<>();
  56.         TreeNode root = new TreeNode(Integer.parseInt(datas[0]));
  57.         queue.offer(root);
  59. 		// 第一次做的时候用了两个指针，其实一个指针就行了，更加简洁明了
  60.         int index = 1;
  61.         while(!queue.isEmpty()){
  62.             TreeNode node = queue.poll();
  64.             if(!datas[index].equals("null")){
  65.                 node.left = new TreeNode(Integer.parseInt(datas[index]));
  66.                 queue.offer(node.left);
  67.             }
  68.             index++;
  70.             if(!datas[index].equals("null")){
  71.                 node.right = new TreeNode(Integer.parseInt(datas[index]));
  72.                 queue.offer(node.right);
  73.             }
  74.             index++;
  75.         }
  76.         return root;
  77.     }
  78. }
  80. // Your Codec object will be instantiated and called as such:
  81. // Codec codec = new Codec();
  82. // codec.deserialize(codec.serialize(root));

剑指 Offer 38. 字符串的排列

  1. // 一个经典的回溯问题
  2. // 时间复杂度：O(n!) n为字符串长度，n*(n-1)*(n-2)*...*1
  3. // 空间复杂度：O(n^2)
  4. List<String> res = new LinkedList<>();
  5. boolean[] visited;
  6. public String[] permutation(String s) {
  8.     char[] chars = s.toCharArray();
  9.     // 排序一下后面好剪枝
  10.     Arrays.sort(chars);
  11.     StringBuilder track = new StringBuilder();
  12.     visited = new boolean[s.length()];
  14.     backtrack(chars, track);
  16.     // 输出
  17.     return res.toArray(new String[res.size()]);
  18. }
  20. private void backtrack(char[] chars, StringBuilder track){
  22.     // 触发结束条件
  23.     if(track.length() == chars.length){
  24.         res.add(track.toString());
  25.         return;
  26.     }
  28.     for(int i=0; i<chars.length; i++){
  29.         // 排除不合法的选择，当有重复的字符串出现时，不允许先访问后面再访问前面
  30.         if(visited[i] || (i>0 && chars[i] == chars[i-1] && !visited[i-1])){
  31.             continue;
  32.         }
  34.         // 前序：做选择
  35.         visited[i] = true;
  36.         track.append(chars[i]);
  37.         // 进入下一层决策树
  38.         backtrack(chars, track);
  39.         // 后序：取消选择
  40.         track.deleteCharAt(track.length() - 1);
  41.         visited[i] = false;
  42.     }
  43. }

剑指 Offer 39. 数组中出现次数超过一半的数字

  1. // 方法1：直接hash表
  2. // 时间复杂度：O(n)
  3. // 空间复杂度：O(n/2)
  4. public int majorityElement(int[] nums) {
  6.     Map<Integer, Integer> map = new HashMap<>();
  8.     for(int i=0; i<= nums.length; i++){
  10.         map.put(Integer.valueOf(nums[i]), map.getOrDefault(Integer.valueOf(nums[i]), 0) + 1);
  12.         if(map.get(Integer.valueOf(nums[i])) > nums.length/2){
  13.             return nums[i];
  14.         }
  15.     }    
  17.     return -1;
  18. }
  20. // 解法2：排序取中位数
  21. // 排序算法时间复杂度O(nlogn)，
  22. // 空间复杂度O(1)
  23. public int majorityElement(int[] nums) {
  25.     Arrays.sort(nums);
  27.     return nums[nums.length/2];
  28. } 
  30. // 解法3：摩尔投票法
  31. // 也可以理解成混战极限一换一，不同的两者一旦遇见就同归于尽，最后活下来的值都是相同的，即要求的结果
  32. // 时间复杂度O(n)，空间复杂度O(1)
  33. public int majorityElement(int[] nums) {
  34.     int res = 0, count = 0;
  35.     for(int i=0; i<nums.length; i++){
  36.         if(count == 0){
  37.             // 假设当前的数为众数，给你投票后续让你去火拼
  38.             res = nums[i];
  39.             count++;
  40.         }else{
  41.             if(res == nums[i]) count++;  // 票数增加
  42.             else count--;  // 抵消
  43.         }
  44.     }
  45.     // 最终一定是票数大于一半的获胜
  46.     return res;
  47. }

剑指 Offer 40. 最小的k个数

  1. // 方法1：固定堆：大顶堆，固定一个大小为k的大顶堆可以快速求出第k小的数
  2. // 时间复杂度: O(nlog k)
  3. // 空间复杂度：O(k)
  4. public int[] getLeastNumbers(int[] arr, int k) {
  6.     if(arr.length <= 0 || k == 0){
  7.         return new int[0];
  8.     }
  10.     // 建立大顶堆：固定大小为k，
  11.     PriorityQueue<Integer> maxHeap = new PriorityQueue<>(3, (a, b) -> b-a);
  13.     for(int i=0; i<arr.length; i++){
  14.         if(maxHeap.size() < k){
  15.             maxHeap.offer(arr[i]);
  16.             continue;
  17.         }
  19.         if(maxHeap.peek() > arr[i]){
  20.             maxHeap.poll();
  21.             maxHeap.offer(arr[i]);
  22.         }
  23.     }
  25.     int size = maxHeap.size();
  26.     int[] res = new int[size];
  27.     for(int i=0; i<size; i++){
  28.         res[i] = maxHeap.poll();
  29.     }
  31.     return res;
  32. }
  34. // 方法2：快排，用了https://www.cnblogs.com/zhuchengchao/p/14403781.html中快排的代码
  35. // 时间复杂度：根据已经分好的数组与k比较，其实能到O(k)的
  36. // 空间复杂度：原地排序O(1)
  37. public int[] getLeastNumbers(int[] arr, int k) {
  39.     if(arr.length == 0 || k == 0){
  40.         return new int[0];
  41.     }
  43.     // 最后一个参数表示我们要找的是下标为k-1的数
  44.     return quickSort(arr, 0, arr.length-1, k-1);
  45. }
  47. private int[] quickSort(int[] nums, int start, int end, int k){
  48.     int j = partition(nums, start, end);
  49.     if(k == j){
  50.         // 已经到达个数了 返回即可
  51.         return Arrays.copyOf(nums, j + 1);
  52.     }
  53.     // 优化在此，根据下标j与k的大小关系来决定继续切分左段还是右段
  54.     if (j > k){
  55.         // 对分区左侧进行快排
  56.         return quickSort(nums, start, j-1, k);
  57.     }else{
  58.         // 对分区右侧进行快排
  59.         return quickSort(nums, j+1, end, k);
  60.     }
  62. }
  64. // 快排切分，返回下标pivotIndex
  65. // 使得比nums[pivotIndex]小的数都在pivotIndex的左边，比nums[pivotIndex]大的数都在pivotIndex的右边。
  66. private static int partition(int[] nums, int begin, int end){
  67.     // 默认数组中待分区区间的最后一个是 pivot 元素
  68.     int	pivot = nums[end];
  69.     // 定义分区后 pivot 元素的下标
  70.     int pivotIndex = begin;
  71.     for(int i=begin; i<end; i++){
  72.         // 判断如果该区间内如果有元素小于 pivot 则将该元素从区间头开始一直向后填充 有点类似选择排序
  73.         if(nums[i] < pivot){
  74.             if(i > pivotIndex){
  75.                 // 交换元素
  76.                 swap(nums, i, pivotIndex);
  77.             }
  78.             pivotIndex++;
  79.         }
  80.     }
  81.     swap(nums, pivotIndex, end);
  82.     return pivotIndex;
  83. }
  85. // 交换数组内下标为 i j 的两个元素
  86. private static void swap(int[] nums,int i,int j){
  87.     int temp = nums[j];
  88.     nums[j] = nums[i];
  89.     nums[i] = temp;
  90. }
  92. // 方法3：数据范围有限时可以用计数排序：O(N)
  93. public int[] getLeastNumbers(int[] arr, int k) {
  95.     if(k == 0 || arr.length == 0){
  96.         return new int[0];
  97.     }
  99.     // 统计每个数字出现的次数
  100.     // arr[i]的范围是0~10000
  101.     int[] counter = new int[10001];
  102.     for(int num: arr){
  103.         counter[num] ++;
  104.     }
  106.     // 根据counter数组从头找出k个数作为返回结果
  107.     int[] res = new int[k];
  108.     int index = 0;
  109.     for(int i=0; i<counter.length; i++){
  110.         while(counter[i]-- > 0 && index < k){
  111.             res[index++] = i;
  112.         }
  113.         if(index == k){
  114.             break;
  115.         }
  116.     }
  118.     return res;
  119. }

剑指 Offer 41. 数据流中的中位数

  1. class MedianFinder {
  3.     // 建立两个堆，一个小顶堆 一个大顶堆
  4.     private Queue<Integer> minHeap, maxHeap;
  5.     /** initialize your data structure here. */
  6.     public MedianFinder() {
  7.         // 建立两个堆，一个大顶堆，一个小顶堆，只需要平衡两者的大小即可
  8.         // 大顶堆中放入 (n+1)/2 个小元素，栈顶就是第(n+1)/2小的元素
  9.         // 小顶堆中放入 (n+1)/2 个大元素，栈顶就是第(n+1)/2大的元素
  10.         minHeap = new PriorityQueue<>();
  11.         maxHeap = new PriorityQueue<>((a, b) -> b-a);
  12.     }
  14.     public void addNum(int num) {
  16.         // 两个堆之间的元素是需要平衡的
  17.         // 保证：大顶堆中的元素个数 >= 小顶堆中的元素个数，且最多相差一个元素
  18.         maxHeap.offer(num);
  19.         minHeap.offer(maxHeap.poll());
  20.         if(maxHeap.size() < minHeap.size()){
  21.             maxHeap.offer(minHeap.poll());
  22.         }
  23.     }
  25.     public double findMedian() {
  27.         if(maxHeap.size() == minHeap.size()){
  28.             // 偶数情况下的中位数
  29.             return (maxHeap.peek() + minHeap.peek()) / 2.0;
  30.         }else{
  31.             // 计数情况下的中位数
  32.             return maxHeap.peek();
  33.         }
  34.     }
  35. }

剑指 Offer 42. 连续子数组的最大和

  1. // 经典动态规划
  2. // 时间复杂度：O(n)
  3. // 空间复杂度：O(n)，是可以降为O(1)的，将dp数组修改为两个变量即可
  4. public int maxSubArray(int[] nums) {
  5. 	// 明确状态，dp[i]在包含第nums[i]时的最大情况
  6.     int[] dp = new int[nums.length + 1];
  8.     // base case
  9.     dp[0] = 0;
  10.     int res = nums[0];
  11. 	// 状态转移
  12.     for(int i=1; i<=nums.length; i++){
  13.         // 继承 / 另辟蹊径
  14.         dp[i] = Math.max(nums[i-1], dp[i-1] + nums[i-1]);
  15.         res = Math.max(res, dp[i]);
  16.     }
  18.     return res;
  19. }

剑指 Offer 43. 1～n 整数中 1 出现的次数

这种题目真的很烦人，直接看答案+CV的；

这题其实也是动态规划类型的题目吧，解答中是有明确的状态转移方程的

  1. // 参考了题解中：xujunyi的答案
  2. public int countDigitOne(int n) {
  3.     return helper(n);
  4. }
  6. private int helper(int n){
  7.     if(n <= 0){
  8.         return 0;
  9.     }
  11.     String s = String.valueOf(n);
  12.     int high = s.charAt(0) - '0';
  13.     int pow = (int) Math.pow(10, s.length() - 1);
  14.     int last = n - high*pow;
  15.     if(high == 1){
  16.         return helper(pow-1) + (last+1) + helper(last);
  17.     }else{
  18.         return pow + high*helper(pow-1) + helper(last);
  19.     }
  20. }

剑指 Offer 44. 数字序列中某一位的数字

先空着吧

剑指 Offer 45. 把数组排成最小的数

  1. // 这个排序很巧妙，万万没想到还能这么玩
  2. // 时间复杂度：O(NlogN)
  3. // 空间复杂度：O(n), strs需要额外的空间
  4. public String minNumber(int[] nums) {
  6.     String[] strs = new String[nums.length];
  7.     for(int i=0; i<nums.length; i++){
  8.         strs[i] = String.valueOf(nums[i]);
  9.     }
  10. 	// 对string组成的字符串进行排序，是从小到大的排序顺序
  11.     // 例如："30" + "3" < "3" + "30"
  12.     // 则，把 “30” 放到 “3" 前面
  13.     Arrays.sort(strs, (o1, o2) -> (o1+o2).compareTo(o2+o1));
  15.     StringBuilder res = new StringBuilder();
  17.     for(String s: strs){
  18.         res.append(s);
  19.     }
  21.     return res.toString();
  22. }

剑指 Offer 46. 把数字翻译成字符串

  1. // 动态规划解题
  2. // 时间空间复杂度都为O(n)
  3. public int translateNum(int num) {
  5.     if(num == 0){
  6.         // 特殊处理一下
  7.         return 1;
  8.     }
  10.     // 把num修改为nums数组，便于后续操作
  11.     List<Integer> lists = new ArrayList<>();
  12.     while(num != 0){
  13.         lists.add(num%10);
  14.         num /= 10;
  15.     }
  16.     int[] nums = new int[lists.size()];
  17.     for(int i=0; i<lists.size(); i++){
  18.         nums[i] = lists.get(lists.size()-i-1);
  19.     }
  21.     int n = nums.length;
  22.     // 明确状态: dp[i] 当有i个字符时可能的组合数
  23.     int[] dp = new int[n+1];
  25.     // base case
  26.     dp[0] = 1;
  27.     if(nums[0] >=0 && nums[0] <= 25){
  28.         dp[1] = 1;
  29.     }else{
  30.         return 0;
  31.     }
  33.     // 开始状态转移
  34.     for(int i=2; i<=n; i++){
  36.         // 当前的数字能否转换成字符
  37.         int one = nums[i-1];
  38.         if(one >=0 && one <= 25){
  39.             dp[i] += dp[i-1];
  40.         }
  42.         // 当前的字符和上一个字符能否转换成字符
  43.         int two = nums[i-2] * 10 + nums[i-1];
  44.         if(nums[i-2] != 0 && two >=0 && two <= 25){
  45.             dp[i] +=  dp[i-2];
  46.         }
  47.     }
  49.     return dp[n];
  50. }

剑指 Offer 47. 礼物的最大价值

  1. // 基础的动态规划题
  2. // 时间/空间复杂度：O(m*n)
  3. public int maxValue(int[][] grid) {
  5.     int m = grid.length;
  6.     int n = grid[0].length;
  8.     // 明确状态:  dp[i][j] 就是在ij位置时的最大礼物价值
  9.     int[][] dp = new int[m][n];
  11.     // base case: 只有一行/只有一列的情况下
  12.     dp[0][0] = grid[0][0];
  13.     for(int i=1; i<m; i++){
  14.         dp[i][0] = dp[i-1][0] + grid[i][0];
  15.     }
  16.     for(int j=1; j<n; j++){
  17.         dp[0][j] = dp[0][j-1] + grid[0][j];
  18.     }
  20.     // 开始状态转移
  21.     for(int i=1; i<m; i++){
  22.         for(int j=1; j<n; j++){
  23.             // 状态转移方程
  24.             dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]) + grid[i][j];
  25.         }
  26.     }
  28.     return dp[m-1][n-1];
  29. }

剑指 Offer 48. 最长不含重复字符的子字符串

  1. // 滑动窗口解题
  2. // 时间/空间复杂度：O(n)
  3. public int lengthOfLongestSubstring(String s) {
  5.     // 定义窗口，窗口中包含了出现过的字符
  6.     Map<Character, Integer> window = new HashMap<>();
  8.     int left = 0, right = 0, len = 0;
  9.     while(right < s.length()){
  10.         // c 是将移入窗口的字符
  11.         char c = s.charAt(right);
  13.         // 进行窗口内数据的一系列更新
  14.         if(window.getOrDefault(c, 0) < 1){
  15.             // 没有重复的时候的情况：右移窗口
  16.             right++;
  17.             window.put(c, window.getOrDefault(c, 0)+1);
  18.             // 动态获取最长长度
  19.             if(right - left > len){
  20.                 len = right - left;
  21.             }
  22.         }else{
  23.             // 一旦出现重复的时候：开始移左窗口
  24.             char d = s.charAt(left);
  25.             left++;
  26.             window.put(d, window.get(d) - 1);
  27.         }
  28.     }
  30.     return len;
  31. }

剑指 Offer 49. 丑数

  1. // 方法1：直接上个小顶堆完事
  2. // 空间复杂度：O(3n)
  3. // 时间复杂度：O(nlogn)
  4. public int nthUglyNumber(int n) {
  6.     // 建立一个最小堆，每次都从堆中弹出最小的那个元素 * 2 3 5后入堆
  7.     PriorityQueue<Long> minHeap = new PriorityQueue<>();
  8.     // int有案例过不了
  9.     long res = 1;
  10.     minHeap.offer(res);
  11.     for(int i=0; i<n; i++){
  13.         res = minHeap.poll();
  15.         while(!minHeap.isEmpty() && res == minHeap.peek()){
  16.             // 为了删除重复的元素，如2*3  3*2 就重复了
  17.             minHeap.poll();
  18.         }
  19.         minHeap.offer(res*2);
  20.         minHeap.offer(res*3);
  21.         minHeap.offer(res*5);
  22.     }
  23.     return (int)res;
  24. }
  26. // 方法2：三指针法
  27. // 空间复杂度：O(n)
  28. // 时间复杂度：O(1)
  29. public int nthUglyNumber(int n) {
  31.     int[] reuslt = new int[n];
  33.     reuslt[0] = 1;
  35.     // 定义三个指针
  36.     int p1=0, p2=0, p3=0;
  37.     for(int i=1; i<n; i++){
  39.         reuslt[i] = Math.min(reuslt[p1]*2, Math.min(reuslt[p2]*3, reuslt[p3]*5));
  41.         if(reuslt[i] == reuslt[p1]*2) p1++;
  42.         if(reuslt[i] == reuslt[p2]*3) p2++;
  43.         if(reuslt[i] == reuslt[p3]*5) p3++;
  44.     }
  46.     return reuslt[n-1];
  47. }

剑指 Offer 50. 第一个只出现一次的字符

  1. // 方法1：好家伙我直接就是hash表
  2. // 时间复杂度：O(2n)
  3. // 空间复杂度：O(n)
  4. public char firstUniqChar(String s) {
  6.     Map<Character, Integer> map = new HashMap<>();
  8.     for(char c: s.toCharArray()){
  9.         map.put(c, map.getOrDefault(c, 0) + 1);
  10.     }
  12.     for(char c: s.toCharArray()){
  13.         if(map.get(c) == 1){
  14.             return c;
  15.         }
  16.     }
  17.     return ' ';
  18. }
  20. // 方法2：优化方式1：
  21. // 时间复杂度：O(2n)
  22. // 空间复杂度：O(26)
  23. public char firstUniqChar(String s) {
  25.     if (s.equals("")) return ' ';
  27.     // 创建‘a'-'z'的字典
  28.     int[] target = new int[26];
  30.     // 第一次遍历，将字符统计到字典数组
  31.     for (int i = 0; i < s.length(); i++) {
  32.         target[s.charAt(i) - 'a']++;
  33.     }
  35.     // 第二次遍历，从字典数组获取次数
  36.     for (int i = 0; i < s.length(); i++) {
  37.         if (target[s.charAt(i) - 'a'] == 1) return s.charAt(i);
  38.     }
  40.     return ' ';
  41. }
  43. // 优化方式2：
  44. // 时间复杂度：O(2n)
  45. // 空间复杂度：O(26)
  46. public char firstUniqChar(String s) {
  47.     // key:字符  value:标记其是否出现过
  48.     Map<Character, Boolean> dic = new LinkedHashMap<>();
  49.     char[] sc = s.toCharArray();
  50.     for(char c : sc){
  51.         // 这里的逻辑很巧妙，只要出现过2次及以上就是false
  52.         dic.put(c, !dic.containsKey(c));
  53.     } 
  55.     for(Map.Entry<Character, Boolean> d : dic.entrySet()){
  56.         if(d.getValue()) return d.getKey();
  57.     }
  58.     return ' ';
  59. }

剑指 Offer 51. 数组中的逆序对

就很烦

  1. // 回溯：组合问题  虽然超出时间限制，但还是贴一下吧
  2. // 时间复杂度：O(n^2)
  3. // 空间复杂度：O(n^2), 应...该递归的深度和时间复杂度差不多的吧...
  4. int count = 0;
  5. public int reversePairs(int[] nums) {
  7.     if(nums.length <= 1){
  8.         return 0;
  9.     }
  11.     List<Integer> track = new LinkedList<>();
  12.     backtrack(nums, track, 0);
  13.     return count;
  14. }
  16. private void backtrack(int[] nums, List<Integer> track, int index){
  18.     if(track.size() == 2){
  19.         if(track.get(0) > track.get(1)){
  20.             // 满足逆序的条件
  21.             count++;
  22.         }
  23.         return;
  24.     }
  26.     for(int i=index; i<nums.length; i++){
  27.         // 剪枝
  28.         if(index>0 && nums[index-1] < nums[i]){
  29.             continue;
  30.         }
  31.         track.add(nums[i]);
  32.         backtrack(nums, track, i+1);
  33.         track.remove(track.size() - 1);
  34.     }
  35. }
  37. // 正确解法：
  38. // 分治算法:归并排序
  39. // 时间复杂度：O(nlogn), 归并排序的时间复杂度
  40. // 空间复杂度：O(n)
  41. int count = 0;
  42. public int reversePairs(int[] nums) {
  43.     mergeSort(nums);
  44.     return count;
  45. }
  47. private int[] mergeSort(int[] arr){
  48.     if(arr.length < 2){
  49.         return arr;
  50.     }
  51.     // 将数组从中间拆分成左右两部分
  52.     int mid = arr.length/2;
  53.     int[] left = Arrays.copyOfRange(arr, 0, mid);
  54.     int[] right = Arrays.copyOfRange(arr, mid, arr.length);
  55.     return merge(mergeSort(left), mergeSort(right));
  56. }
  58. // 合并两个有序数组并返回新的数组
  59. private int[] merge(int[] left, int[] right){
  60.     // 创建一个新数组,长度为两个有序数组的长度之和
  61.     int[] newArray = new int[left.length+right.length];
  62.     // 定义两个指针,分别代表两个数组的下标
  63.     int lindex = 0;
  64.     int rindex = 0;
  65.     for(int i=0; i<newArray.length;i++){
  66.         // 归并的过程
  67.         if(lindex >= left.length){
  68.             newArray[i] = right[rindex++];
  69.         }else if(rindex >= right.length){
  70.             newArray[i] = left[lindex++];
  71.         }else if(left[lindex] > right[rindex]){
  72.             newArray[i] = right[rindex++];
  73.             // ☆☆☆只有这里有区别☆☆☆
  74.             // 当左边的数组大于时右边的值时，表示左区间lindex及之后的数都将大于rindex指向的数，所以出现了left.length - lindex个逆序对
  75.             count += left.length - lindex;
  76.         }else{
  77.             newArray[i] = left[lindex++];
  78.         }
  79.     }
  80.     return newArray;
  81. }

剑指 Offer 52. 两个链表的第一个公共节点

  1. // 方法1：暴力解法：hash表 走一波
  2. // 空间时间复杂度都是 O(n)
  3. public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
  5.     Set<ListNode> set = new HashSet<>();
  7.     while(headA != null){
  8.         set.add(headA);
  9.         headA = headA.next;
  10.     }
  12.     while(headB != null){
  13.         if(set.contains(headB)){
  14.             return headB;
  15.         }
  16.         headB = headB.next;
  17.     }
  19.     return null;
  20. }
  22. // 方法2：双指针法，浪漫相遇，看呆了
  23. // 贴一个骚评论：两个结点不断的去对方的轨迹中寻找对方的身影，只要二人有交集，就终会相遇
  24. // 时间复杂度：O(n)
  25. // 空间复杂度：O(1)
  26. public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
  27.     ListNode h1 = headA, h2 = headB;
  29.     while(h1 != h2){
  30.         h1 = h1 == null ? headB : h1.next;
  31.         h2 = h2 == null ? headA : h2.next;
  32.     }
  34.     return h1;
  35. }

剑指 Offer 53 - I. 在排序数组中查找数字 I

  1. // 方法1：暴力法
  2. // 时间复杂度：O(n)
  3. // 空间复杂度：O(1)
  4. public int search(int[] nums, int target) {
  6.     int res = 0;
  7.     for(int i=0; i<nums.length; i++){
  8.         if(nums[i] == target){
  9.             res ++;
  10.         }
  11.     }
  13.     return res;
  14. }
  16. // 方法2：二分法所搜左右边界，主要给了这个数组是排序的这个条件
  17. // 时间复杂度：O(logn)
  18. // 空间复杂度：O(1)
  19. public int search(int[] nums, int target) {
  21.     int left_index = 0, right_index = 0;
  23.     // 找左边界
  24.     int left = 0, right = nums.length-1;
  25.     while(left <= right){
  26.         int mid = left + (right-left)/2;
  27.         if(nums[mid] < target){
  28.             left = mid+1;
  29.         }else if(nums[mid] > target){
  30.             right = mid-1;
  31.         }else if(nums[mid] == target){
  32.             // 别返回，锁定左侧边界
  33.             right = mid - 1;
  34.         }
  35.     }
  36.     // 最后要检查 left 越界的情况
  37.     if (left >= nums.length || nums[left] != target)
  38.         return 0;
  39.     left_index = left;
  41.     // 找右侧边界
  42.     left = 0;
  43.     right = nums.length - 1;
  44.     while (left <= right) {
  45.         int mid = left + (right - left) / 2;
  46.         if (nums[mid] < target) {
  47.             left = mid + 1;
  48.         } else if (nums[mid] > target) {
  49.             right = mid - 1;
  50.         } else if (nums[mid] == target) {
  51.             // 别返回，锁定右侧边界
  52.             left = mid + 1;
  53.         }
  54.     }
  55.     // 最后要检查 right 越界的情况
  56.     if (right < 0 || nums[right] != target)
  57.         return 0;
  58.     right_index = right;
  60.     // 最后返回长度即可
  61.     return right_index - left_index + 1;
  62. }

剑指 Offer 53 - II. 0～n-1中缺失的数字

  1. // 方法1：暴力法，顺序遍历
  2. // 时间复杂度：O(n)
  3. // 空间复杂度：O(1)
  4. public int missingNumber(int[] nums) {
  6.     for(int i=0; i<nums.length; i++){
  7.         if(nums[i] != i){
  8.             return i;
  9.         }
  10.     }
  12.     return nums[nums.length-1] + 1;
  13. }
  15. // 方法2：二分法
  16. // 时间复杂度：O(logn)
  17. // 空间复杂度：O(1)
  18. public int missingNumber(int[] nums) {
  20.     int left = 0, right = nums.length - 1;
  21.     while (left <= right) {
  22.         int mid = left + (right - left) / 2;
  24.         if(nums[mid] == mid){
  25.             left = mid+1;
  26.         }else{
  27.             right = mid-1;
  28.         }
  29.     }
  30.     return left;
  31. }

剑指 Offer 54. 二叉搜索树的第k大节点

  1. // 方法1：第k大的节点：动态极值，用固定k大小的最小堆
  2. // 时间复杂度：O(n), 遍历每一个节点
  3. // 空间复杂度：O(k) 没有算递归的消耗
  4. PriorityQueue<Integer> minHeap;
  5. public int kthLargest(TreeNode root, int k) {
  7.     if(root == null){
  8.         return 0;
  9.     }
  10. 	// 小顶堆k尺寸，找第K大的值
  11.     minHeap = new PriorityQueue<>();
  12.     dfs(root, k);
  14.     return minHeap.peek();
  15. }
  17. private void dfs(TreeNode root, int k){
  19.     if(root == null){
  20.         return;
  21.     }
  23.     if(minHeap.size() < k){
  24.         minHeap.offer(root.val);
  25.     }else if(minHeap.peek()<root.val){
  26.         minHeap.poll();
  27.         minHeap.offer(root.val);
  28.     }
  30.     dfs(root.left, k);
  31.     dfs(root.right, k);
  32. }
  34. // 方法2：利用二叉搜索树的中序遍历是有序的这个性质
  35. // 时间复杂度：O(n), 遍历每一个节点
  36. // 空间复杂度：O(n)
  37. public int kthLargest(TreeNode root, int k) {
  39.     List<Integer> res = new ArrayList<>();
  41.     dfs(root, res);
  43.     return res.get(res.size() - k);
  44. }
  46. private void dfs(TreeNode root, List<Integer> res){
  47.     if(root == null){
  48.         return;
  49.     }
  51.     dfs(root.left, res);
  52.     res.add(root.val);
  53.     dfs(root.right, res);
  54. }
  56. // 方法3：二叉搜索树的中序遍历优化: 逆序遍历 “右中左” 的顺序
  57. // 时间复杂度：O(k)  k <= n(树节点)
  58. // 空间复杂度：O(k)
  59. int ans = 0, count=0;
  60. public int kthLargest(TreeNode root, int k) {
  62.     dfs(root, k);
  64.     return ans;
  65. }
  67. private void dfs(TreeNode root, int k){
  68.     if(root == null){
  69.         return;
  70.     }
  72.     dfs(root.right, k);
  73.     if(++count == k){
  74.         ans = root.val;
  75.         return;
  76.     }
  77.     dfs(root.left, k);
  78. }

剑指 Offer 55 - I. 二叉树的深度

  1. // 正常的dfs即可
  2. // 时间复杂度：O(n)
  3. // 空间复杂度：O(1)  没有算递归的消耗
  4. public int maxDepth(TreeNode root) {
  6.     if(root == null){
  7.         return 0;
  8.     }
  10.     return dfs(root, 1);
  11. }
  13. private int dfs(TreeNode root, int layer){
  15.     if(root == null){
  16.         return layer-1;
  17.     }
  19.     int left_layer = dfs(root.left, layer+1);
  20.     int right_layer = dfs(root.right, layer+1);
  22.     return Math.max(left_layer, right_layer);
  23. }
  25. // 优化写法，其实可以一行代码解决的
  26. public int maxDepth(TreeNode root) {
  27.     return root == null ?
  28.         0 : Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
  29. }

剑指 Offer 55 - II. 平衡二叉树

  1. // 和上一题一样，dfs计算左右子树的深度
  2. // 时间复杂度：O(n)
  3. // 空间复杂度：O(1)  没有算递归的消耗
  4. boolean res = true;
  5. public boolean isBalanced(TreeNode root) {
  7.     if(root == null){
  8.         return true;
  9.     }
  11.     dfs(root, 0);
  13.     return res;
  14. }
  16. private int dfs(TreeNode root, int depth){
  18.     if(!res){
  19.     	// 剪枝
  20.         return -1;
  21.     }
  23.     if(root == null){
  24.         return depth - 1;
  25.     }
  27.     int left_depth = dfs(root.left, depth+1);
  28.     int right_depth = dfs(root.right, depth+1);
  30.     if(Math.abs(left_depth - right_depth) > 1){
  31.         res = false;
  32.         return -1;
  33.     }
  35.     return Math.max(left_depth, right_depth);
  36. }

剑指 Offer 56 - I. 数组中数字出现的次数

  1. // 方法1：排序,但是时间复杂度不满足要求
  2. // 时间复杂度：O(nlogn)
  3. // 空间复杂度：O(1)
  4. public int[] singleNumbers(int[] nums) {
  6.     Arrays.sort(nums);
  8.     int[] res = new int[2];
  9.     int index = 0;
  10.     if(nums[0] != nums[1]){
  11.         res[index++] = nums[0];
  12.     }
  13.     if(nums[nums.length-1] != nums[nums.length-2]){
  14.         res[index++] = nums[nums.length-1];
  15.     }
  16.     for(int i=1; i<nums.length-1; i++){
  18.         if(index == 2){
  19.             break;
  20.         }
  21.         if(nums[i] != nums[i+1] && nums[i] != nums[i-1]){
  22.             res[index++] = nums[i];
  23.         }
  24.     }
  26.     return res;
  27. }
  29. // 方法2：位运算: 参考了题解中eddieVim的解答
  30. // 时间复杂度：O(n)
  31. // 空间复杂度：O(1)
  32. public int[] singleNumbers(int[] nums) {
  34.     // 用于将所有的数异或起来
  35.     int k = 0;
  37.     for(int num: nums) {
  38.         // 相同的数都抵消掉了，只有两个不同的数，最终的为k为1的位置就是不同处
  39.         k ^= num;
  40.     }
  42.     // 获得k中最低位的1，以此为依据将nums分为两组
  43.     int mask = 1;
  44.     while((k & mask) == 0) {
  45.         mask <<= 1;
  46.     }
  48.     int a = 0;
  49.     int b = 0;
  50.     for(int num: nums) {
  51.         // 更具mask分成了两组数据，两个不同数会被分到不同的组中
  52.         // 而相同的数会被分到同一组中，并且在异或后会被抵消的即变为0
  53.         // 又有0异或任何数就是该数本身
  54.         if((num & mask) == 0) {
  55.             // 找第一个数
  56.             a ^= num;
  57.         } else {
  58.             // 找第二个数
  59.             b ^= num;
  60.         }
  61.     }
  63.     return new int[]{a, b};
  64. }

剑指 Offer 56 - II. 数组中数字出现的次数 II

  1. // 论位运算的巧妙
  2. // 时间复杂度：O(32n)
  3. // 空间复杂度：O(1)
  4. public int singleNumber(int[] nums) {
  6.     int res = 0;
  7.     for(int i=0; i<32; i++){
  8.         int mask = 1 << i;
  9.         int cnt = 0;
  10.         for(int j=0; j<nums.length; j++){
  11.             if((nums[j] & mask) != 0){
  12.                 // 这个位置上的值是1
  13.                 cnt++;
  14.             }
  15.         }
  17.         if(cnt % 3 != 0){
  18.             // 一个数字出现3遍，如果这个位置是1，则%3就没了
  19.             // 只有出现1次的数字若是1则能保存下来，若是0那就是0没有区别
  20.             res |= mask;
  21.         }
  22.     }
  24.     return res;
  25. }

剑指 Offer 57. 和为s的两个数字

  1. // 递增数列：双指针完事
  2. // 时间复杂度：O(n)
  3. // 空间复杂度：O(1)
  4. public int[] twoSum(int[] nums, int target) {
  6.     if(nums.length < 2){
  7.         return new int[0];
  8.     }
  10.     int left = 0;
  11.     int right = nums.length - 1;
  13.     while(left < right){
  14.         if(nums[left] + nums[right] == target){
  15.             return new int[]{nums[left], nums[right]};
  16.         }else if(nums[left] + nums[right] > target){
  17.             right --;
  18.         }else{
  19.             left ++;
  20.         }
  21.     }
  23.     return new int[0];
  24. }

剑指 Offer 57 - II. 和为s的连续正数序列

  1. // 暴力前缀和数组：超出时间限制 24 / 32
  2. // 时间复杂度：O(n^2)
  3. // 空间复杂度：O(n)
  4. public int[][] findContinuousSequence(int target) {
  6.     List<List<Integer>> res = new LinkedList<>();
  8.     int len = target/2 + 1;
  9.     // 数组
  10.     int[] nums = new int[len];
  11.     // 数组的前缀和
  12.     int[] preSum = new int[len+1];
  13.     preSum[0] = 0;
  14.     for(int i=0; i<len; i++){
  15.         nums[i] = i+1;
  16.         preSum[i+1] = preSum[i] + nums[i];
  17.     }
  19.     for(int i=0; i<len; i++){
  20.         for(int j=i+1; j<len; j++){
  21.             if(preSum[j+1] - preSum[i] == target){
  22.                 List tmp = new ArrayList<>();
  23.                 for(int k=i; k<=j; k++){
  24.                     tmp.add(nums[k]);
  25.                 }
  26.                 res.add(tmp);
  27.             }
  28.         }
  29.     }
  31.     int[][] ans = new int[res.size()][];
  32.     for(int i=0; i<res.size(); i++){
  33.         ans[i] = new int[res.get(i).size()];
  34.         for(int j=0; j<res.get(i).size(); j++){
  35.             ans[i][j] = res.get(i).get(j);
  36.         }
  37.     }
  38.     return ans;
  39. }
  41. // 正确解法：滑动窗口
  42. // 时间复杂度：O(target)
  43. // 空间复杂度：O(1)
  44. public int[][] findContinuousSequence(int target) {
  46.     List<int[]> res = new LinkedList<>();
  48.     int left = 1, right = 1;
  49.     int sum = 0;
  50.     while(right <= target/2+1){
  51.         // 右移窗口
  52.         sum += right;
  53.         right++;
  55.         while(sum > target){
  56.             // 左移窗口
  57.             sum -= left;
  58.             left++;
  59.         }
  61.         if(sum == target){
  62.             // 条件满足，存储结果
  63.             int[] tmp = new int[right - left];
  64.             for(int i=left; i<right; i++){
  65.                 tmp[i-left] = i;
  66.             }
  67.             res.add(tmp);
  68.         }
  69.     }
  71.     int[][] ans = new int[res.size()][];
  72.     for(int i=0; i<res.size(); i++){
  73.         if(res.get(i).length <= 1){
  74.             continue;
  75.         }
  76.         ans[i] = res.get(i);
  77.     }
  79.     return ans;
  80. }

剑指 Offer 58 - I. 翻转单词顺序

  1. // 直接库函数
  2. public String reverseWords(String s) {
  3.     // 删除首尾空格
  4.     s = s.trim();
  5.     // 直接按照空格分隔字符串
  6.     String[] words = s.split(" ");
  8.     StringBuilder res = new StringBuilder();
  9.     for(int i=words.length-1; i>=0; i--){
  10.         if(words[i].equals("")){
  11.             continue;
  12.         }
  13.         res.append(words[i]+" ");
  14.     }
  16.     return res.toString().trim();
  17. }
  19. // 正常解法：双指针
  20. // 空间复杂度：O(n)
  21. // 时间复杂度：O(n)
  22. public String reverseWords(String s) {
  23.     // 删除首尾空格
  24.     s = s.trim();
  25.     int n = s.length();
  26.     StringBuilder res = new StringBuilder();
  28.     int left = n-1, right = n-1, index = 0;
  29.     while(left >= 0){
  30.         while(left >= 0 && s.charAt(left) != ' ') left--;  // 搜索首个空格
  31.         res.append(s.substring(left+1, right+1)+" ");       // 添加单词
  32.         while(left >= 0 && s.charAt(left) == ' ') left --;  // 跳过单词间空格
  33.         // 更新右指针
  34.         right = left;
  36.     }
  38.     return res.toString().trim();
  39. }

剑指 Offer 58 - II. 左旋转字符串

  1. // 暴力做法
  2. // 时间复杂度 O(n)
  3. // 空间复杂度 O(N)
  4. public String reverseLeftWords(String s, int n) {
  6.     int len = s.length();
  7.     char[] res = new char[len];
  9.     for(int i=0; i<len; i++){
  10.         if(i<n){
  11.             res[len - n + i] = s.charAt(i);
  12.         }else{
  13.             res[i-n] = s.charAt(i);
  14.         }
  15.     }
  17.     return new String(res);
  18. }

剑指 Offer 59 - I. 滑动窗口的最大值

  1. // 方法1：暴力法
  2. // 时间复杂度 O(n*k)
  3. // 空间复杂度 O(1)  除去必要的输出
  4. public int[] maxSlidingWindow(int[] nums, int k) {
  6.     if(nums.length == 0){
  7.         return new int[0];
  8.     }
  10.     int left = 0, right = k-1;
  11.     int res[] = new int[nums.length - k + 1];
  13.     while(right < nums.length){
  15.         res[left] = nums[left];
  16.         for(int i=left; i<=right; i++){
  17.             res[left] = Math.max(res[left], nums[i]);
  18.         }
  20.         left++; right++;
  21.     }
  23.     return res;
  24. }
  26. // 方法2：单调队列，还是需要画图理解，看的K神的讲解
  27. // 时间复杂度 O(n)
  28. // 空间复杂度 O(k)
  29. public int[] maxSlidingWindow(int[] nums, int k) {
  31.     if(nums.length <= 0){
  32.         return new int[0];
  33.     }
  35.     int[] res = new int[nums.length - k + 1];
  36.     // res数组的下标
  37.     int index = 0;
  38.     // 单调队列
  39.     Deque<Integer> deque = new ArrayDeque<>();
  40.     // 未形成窗口区间
  41.     for(int i=0; i<k; i++){
  42.         // 队列不为空时，当前值与队列尾部值比较，如果大于，删除队列尾部值
  43.         // 一直循环删除到队列中的值都大于当前值，或者删到队列为空
  44.         while(!deque.isEmpty() && nums[i] > deque.peekLast()) deque.pollLast();
  45.         // 执行完上面的循环后，队列中要么为空，要么值都比当前值大，然后就把当前值添加到队列中
  46.         deque.addLast(nums[i]);
  47.     }
  49.     // 窗口区间刚形成后，把队列首位值添加到队列中
  50.     // 因为窗口形成后，就需要把队列首位添加到数组中，而下面的循环是直接跳过这一步的，所以需要我们直接添加
  51.     res[index++] = deque.peek();
  53.     // 窗口区间形成
  54.     for(int i=k; i<nums.length; i++){
  55.         // i-k是已经在区间外了，如果首位等于nums[i-k]，那么说明此时首位值已经不再区间内了，需要删除
  56.         if(deque.peek() == nums[i-k]) deque.poll();
  57.         // 删除队列中比当前值小的值
  58.         while(!deque.isEmpty() && nums[i] > deque.peekLast()) deque.pollLast();
  59.         // 把当前值添加到队列中
  60.         deque.addLast(nums[i]);
  61.         // 把队列的首位值添加到arr数组中
  62.         res[index++] = deque.peek();
  63.     }
  65.     return res;
  66. }

剑指 Offer 59 - II. 队列的最大值

  1. // 参考的是题解中 “腐烂的橘子” 的题解
  2. // 函数max_value、push_back 和 pop_front 的均摊时间复杂度都是O(1)
  3. class MaxQueue {
  5.     Queue<Integer> queue;  // 正常队列
  6.     Deque<Integer> deque;  // 存了最大值的队列，是个双端队列
  8.     public MaxQueue() {
  9.         queue = new LinkedList<>();
  10.         deque = new LinkedList<>();
  11.     }
  13.     public int max_value() {
  14.         if(deque.isEmpty()){
  15.             return -1;
  16.         }else{
  17.             // 双端队列存的是最大值
  18.             return deque.peek();
  19.         }
  20.     }
  22.     public void push_back(int value) {
  23.         queue.offer(value);
  25.         // 队列是空的时候就直接添加
  26.         if(deque.isEmpty()){
  27.             deque.offer(value);
  28.             return;
  29.         }
  31.         // 若列队不为空，则从后比较，是的队列头中存的是最大值
  32.         // 即这个deque中按照递减的顺序存了queue中的部分数据
  33.         while(!deque.isEmpty() && value > deque.peekLast()){
  34.             deque.pollLast();
  35.         }
  36.         deque.offer(value);
  37.     }
  39.     public int pop_front() {
  41.         if(queue.isEmpty()){
  42.             return -1;
  43.         }
  45.         Integer res = queue.poll();
  47.         // 当队列中的值和deque中的相同时，deque也要出队
  48.         if(res.equals(deque.peek())){
  49.             deque.poll();
  50.         }
  52.         return res;
  53.     }
  54. }

剑指 Offer 60. n个骰子的点数

  1. // 动态规划解题
  2. public double[] dicesProbability(int n) {
  4.     // 明确状态：dp[i][j] 当前有i个骰子时，出现j点数的次数
  5.     int[][] dp = new int[n+1][6*n+1];
  7.     // base case：只有一个骰子的情况，每种可能都是1次
  8.     for(int j=1; j<=6; j++){
  9.         dp[1][j] = 1;
  10.     }
  12.     // 开始状态转移
  13.     for(int i=2; i<=n; i++){          // 骰子个数的状态转移
  14.         for(int j=i; j<=6*i; j++){    // 出现点数j的状态
  15.             for(int k=1; k<=6; k++){  // 然后遍历这个骰子出点的点数可能
  16.                 if(j-k<=0){
  17.                     // 不存在的情况，提前结束
  18.                     break;
  19.                 }
  20.                 dp[i][j] += dp[i-1][j-k];
  21.             }
  22.         }
  23.     }
  25.     // 由于结果需要的是输出的概率值，进行转换
  26.     double[] res = new double[6*n -n + 1];
  27.     double all = Math.pow(6, n);
  28.     for(int i=n; i<=6*n; i++){
  29.         res[i-n] = dp[n][i] / all;
  30.     }
  32.     return res;
  33. }

剑指 Offer 61. 扑克牌中的顺子

  1. // 复杂度分析
  2. // 时间：O(nlogn + n)
  3. // 空间：O(1)
  4. public boolean isStraight(int[] nums) {
  6.     // 排序一下
  7.     Arrays.sort(nums);
  9.     // 记录一下0的个数，0可能是有好几个的 TMD
  10.     int count = 0;
  11.     for(int i=0; i<nums.length; i++){
  12.         if(nums[i] == 0){
  13.             count++;
  14.         }else{
  15.             break;
  16.         }
  17.     }
  19.     // 记录一下不连续的情况
  20.     int fix = 0;
  21.     for(int i=count+1; i<nums.length; i++){
  22.         if(nums[i] - nums[i-1] != 1){
  23.             // 计算不连续度
  24.             fix += nums[i] - nums[i-1] - 1;
  25.         }
  26.         if(nums[i] == nums[i-1] || fix > count){
  27.             // 重复牌的出 || 已经修复不了了
  28.             return false;
  29.         }
  30.     }
  32.     return true;
  33. }

剑指 Offer 62. 圆圈中最后剩下的数字

  1. // 暴力法:模拟这个过程
  2. // 时间复杂度：O(n)
  3. // 空间复杂度：O(n)
  4. public int lastRemaining(int n, int m) {
  6.     List<Integer> nums = new ArrayList<>();
  7.     for(int i=0; i<n; i++){
  8.         nums.add(i);
  9.     }
  11.     int index = 0;
  12.     int res = 0;
  13.     while(n > 0){
  14.         // 关键逻辑
  15.         index = (index + m - 1) % n;
  16.         res = nums.remove(index);
  17.         n--;
  18.     }
  20.     return res;
  21. }

剑指 Offer 63. 股票的最大利润

  1. // 方法1：暴力法 超出时间限制 201/210
  2. // 时间复杂度：O(n^2)
  3. // 空间复杂度：O(1)
  4. public int maxProfit(int[] prices) {
  6.     int res=0;
  8.     // 遍历所有可能
  9.     for(int i=0; i<prices.length; i++){
  10.         for(int j=i+1; j<prices.length; j++){
  11.             if(prices[j] - prices[i] > res){
  12.                 res = prices[j] - prices[i];
  13.             }
  14.         }
  15.     }
  17.     return res;
  18. }
  20. // 方法2：优化后减去一个循环
  21. // 时间复杂度：O(n)
  22. // 空间复杂度：O(1)
  23. public int maxProfit(int[] prices) {
  25.     int res = 0;
  26.     // 固定买出时间
  27.     int cur_min = prices[0];
  28.     for(int j=1; j<prices.length; j++){
  29.         // 寻找最低买入价格的时间，遍历一遍肯定能找到最小值
  30.         cur_min = Math.min(cur_min, prices[j]);
  31.         // 计算最佳时机
  32.         res = Math.max(res, prices[j] - cur_min);
  33.     }
  34.     return res;
  35. }
  37. // 方法3：动态规划
  38. // 时间复杂度：O(n)
  39. // 空间复杂度：O(2n)
  40. public int maxProfit(int[] prices) {
  42.     int n = prices.length;:
  44.     // 定义dp数组表示第i天的最大收入
  45.     // 有2个状态，i：天数  j:持有股票的状态 0-没持有  1-持有
  46.     int[][] dp = new int[n][2];
  48.     // base case
  49.     dp[0][0] = 0;
  50.     dp[0][1] = -prices[0];  // 第一天持有，结果当然是负的
  52.     // 开始状态转移
  53.     for(int i=1; i<n; i++){
  54.         // 第i天没持有，可以由 上一天没持有/上一天持有，这一天卖了 转移而来
  55.         dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1]+prices[i]);
  56.         // 第i天持有，可以由 上一天没持有 这一天买入/上一天持有 转移而来
  57.         dp[i][1] = Math.max(-prices[i], dp[i-1][1]);
  58.     }
  60.     // 最终输出：第n天，没持有股票
  61.     return dp[n-1][0];
  62. }

剑指 Offer 64. 求1+2+…+n

  1. // 不能用for：递归解决
  2. // 不能用if判断递归结束条件，用 && 的短路特性实现
  3. public int sumNums(int n) {
  5.     boolean bool = n > 1 && (n += sumNums(n-1)) > 0;
  7.     return n;
  8. }

剑指 Offer 65. 不用加减乘除做加法

还没做

剑指 Offer 66. 构建乘积数组

  1. // 妙蛙种子吃着妙脆角走进了米奇妙妙屋
  2. // 时间复杂度：O(2n)
  3. // 空间复杂度：O(1)  除去了必要的输出
  4. public int[] constructArr(int[] a) {
  5.     int n = a.length;
  6.     int[] res = new int[n];
  7.     for (int i = 0, cur = 1; i < a.length; i++) {
  8.         res[i] = cur;   // 先乘左边的数(不包括自己)
  9.         cur *= a[i];
  10.     }
  11.     for (int i = a.length - 1, cur = 1; i >= 0; i--) {
  12.         res[i] *= cur;  // 再乘右边的数(不包括自己)
  13.         cur *= a[i];
  14.     }
  15.     return res;
  16. }

剑指 Offer 67. 把字符串转换成整数

  1. public int strToInt(String str) {
  3.     // 删除空格，转换成字符数组
  4.     char[] c = str.trim().toCharArray();
  5.     if(c.length == 0) return 0;
  6.     // 大数边界，这个边界用的很巧妙
  7.     int res = 0, bndry = Integer.MAX_VALUE / 10;
  8.     // 符号位的提取
  9.     int i = 1, sign = 1;
  10.     if(c[0] == '-') sign = -1;
  11.     else if(c[0] != '+') i = 0;
  12.     // 开始遍历
  13.     for(int j = i; j < c.length; j++) {
  14.         // 不是数字了 break
  15.         if(c[j] < '0' || c[j] > '9') break;
  17.         // 关键步骤：防止溢出
  18.         // int的最大值为 -2147483648 ~ 2147483647
  19.         // 大于边界了，再*10必然溢出 || 刚刚等于边界，但是下一个数大于7加上后也溢出
  20.         if(res > bndry || res == bndry && c[j] > '7'){
  21.             return  sign == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
  22.         }
  23.         res = res * 10 + (c[j] - '0');
  24.     }
  26.     return sign*res;
  27. }

剑指 Offer 68 - I. 二叉搜索树的最近公共祖先

  1. // 方法1:一般dfs，没有利用二叉搜索树的性质
  2. // 时间复杂度：O(n)
  3. // 空间复杂度：O(n)  加上了递归的消耗
  4. TreeNode res = null;
  5. public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
  6.     dfs(root, p, q);
  7.     return res;
  8. }
  10. private boolean dfs(TreeNode root, TreeNode p, TreeNode q){
  12.     if(res != null){
  13.         return false;
  14.     }
  16.     boolean left = false, right = false;
  17.     if(root.left != null){
  18.         left = dfs(root.left, p, q);
  19.     }
  21.     if(root.right != null){
  22.         right = dfs(root.right, p, q);
  23.     }
  25.     if(left && right){
  26.         // 左边右边都满足val相等，则root则是这个公共祖先
  27.         res = root;
  28.     }else if((left || right) && (root.val == p.val || root.val == q.val)){
  29.         // 左边或右边满足val相等，且现在的root满足等于p/q，则现在的root就是祖先
  30.         res = root;
  31.     }
  33.     return root.val == p.val || root.val == q.val || left || right;
  34. }
  36. // 方法2：利用二叉搜索树的性质的解法：迭代
  37. // 时间复杂度：O(logn)
  38. // 空间复杂度：O(1)
  39. public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
  41.     while(root != null){
  42.         if(root.val < p.val && root.val < q.val){
  43.             // p,q 都在 root 的右子树中
  44.             root = root.right;
  45.         }else if(root.val > p.val && root.val > q.val){
  46.             // p,q 都在 root 的左子树中
  47.             root = root.left;
  48.         }else{
  49.             // 此时有root的值刚好介于 p q 之间
  50.             break;
  51.         }
  52.     }
  54.     return root;
  55. }

剑指 Offer 68 - II. 二叉树的最近公共祖先

  1. // 一般解法：做了68-I再做的这题...直接用上述的一般解法解的
  2. TreeNode res = null;
  3. public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
  5.     dfs(root, p, q);
  6.     return res;
  7. }
  9. private boolean dfs(TreeNode root, TreeNode p, TreeNode q){
  11.     if(res != null){
  12.         return false;
  13.     }
  15.     boolean left = false, right = false;
  16.     if(root.left != null){
  17.         left = dfs(root.left, p, q);
  18.     }
  20.     if(root.right != null){
  21.         right = dfs(root.right, p, q);
  22.     }
  24.     if(left && right){
  25.         res = root;
  26.     }else if((left || right) && (root.val == p.val || root.val == q.val)){
  27.         res = root;
  28.     }
  30.     return root.val == p.val || root.val == q.val || left || right;
  31. }

LeetCode：“剑指 Offer”的更多相关文章

  1. LeetCode剑指Offer刷题总结（一）

    LeetCode过程中值得反思的细节 以下题号均指LeetCode剑指offer题库中的题号 本文章将每周定期更新,当内容达到10题左右时将会开下一节. 二维数组越界问题04 public stati ...

  2. Leetcode - 剑指offer 面试题29：数组中出现次数超过一半的数字及其变形(腾讯2015秋招 编程题4)

    剑指offer 面试题29:数组中出现次数超过一半的数字 提交网址: http://www.nowcoder.com/practice/e8a1b01a2df14cb2b228b30ee6a92163 ...

  3. [leetcode] 剑指 Offer 专题（一）

    又开了一个笔记专题的坑,未来一两周希望能把<剑指Offer>的题目刷完

  4. LeetCode—剑指 Offer学习计划

    第 1 天 栈与队列(简单) 剑指 Offer 09. 用两个栈实现队列 class CQueue { public: CQueue() { } stack<int>s1,s2; void ...

  5. LeetCode 剑指 Offer 22. 链表中倒数第k个节点

    剑指 Offer 22. 链表中倒数第k个节点 题意 输入一个链表,输出该链表中倒数第k个节点.为了符合大多数人的习惯,本题从1开始计数,即链表的尾节点是倒数第1个节点. ​ 例如,一个链表有 6 个 ...

  6. [LeetCode]剑指 Offer 17. 打印从1到最大的n位数

    输入数字 n,按顺序打印出从 1 到最大的 n 位十进制数.比如输入 3,则打印出 1.2.3 一直到最大的 3 位数 999. 示例 1: 输入: n = 1 输出: [1,2,3,4,5,6,7, ...

  7. [LeetCode]剑指 Offer 52. 两个链表的第一个公共节点

    题解 nodeA走一个链表A(A独有+公共),再走B独有的长度, nodeB走一个链表B(B独有+公共),再走A独有的长度. 结果:两者相遇点即为交点:若没有交点,两者都走到null,会返回null. ...

  8. ⛅剑指 Offer 11. 旋转数组的最小数字

    20207.22 LeetCode 剑指 Offer 11. 旋转数组的最小数字 把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转.输入一个递增排序的数组的一个旋转,输出旋转数组的最小 ...

  9. C++版 - 剑指offer之面试题37：两个链表的第一个公共结点[LeetCode 160] 解题报告

    剑指offer之面试题37 两个链表的第一个公共结点 提交网址: http://www.nowcoder.com/practice/6ab1d9a29e88450685099d45c9e31e46?t ...

  10. C++版 - 剑指offer 面试题39：判断平衡二叉树(LeetCode 110. Balanced Binary Tree) 题解

    剑指offer 面试题39:判断平衡二叉树 提交网址:  http://www.nowcoder.com/practice/8b3b95850edb4115918ecebdf1b4d222?tpId= ...

随机推荐

  1. 服务器安装CentOS7.9系统（U盘启动方式）

    一.安装环境 机房的华为GPU服务器,型号G2500,8张P4显卡,需要安装最小化的CentOS7.9操作系统,利用U盘启动的方式进行安装. 二.安装说明 虽然本环境是GPU服务器,但是安装方式同样适 ...

  2. 使用ogr裁剪矢量数据

    使用ogr裁剪矢量数据 由来: ​ 近期有个需求,内容是这样的:我们有两个矢量数据,现在要求以一个矢量文件为底板,按字段对另一个矢量文件进行分割,生成若干小的shpfile文件 分析: ​ 经过分析之 ...

  3. Python - //和/的区别

    / 表示浮点数除法,返回浮点结果; // 表示整数除法,返回不大于结果的一个最大的整数 print("6 // 4 = " + str(6 // 4)) print("6 ...

  4. Mysql 面试宝典

    实时更新 你用过哪些数据库? mysql redis mysql 和 redis 的区别? 比较点 Mysql Redis 数据库类型 关系型 非关系型 作用 持久化层 存储需要持久化的数据,数据存在 ...

  5. jvm学习笔记：程序计数器

    程序计数器(PC Register) The Java Virtual Machine can support many threads of execution at once (JLS §17). ...

  6. 【HMS Core 6.0全球上线】Toolkit，您的智能辅助编程好帮手

    HMS Core 6.0已于7月15日全球上线.本次版本中,华为HMS Toolkit向广大开发者推出了智能辅助编程助手SmartCoder,帮助开发者轻松高效地集成HMS Core,开发新功能,创建 ...

  7. python中的getpass模块问题,在pycharm中不能继续输入密码

    python中getpass模块   在pycharm中运行下面的代码: 1 import getpass 2 name = input('请输入你的名字:') 3 passwd = getpass. ...

  8. 本地文件名大写，提交到git仓库后变成了小写

    输入改命令即可: git config core.ignorecase false

  9. 取得get参数 从url

    1. getUrlParam.js define(function() { // url参数 var data, index; (function init() { data = []; index ...

  10. php设计模式--生成器模式

    生成器模式 require "D:\\xxx\bild.php"; require "D:\\xxx\cx_bild.php"; require "D ...