new Blog

Author: thrinisty

src/content/posts/Kafka消息队列笔记（模板）.md

@@ -0,0 +1,13 @@
+---
+title: Kafka消息队列笔记（）
+published: 2025-11-01
+updated: 2025-11-01
+description: ''
+image: ''
+tags: [MQ]
+category: ''
+draft: false 
+---
+
+# Kafka笔记
+

src/content/posts/Kafka消息队列笔记（）.md

@@ -0,0 +1,29 @@
+---
+title: Kafka消息队列笔记（）
+published: 2025-11-13
+updated: 2025-11-13
+description: ''
+image: ''
+tags: [MQ]
+category: ''
+draft: false 
+---
+
+# Kafka笔记
+
+Kafka消息队列应用场景：异步处理、系统解耦、流量削峰、日志处理
+
+交互模型：请求响应模型、生产者消费者模型
+
+消息队列两种模式：点对点模式、发布订阅模型
+
+
+
+Producers：将消息放入集群中
+
+Consumers：将消息数据从集群中拉出来
+
+Connectors：连接器可以将数据库中的数据导入Kafka，也可以将数据导出到数据库中
+
+Stream Processors：流处理器可以从Kafka中拉取数据，也可以将数据写入Kafka
+

src/content/posts/LeetCode刷题（二叉搜索树最小绝对差、搜索树第K小元素）.md

@@ -0,0 +1,168 @@
+---
+title: LeetCode刷题（二叉搜索树最小绝对差、搜索树第K小元素）
+published: 2025-11-13
+updated: 2025-11-13
+description: '二叉搜索树最小绝对差、搜索树第K小元素'
+image: ''
+tags: [LeetCode]
+category: 'LeetCode'
+draft: false 
+---
+
+# 二叉搜索树最小绝对差
+
+## 题目描述
+
+给你一个二叉搜索树的根节点 `root` ，返回 **树中任意两不同节点值之间的最小差值** 。
+
+差值是一个正数，其数值等于两值之差的绝对值。
+
+**示例 1：**
+
+![361](../images/361.jpg)
+
+```
+输入：root = [4,2,6,1,3]
+输出：1
+```
+
+**示例 2：**
+
+![362](../images/362.jpg)
+
+```
+输入：root = [1,0,48,null,null,12,49]
+输出：1
+```
+
+
+
+## 题解
+
+用pre记录前一个值，在中序遍历中进行对于result迭代
+
+```java
+class Solution {
+    int result = Integer.MAX_VALUE;
+    int pre = -1;
+    public int getMinimumDifference(TreeNode root) {
+        dfs(root);
+        return result;
+    }
+    public void dfs(TreeNode root) {
+        if(root == null) return;
+        dfs(root.left);
+        if(pre != -1) {
+            result = Math.min(result, Math.abs(pre - root.val));
+        }
+        pre = root.val;
+        dfs(root.right);
+    }   
+}
+```
+
+补一个非递归的方式
+
+```java
+class Solution {
+    int result = Integer.MAX_VALUE;
+    int pre = -1;
+    public int getMinimumDifference(TreeNode root) {
+        Stack<TreeNode> stack = new Stack();
+        TreeNode p = root;
+        while(!stack.isEmpty() || p != null) {
+            while(p != null) {
+                stack.push(p);
+                p = p.left;
+            }
+            TreeNode node = stack.pop();
+            if(pre != -1) {
+                result = Math.min(result, Math.abs(node.val - pre));
+            }
+            pre = node.val;
+            p = node.right;
+        }
+        return result;
+    }
+}
+```
+
+
+
+# 搜索树第K小元素
+
+## 题目描述
+
+给定一个二叉搜索树的根节点 `root` ，和一个整数 `k` ，请你设计一个算法查找其中第 `k` 小的元素（从 1 开始计数）。
+
+**示例 1：**
+
+![363](../images/363.jpg)
+
+```
+输入：root = [3,1,4,null,2], k = 1
+输出：1
+```
+
+**示例 2：**
+
+![364](../images/364.jpg)
+
+```
+输入：root = [5,3,6,2,4,null,null,1], k = 3
+输出：3
+```
+
+
+
+## 题解
+
+用中序遍历，遍历到数字就加一，如果当前数字在第K为就设置当前数字为result
+
+```java
+class Solution {
+    int num = 1;
+    int result = -1;
+    int target;
+    public int kthSmallest(TreeNode root, int k) {
+        target = k;
+        dfs(root);
+        return result;
+    }
+
+    public void dfs(TreeNode root) {
+        if(root == null) return; 
+        dfs(root.left);
+        if(num == target) {
+            result = root.val;
+        }
+        num++;
+        dfs(root.right);
+    }
+}
+```
+
+非递归
+
+```java
+class Solution {
+    public int kthSmallest(TreeNode root, int k) {
+        Stack<TreeNode> stack = new Stack();
+        TreeNode p = root;
+        while(!stack.isEmpty() || p != null) {
+            while(p != null) {
+                stack.push(p);
+                p = p.left;
+            }
+            TreeNode node = stack.pop();
+            k--;
+            if(k == 0) {
+                return node.val;
+            }
+            p = node.right;
+        }
+        return p.val;
+    }
+}
+```
+

