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

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

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

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;
    }
}

在这里插入图片描述

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/

/**
 * 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;
    }
}

来个牛逼的！

/**
 * 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/

/**
 * 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;
    }
}

递归
在这里插入图片描述

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/

/**
 * 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 哪一个链表的头节点的值更小，然后递归地决定下一个添加到结果里的节点。如果两个链表有一个为空，递归结束。

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/

/**
 * 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/

/**
 * 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/

/**
 * 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
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;
    }
}

按层模拟:
在这里插入图片描述

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/

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();
 */

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/391356.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

数据结构对链表的初步认识（一）

数据结构对链表的初步认识（一）

已经两天没有更新了&#xff0c;今天就写一篇数据结构的链表吧&#xff0c;巩固自己也传授知识&#xff0c;不知道各位是否感兴趣看看这一篇有关联表的文章。 目录 链表的概念与结构 单向链表的实现 链表各个功能函数 首先我在一周前发布了一篇有关顺序表的文章&#xff0c;…
阅读更多...
基于RTOS的嵌入式软件开发与可靠性提升

基于RTOS的嵌入式软件开发与可靠性提升

&#xff08;本文为简单介绍&#xff0c;观点来自网络&#xff09; 随着科技的快速发展&#xff0c;嵌入式系统无所不在&#xff0c;从你的智能手表到汽车的自动驾驶系统&#xff0c;它们都在静静地改变我们的世界。而在这一切的背后&#xff0c;实时操作系统&#xff08;RTOS&…
阅读更多...
OpenAI 发布文生视频大模型 Sora，AI 视频要变天了，视频创作重新洗牌！AGI 还远吗？

OpenAI 发布文生视频大模型 Sora，AI 视频要变天了，视频创作重新洗牌！AGI 还远吗？

一、一觉醒来&#xff0c;AI 视频已变天 早上一觉醒来&#xff0c;群里和朋友圈又被刷屏了。 今年开年 AI 界最大的震撼事件&#xff1a;OpenAI 发布了他们的文生视频大模型 Sora。 OpenAI 文生视频大模型 Sora 的横空出世&#xff0c;预示着 AI 视频要变天了&#xff0c;视…
阅读更多...
Google Gemini 1.5：引领跨模态AIGC信息分析理解与视频内容推理的新篇章，与 Open AI 决一高下！

Google Gemini 1.5：引领跨模态AIGC信息分析理解与视频内容推理的新篇章，与 Open AI 决一高下！

Gemini 1.5具有100万token的上下文理解能力&#xff0c;是目前最强&#xff01;具有跨模态理解和推理&#xff1a;能够对文本、代码、图像、音频和视频进行高度复杂的理解和推理。允许分析1小时视频、11小时音频、超过30,000行代码或超过700,000字的文本。不过谷歌这个Gemini 1…
阅读更多...
简单聊聊k8s，和docker之间的关系

简单聊聊k8s，和docker之间的关系

前言 随着云原生和微服务架构的快速发展&#xff0c;Kubernetes和Docker已经成为了两个重要的技术。但是有小伙伴通常对这两个技术的关系产生疑惑&#xff1a; 既然有了docker&#xff0c;为什么又出来一个k8s&#xff1f; 它俩之间是竞品的关系吗&#xff1f; 傻傻分不清。…
阅读更多...
数据预处理 —— AI算法初识

数据预处理 —— AI算法初识

一、预处理原因 AI算法对数据进行预处理的原因主要基于以下几个核心要点&#xff1a; 1. **数据清洗**&#xff1a; - 数据通常包含缺失值、异常值或错误记录&#xff0c;这些都会干扰模型训练和预测准确性。通过预处理可以识别并填充/删除这些不完整或有问题的数据。 2. **数…
阅读更多...
问题记录——c++ sort 函数 和 严格弱序比较

问题记录——c++ sort 函数 和 严格弱序比较

引出 看下面这段cmp函数的定义 //按照vector第一个元素升序排序 static bool cmp(const vector<int>& a, const vector<int>& b){return a[0] < b[0]; }int eraseOverlapIntervals(vector<vector<int>>& intervals) {//按区间左端排序…
阅读更多...
C语言strlen和sizeof的区别

C语言strlen和sizeof的区别

strlen和sizeof没有联系 前者是库函数&#xff0c;统计长度的标志是是否有\0 后者是操作符。计算长度的标志是字节数量。
阅读更多...
2024阿里云服务器租用价格表大全_1年费用_一个月_1小时收费

2024阿里云服务器租用价格表大全_1年费用_一个月_1小时收费

2024年最新阿里云服务器租用费用优惠价格表&#xff0c;轻量2核2G3M带宽轻量服务器一年61元&#xff0c;折合5元1个月&#xff0c;新老用户同享99元一年服务器&#xff0c;2核4G5M服务器ECS优惠价199元一年&#xff0c;2核4G4M轻量服务器165元一年&#xff0c;2核4G服务器30元3…
阅读更多...
老师的“神秘武器”——教育战线的宝藏工具

老师的“神秘武器”——教育战线的宝藏工具

