《剑指Offer》笔记&题解&思路&技巧&优化 Java版本——新版leetcode_Part_3

_Matthew2024-02-18 1:00

《剑指Offer》笔记&题解&思路&技巧&优化_Part_3

  • [😍😍😍 相知](#😍😍😍 相知)
  • [🙌🙌🙌 相识](#🙌🙌🙌 相识)
  • [😢😢😢 开始刷题](#😢😢😢 开始刷题)
    • [1. LCR 138. 有效数字------表示数值的字符串](#1. LCR 138. 有效数字——表示数值的字符串)
    • [2. LCR 139. 训练计划 I------调整数组顺序使奇数位于偶数前面](#2. LCR 139. 训练计划 I——调整数组顺序使奇数位于偶数前面)
    • [3. LCR 140. 训练计划 II------链表中倒数第k个节点](#3. LCR 140. 训练计划 II——链表中倒数第k个节点)
    • [4. LCR 141. 训练计划 III------反转链表](#4. LCR 141. 训练计划 III——反转链表)
    • [5. LCR 142. 训练计划 IV------合并两个排序的链表](#5. LCR 142. 训练计划 IV——合并两个排序的链表)
    • [6. LCR 143. 子结构判断------树的子结构](#6. LCR 143. 子结构判断——树的子结构)
    • [7. LCR 144. 翻转二叉树------二叉树的镜像](#7. LCR 144. 翻转二叉树——二叉树的镜像)
    • [8. LCR 145. 判断对称二叉树------对称的二叉树](#8. LCR 145. 判断对称二叉树——对称的二叉树)
    • [9. LCR 146. 螺旋遍历二维数组------顺时针打印矩阵](#9. LCR 146. 螺旋遍历二维数组——顺时针打印矩阵)
    • [10. LCR 147. 最小栈------包含min函数的栈](#10. LCR 147. 最小栈——包含min函数的栈)

😍😍😍 相知

当你踏入计算机科学的大门，或许会感到一片新奇而陌生的领域，尤其是对于那些非科班出身的学子而言。作为一位非科班研二学生，我深知学习的道路可能会充满挑战，让我们愿意迎接这段充满可能性的旅程。

最近，我开始了学习《剑指Offer》和Java编程的探索之旅。这不仅是一次对计算机科学的深入了解，更是对自己学术生涯的一次扩展。或许，这一切刚刚开始，但我深信，通过努力与坚持，我能够逐渐驾驭这门技艺。

在这个博客中，我将深入剖析《剑指Offer》中的问题，并结合Java编程语言进行解析。

让我们一起踏上这段学习之旅，共同奋斗，共同成长。无论你是已经驾轻就熟的Java高手，还是像我一样初出茅庐的学子，我们都能在这里找到彼此的支持与激励。让我们携手前行，共同迎接知识的挑战，为自己的未来打下坚实的基石。

这是我上一篇博客的，也希望大家多多关注！

  1. 《剑指Offer》笔记&题解&思路&技巧&优化 Java版本------新版leetcode_Part_1
  2. 《剑指Offer》笔记&题解&思路&技巧&优化 Java版本------新版leetcode_Part_2

🙌🙌🙌 相识

根据题型可将其分为这样几种类型：

  1. 结构概念类（数组，链表，栈，堆，队列，树）
  2. 搜索遍历类（深度优先搜索，广度优先搜索，二分遍历）
  3. 双指针定位类（快慢指针，指针碰撞，滑动窗口）
  4. 排序类（快速排序，归并排序）
  5. 数学推理类（动态规划，数学）

😢😢😢 开始刷题

1. LCR 138. 有效数字------表示数值的字符串

题目跳转：https://leetcode.cn/problems/biao-shi-shu-zhi-de-zi-fu-chuan-lcof/description/

边界条件很多

学会函数：

  1. s = s.trim();
  2. char[] res = s.toCharArray();
java 复制代码 
class Solution {
    public boolean isNumber(String s) {
        if (s == null || s.length() == 0) return false;
        //去掉首尾空格
        s = s.trim();
        boolean numFlag = false;
        boolean dotFlag = false;
        boolean eFlag = false;
        for (int i = 0; i < s.length(); i++) {
            //判定为数字，则标记numFlag
            if (s.charAt(i) >= '0' && s.charAt(i) <= '9') {
                numFlag = true;
                //判定为.  需要没出现过.并且没出现过e
            } else if (s.charAt(i) == '.' && !dotFlag && !eFlag) {
                dotFlag = true;
                //判定为e，需要没出现过e，并且出过数字了
            } else if ((s.charAt(i) == 'e' || s.charAt(i) == 'E') && !eFlag && numFlag) {
                eFlag = true;
                numFlag = false;//为了避免123e这种请求，出现e之后就标志为false
                //判定为+-符号，只能出现在第一位或者紧接e后面
            } else if ((s.charAt(i) == '+' || s.charAt(i) == '-') 
            && (i == 0 || s.charAt(i - 1) == 'e' || s.charAt(i - 1) == 'E')) {

                //其他情况，都是非法的
            } else {
                return false;
            }
        }
        return numFlag;
    }
}

2. LCR 139. 训练计划 I------调整数组顺序使奇数位于偶数前面

题目跳转：https://leetcode.cn/problems/diao-zheng-shu-zu-shun-xu-shi-qi-shu-wei-yu-ou-shu-qian-mian-lcof/description/

java 复制代码 
class Solution {
    public int[] trainingPlan(int[] actions) {
        if(actions==null)return null;
        if(actions.length==0)return new int[0];
        int slow = 0;
        int fast = 0;
        while(fast<actions.length&&slow<actions.length){
            if(actions[slow]%2==0){
                while(fast<actions.length){
                    if(actions[fast]%2==1){
                        int temp = actions[fast];
                        for(int i = fast;i>slow;i--){
                            actions[i] = actions[i-1];
                        }
                        actions[slow] =temp;
                        
                        break;
                    }
                    else fast++;
                }
            }
            slow++;
            fast++;
            
        }
        return actions;
    }
}
java 复制代码 
class Solution {
    public int[] trainingPlan(int[] nums) {
        if(nums == null || nums.length == 0){
            return nums;
        }
        int left = 0;
        int right = nums.length - 1;
        while(left < right){
	        while(left < right && nums[left] % 2 != 0) left++;
	        while(left < right && nums[right] % 2 != 1) right--;
	        int temp = nums[left];
	        nums[left] = nums[right];
	        nums[right] = temp;
        }
        return nums;
    }
}

3. LCR 140. 训练计划 II------链表中倒数第k个节点

题目跳转：https://leetcode.cn/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/description/

java 复制代码 
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode trainingPlan(ListNode head, int cnt) {
        if(head==null) return null;
        if(head.next == null) return head;
        ListNode result = head;
        int num = 0;
        while(result!=null){
            num++;
            result = result.next;
        }
        num = num - cnt;
        while(num!=0){
            head = head.next;
            num--;
        }
        return head;
    }
}

来个牛逼的！

java 复制代码 
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode trainingPlan(ListNode head, int cnt) {
        if(head==null) return null;
        if(head.next == null) return head;
        ListNode slow = head;
        ListNode fast = head;
        for(int i = 0;i<cnt;i++){
            if(fast==null)return null;
            fast = fast.next;
        }
        while(fast!=null){
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }
}

4. LCR 141. 训练计划 III------反转链表

题目跳转：https://leetcode.cn/problems/fan-zhuan-lian-biao-lcof/description/

java 复制代码 
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode trainningPlan(ListNode head) {
        ListNode result = new ListNode(0);
        while(head!=null){
            ListNode temp = head;
            head = head.next;
            temp.next= result.next;
            result.next = temp;
        }
        return result.next;
    }
}

递归

java 复制代码 
class Solution {
    public ListNode trainningPlan(ListNode head) {
        if(head==null||head.next==null)return head;
        ListNode temp = trainningPlan(head.next);
        head.next.next = head;
        head.next= null;
        return temp;
    }
}

5. LCR 142. 训练计划 IV------合并两个排序的链表

题目跳转：https://leetcode.cn/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof/description/

java 复制代码 
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode trainningPlan(ListNode l1, ListNode l2) {
        if(l1==null)return l2;
        if(l2==null)return l1;
        ListNode result = new ListNode();
        ListNode temp = result;
        while(l1!=null||l2!=null){
            if(l1!=null&&l2!=null){
                if(l1.val<l2.val){
                    ListNode res = new ListNode(l1.val);
                    temp.next= res;
                    temp =temp.next;
                    l1 = l1.next;
                }
                else
                {
                    ListNode res = new ListNode(l2.val);
                    temp.next= res;
                    temp =temp.next;
                    l2 = l2.next;
                }
            }
            if(l1==null){
                temp.next =l2;
                break; 
            }
            if(l2==null){
                temp.next =l1;
                break; 
            }
        }
        return result.next;
    }
}

递归思路 ：

我们可以如下递归地定义两个链表里的 merge 操作（忽略边界情况，比如空链表等）：

{ l i s t 1 [ 0 ] + m e r g e ( l i s t 1 [ 1 : ] , l i s t 2 ) l i s t 1 [ 0 ] < l i s t 2 [ 0 ] l i s t 2 [ 0 ] + m e r g e ( l i s t 1 , l i s t 2 [ 1 : ] ) o t h e r w i s e \left\{ \begin{array}{ll} list1[0] + merge(list1[1:], list2) & list1[0] < list2[0] \\ list2[0] + merge(list1, list2[1:]) & otherwise \end{array} \right. {list1[0]+merge(list1[1:],list2)list2[0]+merge(list1,list2[1:])list1[0]<list2[0]otherwise

也就是说，两个链表头部值较小的一个节点与剩下元素的 merge 操作结果合并。

算法

我们直接将以上递归过程建模，同时需要考虑边界情况。

如果 l1 或者 l2 一开始就是空链表 ，那么没有任何操作需要合并，所以我们只需要返回非空链表。否则，我们要判断 l1 和 l2 哪一个链表的头节点的值更小，然后递归地决定下一个添加到结果里的节点。如果两个链表有一个为空，递归结束。

java 复制代码 
class Solution {
    public ListNode trainningPlan(ListNode l1, ListNode l2) {
        if (l1 == null) {
            return l2;
        } else if (l2 == null) {
            return l1;
        } else if (l1.val < l2.val) {
            l1.next = trainningPlan(l1.next, l2);
            return l1;
        } else {
            l2.next = trainningPlan(l1, l2.next);
            return l2;
        }
    }
}

6. LCR 143. 子结构判断------树的子结构

题目跳转：https://leetcode.cn/problems/shu-de-zi-jie-gou-lcof/description/

java 复制代码 
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSubStructure(TreeNode A, TreeNode B) {
        if(A==null||B==null)return false;
        if(isSub(A,B))return true;
        if(isSubStructure(A.left, B) || isSubStructure(A.right, B)){
            return true;
        }
        return false;
    }
    public boolean isSub(TreeNode TA,TreeNode TB){
        if(TB==null)return true;
        if(TA==null)return false;
        if(TA.val!=TB.val)return false;
        return isSub(TA.left,TB.left)&&isSub(TA.right,TB.right);
    }
}

7. LCR 144. 翻转二叉树------二叉树的镜像

题目跳转：https://leetcode.cn/problems/er-cha-shu-de-jing-xiang-lcof/description/

java 复制代码 
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        if(root==null)return root;
        if(root.right==null&&root.left==null)return root;
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
        root.right = mirrorTree(root.right);
        root.left = mirrorTree(root.left);
        return root;
    }

}

8. LCR 145. 判断对称二叉树------对称的二叉树

题目跳转：https://leetcode.cn/problems/dui-cheng-de-er-cha-shu-lcof/description/

java 复制代码 
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean checkSymmetricTree(TreeNode root) {
        if(root==null)return true;
        if(root.left==null&&root.right==null)return true;
        if(root.right==null||root.left==null)return false;
        return check(root.left,root.right);
    }
    public boolean check(TreeNode A,TreeNode B){
        if(A==null&&B==null)return true;
        if(A==null||B==null)return false;
        if(A.val!=B.val)return false;
        return check(A.left,B.right)&&check(A.right,B.left);
    }
}

9. LCR 146. 螺旋遍历二维数组------顺时针打印矩阵

题目跳转：https://leetcode.cn/problems/shun-shi-zhen-da-yin-ju-zhen-lcof/description/


算法流程：

  • 空值处理： 当 array 为空时，直接返回空列表 [] 即可。
  • 初始化： 矩阵 左、右、上、下 四个边界 l , r , t , b ，用于打印的结果列表 res 。
  • 循环打印： "从左向右、从上向下、从右向左、从下向上" 四个方向循环打印；
    • 根据边界打印，即将元素按顺序添加至列表 res 尾部；
    • 边界向内收缩 1 （代表已被打印）；
    • 判断边界是否相遇（是否打印完毕），若打印完毕则跳出。
  • 返回值： 返回 res 即可。
打印方向 1. 根据边界打印 2. 边界向内收缩 3. 是否打印完毕
从左向右 左边界l ，右边界 r 上边界 t 加 111 是否 t > b
从上向下 上边界 t ，下边界b 右边界 r 减 111 是否 l > r
从右向左 右边界 r ，左边界l 下边界 b 减 111 是否 t > b
从下向上 下边界 b ，上边界t 左边界 l 加 111 是否 l > r
java 复制代码 
class Solution {
    public int[] spiralArray(int[][] array) {
        if(array.length == 0) return new int[0];
        int l = 0, r = array[0].length - 1, t = 0, b = array.length - 1, x = 0;
        int[] res = new int[(r + 1) * (b + 1)];
        while(true) {
            for(int i = l; i <= r; i++) res[x++] = array[t][i]; // left to right
            if(++t > b) break;
            for(int i = t; i <= b; i++) res[x++] = array[i][r]; // top to bottom
            if(l > --r) break;
            for(int i = r; i >= l; i--) res[x++] = array[b][i]; // right to left
            if(t > --b) break;
            for(int i = b; i >= t; i--) res[x++] = array[i][l]; // bottom to top
            if(++l > r) break;
        }
        return res;
    }
}

按层模拟 :

java 复制代码 
class Solution {
    public int[] spiralArray(int[][] array) {
        if (array == null || array.length == 0 || array[0].length == 0) {
            return new int[0];
        }
        int rows = array.length, columns = array[0].length;
        int[] order = new int[rows * columns];
        int index = 0;
        int left = 0, right = columns - 1, top = 0, bottom = rows - 1;
        while (left <= right && top <= bottom) {
            for (int column = left; column <= right; column++) {
                order[index++] = array[top][column];
            }
            for (int row = top + 1; row <= bottom; row++) {
                order[index++] = array[row][right];
            }
            if (left < right && top < bottom) {
                for (int column = right - 1; column > left; column--) {
                    order[index++] = array[bottom][column];
                }
                for (int row = bottom; row > top; row--) {
                    order[index++] = array[row][left];
                }
            }
            left++;
            right--;
            top++;
            bottom--;
        }
        return order;
    }
}

复杂度分析

  • 时间复杂度：O(mn)，其中 m 和 n 分别是输入二维数组的行数和列数。二维数组中的每个元素都要被访问一次。

  • 空间复杂度：O(1)。除了输出数组以外，空间复杂度是常数。

10. LCR 147. 最小栈------包含min函数的栈

题目跳转：https://leetcode.cn/problems/bao-han-minhan-shu-de-zhan-lcof/description/

java 复制代码 
class MinStack {

    /** initialize your data structure here. */
    int minstack = Integer.MAX_VALUE;;
    Stack<Integer> stack;
    public MinStack() {
        stack = new Stack<Integer>();
    }
    
    public void push(int x) {
        stack.push(minstack);
        minstack = x<minstack?x:minstack;
        stack.push(x);
    }
    
    public void pop() {
        stack.pop();
        minstack = stack.pop();

    }
    
    public int top() {
        return stack.peek();
    }
    
    public int getMin() {
        return minstack;
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(x);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */
相关推荐
cuisidong199712 分钟前
5G学习笔记三之物理层、数据链路层、RRC层协议
笔记·学习·5g
雷神乐乐13 分钟前
File.separator与File.separatorChar的区别
java·路径分隔符
乌恩大侠14 分钟前
5G周边知识笔记
笔记·5g
小刘|17 分钟前
《Java 实现希尔排序：原理剖析与代码详解》
java·算法·排序算法
逊嘘36 分钟前
【Java语言】抽象类与接口
java·开发语言·jvm
morris13143 分钟前
【SpringBoot】Xss的常见攻击方式与防御手段
java·spring boot·xss·csp
七星静香1 小时前
laravel chunkById 分块查询 使用时的问题
java·前端·laravel
Jacob程序员1 小时前
java导出word文件(手绘)
java·开发语言·word
ZHOUPUYU1 小时前
IntelliJ IDEA超详细下载安装教程（附安装包）
java·ide·intellij-idea
stewie61 小时前
在IDEA中使用Git
java·git
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play