src/content/posts/LeetCode刷题（二叉树右视图、二叉树的锯齿层序遍历）.md

@@ -0,0 +1,143 @@
+---
+title: LeetCode刷题（二叉树右视图、二叉树的锯齿层序遍历）
+published: 2025-11-12
+updated: 2025-11-12
+description: '二叉树右视图、二叉树的锯齿层序遍历'
+image: ''
+tags: [LeetCode]
+category: 'LeetCode'
+draft: false 
+---
+
+# 二叉树右视图
+
+## 题目描述
+
+给定一个二叉树的 **根节点** `root`，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
+
+**示例 1：**
+
+**输入：**root = [1,2,3,null,5,null,4]
+
+**输出：**[1,3,4]
+
+**解释：**
+
+![358](../images/358.png)
+
+**示例 2：**
+
+**输入：**root = [1,2,3,4,null,null,null,5]
+
+**输出：**[1,3,4,5]
+
+**解释：**
+
+![359](../images/359.png)
+
+**示例 3：**
+
+**输入：**root = [1,null,3]
+
+**输出：**[1,3]
+
+**示例 4：**
+
+**输入：**root = []
+
+**输出：**[]
+
+
+
+## 题解
+
+通过层序遍历取出最后的元素即可
+
+```java
+class Solution {
+    public List<Integer> rightSideView(TreeNode root) {
+        List<Integer> result = new ArrayList<>();
+        if(root == null) return result;
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+        while(!queue.isEmpty()) {
+            int n = queue.size();
+            for(int i = 0; i < n; i++) {
+                TreeNode node = queue.poll();
+                if(i == n - 1) result.add(node.val);
+                if(node.left != null) queue.offer(node.left);
+                if(node.right != null) queue.offer(node.right);
+            }
+        }
+        return result;
+    }
+}
+```
+
+
+
+
+
+# 二叉树的锯齿层序遍历
+
+## 题目描述
+
+给你二叉树的根节点 `root` ，返回其节点值的 **锯齿形层序遍历** 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
+
+**示例 1：**
+
+![360](../images/360.jpg)
+
+```
+输入：root = [3,9,20,null,null,15,7]
+输出：[[3],[20,9],[15,7]]
+```
+
+**示例 2：**
+
+```
+输入：root = [1]
+输出：[[1]]
+```
+
+**示例 3：**
+
+```
+输入：root = []
+输出：[]
+```
+
+
+
+## 题解
+
+记录层级在偶数层的时候反转链表即可
+
+```java
+class Solution {
+    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
+        List<List<Integer>> result = new ArrayList<>();
+        if(root == null) return result;
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+        int level = 1;
+        while(!queue.isEmpty()) {
+            int n = queue.size();
+            List<Integer> list = new ArrayList<>();
+            for(int i = 0; i < n; i++) {
+                TreeNode node = queue.poll();
+                list.add(node.val);
+                if(node.left != null) queue.offer(node.left);
+                if(node.right != null) queue.offer(node.right);
+            }
+            if(level % 2 == 0) {
+                Collections.reverse(list);
+            }
+            result.add(list);
+            level++;
+        }
+        return result;
+    }
+}
+```
+