每次考试成绩发布&#xff0c;是不是总让你头疼不已&#xff1f;面对一摞摞试卷&#xff0c;一个个需要手动输入的成绩&#xff0c;你是否也感到力不从心&#xff1f;别急&#xff0c;今天我就为大家揭秘老师们的“神秘武器”——那些在教育战线上&#xff0c;让老师们事半功倍…
阅读更多...
CSDN如何获得更多勋章？

CSDN如何获得更多勋章？

文章目录 前言一、如何找到自己的勋章&#xff1f;二、如何获得更多勋章&#xff1f;三、重点勋章、易得勋章介绍&推荐1.创作能手2.五一创作勋章3.创作纪念日IT一周年勋章4.新秀勋章5.话题达人6.128天创作纪念日&#xff08;IT博客专属&#xff09;7.GitHub绑定勋章8.其他 …
阅读更多...
你逛过凌晨四点的校园吗？2023年终总结

你逛过凌晨四点的校园吗？2023年终总结

前言&#xff1a; Hello大家好&#xff0c;我是Dream。 又是一年的年终总结&#xff0c;我也迎来了自己的毕业季&#xff0c;没错&#xff0c;我马上要毕业啦&#xff01;不知道大家是什么时候认识我的呢&#xff0c;又或者是第一次发现我~这一年&#xff0c;迎接过朝阳、拍下过…
阅读更多...
【Webpack】处理字体图标和音视频资源

【Webpack】处理字体图标和音视频资源

处理字体图标资源 1. 下载字体图标文件 打开阿里巴巴矢量图标库open in new window选择想要的图标添加到购物车&#xff0c;统一下载到本地 2. 添加字体图标资源 src/fonts/iconfont.ttf src/fonts/iconfont.woff src/fonts/iconfont.woff2 src/css/iconfont.css 注意字体…
阅读更多...
C语言—函数

C语言—函数

1.编写一个函数&#xff0c;通过输入一个数字字符&#xff0c;返回该数字29. /*1.编写一个函数&#xff0c;通过输入一个数字字符&#xff0c;返回该数字 */#include <stdio.h>//函数定义,返回类型为int int char_num(char c) {if(c > 0 && c < 9) //检查…
阅读更多...
【Java程序员面试专栏 Java领域】Java集合 核心面试指引

【Java程序员面试专栏 Java领域】Java集合 核心面试指引

关于Java 集合部分的核心知识进行一网打尽，主要包括Java各类集合以及Java的HashMap底层原理，通过一篇文章串联面试重点，并且帮助加强日常基础知识的理解，全局思维导图如下所示 集合基本概念和比较 关于集合的基本分类和知识 Java集合有哪些种类 Java 集合， 也叫作容器…
阅读更多...
读书笔记之《神经科学讲什么》：神经科学的知与不知

读书笔记之《神经科学讲什么》：神经科学的知与不知

《神经科学讲什么——我们究竟该如何理解心智、意识和语言》的作者是罗伯特伯顿 Robert A. Burton&#xff0c; 原作名: A Skeptics Guide to the Mind: What Neuroscience Can and Cannot Tell Us About Ourselves&#xff0c;于2017年出版。 罗伯特伯顿&#xff08;Robert A…
阅读更多...
【刷题】牛客— NC21 链表内指定区间反转

【刷题】牛客— NC21 链表内指定区间反转

链表内指定区间反转 题目描述思路一&#xff08;暴力破解版&#xff09;思路二&#xff08;技巧反转版&#xff09;思路三&#xff08;递归魔法版&#xff09;Thanks♪(&#xff65;ω&#xff65;)&#xff89;谢谢阅读&#xff01;&#xff01;&#xff01;下一篇文章见&…
阅读更多...
SpringBoot整合GateWay（详细配置）

SpringBoot整合GateWay（详细配置）

前言 在Spring Boot中整合Spring Cloud Gateway是一个常见的需求&#xff0c;尤其是当需要构建一个微服务架构的应用程序时。Spring Cloud Gateway是Spring Cloud生态系统中的一个项目&#xff0c;它提供了一个API网关&#xff0c;用于处理服务之间的请求路由、安全、监控和限流…
阅读更多...
Dynamo批量修改多文件项目基点参数

Dynamo批量修改多文件项目基点参数

Hello 大家好&#xff01;我是九哥~ 前几天群里有个小伙伴&#xff0c;咨询了我一个问题&#xff1a;如何批量修改多个 Revit 文件的项目基点&#xff1f; 本来是想帮忙改改程序&#xff0c;奈何打开以后&#xff0c;我看到了无数的节点和连线&#xff0c;而且这个问题&#x…
阅读更多...
WordPress站点成功升级后的介绍页地址是什么？

WordPress站点成功升级后的介绍页地址是什么？

我们一般在WordPress站点后台 >> 仪表盘 >> 更新中成功升级WordPress的话&#xff0c;最后打开的就是升级之后的版本介绍页。比如boke112百科前两天升级到WordPress 6.4.2后显示的介绍页如下图所示&#xff1a; 该介绍除了介绍当前版本修复了多少个问题及修补了多少…
阅读更多...
最新文章

Copyright @ 2022~2023