<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[Guo_Chuang的博客]]></title><description><![CDATA[]]></description><link>https://blog.csdn.net/Guo_Chuang</link><language>zh-cn</language><generator>https://blog.csdn.net/</generator><copyright><![CDATA[Copyright &copy; Guo_Chuang]]></copyright><item><title><![CDATA[linux常见命令：查看端口是否被占用]]></title><link>https://blog.csdn.net/Guo_Chuang/article/details/120234447</link><guid>https://blog.csdn.net/Guo_Chuang/article/details/120234447</guid><author>Guo_Chuang</author><pubDate>Sat, 11 Sep 2021 10:44:22 +0800</pubDate><description><![CDATA[netstat这个命令常用在网络监控方面，可以查看当前系统监听的服务和已经建立的服务，以及相应的端口、协议等信息。
1. 常见参数设置
netstat参数虽然很多，但是常用的不多，主要是下面几个参数：
netstat -[atunlp]
-a ：all，表示列出所有的连接，服务监听，Socket资料
-t ：tcp，列出tcp协议的服务
-u ：udp，列出udp协议的服务
-n ：port number， 用端口号来显示
-l ：listening，列出当前监听服务
-p ：program，列出服务程序的]]></description><category></category></item><item><title><![CDATA[三个线程分别打印 A，B，C-常规算法]]></title><link>https://blog.csdn.net/Guo_Chuang/article/details/119999788</link><guid>https://blog.csdn.net/Guo_Chuang/article/details/119999788</guid><author>Guo_Chuang</author><pubDate>Mon, 30 Aug 2021 16:26:16 +0800</pubDate><description><![CDATA[三个线程分别打印 A，B，C，要求这三个线程一起运行，打印 n 次，输出形如“ABCABCABC…”的字符串.
思路：使用一个取模的判断逻辑 C%M ==N，题为 3 个线程，所以可以按取模结果编号：0、1、2，他们与 3 取模结果仍为本身，则执行打印逻辑。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadPrint {
    priva]]></description><category></category></item><item><title><![CDATA[LeetCode 61-旋转链表]]></title><link>https://blog.csdn.net/Guo_Chuang/article/details/119332738</link><guid>https://blog.csdn.net/Guo_Chuang/article/details/119332738</guid><author>Guo_Chuang</author><pubDate>Mon, 02 Aug 2021 20:00:14 +0800</pubDate><description><![CDATA[给你一个链表的头节点 head，旋转链表，将链表每个节点向右移动 k 个位置。
解题思路：
整体思路：将链表变成环，其次在合适的位置上断开连接。

首先遍历链表，找到链表尾节点修改其next指针，将其指向头节点，将链表连接成循环链表，同时计算链表长度。
再次遍历链表，在len - k % len的节点断开连接。

具体代码：
class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        if(head == ]]></description><category></category></item><item><title><![CDATA[LeetCode 143-重排链表]]></title><link>https://blog.csdn.net/Guo_Chuang/article/details/119182712</link><guid>https://blog.csdn.net/Guo_Chuang/article/details/119182712</guid><author>Guo_Chuang</author><pubDate>Wed, 28 Jul 2021 16:11:10 +0800</pubDate><description><![CDATA[给定一个单链表 L 的头节点 head ，单链表 L 表示为：
L0 → L1 → … → Ln-1 → Ln
请将其重新排列后变为：
L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → …
不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
实例：
输入: head = [1,2,3,4]
输出: [1,4,2,3]
解题思路：
从题目中的表述中，我们可以知晓重新排列的链表就是两个半链表合并在一起的。因此，我们可以对这个过程进行模拟。
具体：

找到链表中间点，断开连接，形成两个]]></description><category></category></item><item><title><![CDATA[LeetCode 20-有效的括号]]></title><link>https://blog.csdn.net/Guo_Chuang/article/details/119182427</link><guid>https://blog.csdn.net/Guo_Chuang/article/details/119182427</guid><author>Guo_Chuang</author><pubDate>Wed, 28 Jul 2021 15:58:17 +0800</pubDate><description><![CDATA[给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
解题思路：
当遇到左括号时，栈内压进相反的右括号。如果遇到右括号，从栈内取出相同的括号，如果此时栈内为空或者栈顶括号不符，直接返回false。
具体代码：
class Solution {
    //利用栈先进后出 stack 局部变量
    //当stack 压栈不成功后 后进去的括号自动弹出来 循环一次弹出一次
 ]]></description><category></category></item><item><title><![CDATA[LeetCode 232-用栈实现队列]]></title><link>https://blog.csdn.net/Guo_Chuang/article/details/119176260</link><guid>https://blog.csdn.net/Guo_Chuang/article/details/119176260</guid><author>Guo_Chuang</author><pubDate>Wed, 28 Jul 2021 11:56:04 +0800</pubDate><description><![CDATA[请你仅使用两个栈实现先入先出队列。
队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：
实现 MyQueue 类：
void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false
解题思路：
栈的特点是“先进后出”，而队列的特点是“先进先出”。因此我们可以利用两个栈实现队列的特性。首先将一个栈当作输入栈，用]]></description><category></category></item><item><title><![CDATA[LeetCode 84-柱状图中最大的矩形]]></title><link>https://blog.csdn.net/Guo_Chuang/article/details/119007435</link><guid>https://blog.csdn.net/Guo_Chuang/article/details/119007435</guid><author>Guo_Chuang</author><pubDate>Thu, 22 Jul 2021 19:47:16 +0800</pubDate><description><![CDATA[给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。
求在该柱状图中，能够勾勒出来的矩形的最大面积。

输入：heights = [2,1,5,6,2,3]
输出：10
解释：最大的矩形为图中红色区域，面积为 10
解题思路：

遍历每根柱子，将当前柱子 i 的高度作为矩形的高，随后我们需要进行向左右两边扩展，使得扩展到的柱子的高度均不小于 h。即找到左右两侧最近的高度小于 h 的柱子
这样这两根柱子之间（不包括其本身）的所有柱子高度均不小于 h，并且就是 i 能够扩展到]]></description><category></category></item><item><title><![CDATA[LeetCode 102-二叉树的层序遍历]]></title><link>https://blog.csdn.net/Guo_Chuang/article/details/118895980</link><guid>https://blog.csdn.net/Guo_Chuang/article/details/118895980</guid><author>Guo_Chuang</author><pubDate>Mon, 19 Jul 2021 14:57:07 +0800</pubDate><description><![CDATA[给你一个二叉树，请你返回其按层序遍历得到的节点值。 （即逐层地，从左到右访问所有节点）。
解题思路：
首先我们需要了解什么是层序遍历。如下图：

将二叉树按照层进行划分，依次从左至右输出每一层的节点即可。我们可以利用队列进行模拟。
具体代码：
class Solution {
    public List&lt;List&lt;Integer&gt;&gt; levelOrder(TreeNode root) {
    	// 1. 保存最后的结果
        List&lt;List&lt;Int]]></description><category></category></item><item><title><![CDATA[LeetCode 104-二叉树的最大深度]]></title><link>https://blog.csdn.net/Guo_Chuang/article/details/118853909</link><guid>https://blog.csdn.net/Guo_Chuang/article/details/118853909</guid><author>Guo_Chuang</author><pubDate>Sat, 17 Jul 2021 11:19:26 +0800</pubDate><description><![CDATA[给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
解题思路：
class Solution {
	// 方法1：递归
    public int maxDepth(TreeNode root) {
        if(root == null) return 0;
        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
    }
}
]]></description><category></category></item><item><title><![CDATA[LeetCode 110-平衡二叉树]]></title><link>https://blog.csdn.net/Guo_Chuang/article/details/118853240</link><guid>https://blog.csdn.net/Guo_Chuang/article/details/118853240</guid><author>Guo_Chuang</author><pubDate>Sat, 17 Jul 2021 10:42:47 +0800</pubDate><description><![CDATA[给定一个二叉树，判断它是否是高度平衡的二叉树。
本题中，一棵高度平衡二叉树定义为：
一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。
解题思路：

构建递归函数，对于当前遍历到的节点，先递归地判断当前节点的左右子树是否是平衡二叉树，再判断以当前节点为根的子树是否平衡。
如果一棵子树是平衡的，则返回其高度，否则返回 -1。
如果存在一棵子树不平衡，则整个二叉树一定不平衡。

public boolean isBalanced(TreeNode root) {
        return pr]]></description><category></category></item><item><title><![CDATA[LeetCode 19-删除链表的倒数第 N 个结点]]></title><link>https://blog.csdn.net/Guo_Chuang/article/details/118815924</link><guid>https://blog.csdn.net/Guo_Chuang/article/details/118815924</guid><author>Guo_Chuang</author><pubDate>Fri, 16 Jul 2021 18:49:50 +0800</pubDate><description><![CDATA[删除链表的倒数第 N 个结点
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
解题思路：
通过双指针定位到需要删除结点的前一个结点。具体流程如下：

快指针先走n步，保证两个指针的距离为n
快慢指针开始一起走，直到快指针的下一个结点为空
删除目标结点

class Solution {
    // 双指针，快指针首先走n步。快慢指针随后一起走
    public ListNode removeNthFromEnd(ListNode head, int n) {    
       ]]></description><category></category></item><item><title><![CDATA[智力题-找机器]]></title><link>https://blog.csdn.net/Guo_Chuang/article/details/118815347</link><guid>https://blog.csdn.net/Guo_Chuang/article/details/118815347</guid><author>Guo_Chuang</author><pubDate>Fri, 16 Jul 2021 18:37:19 +0800</pubDate><description><![CDATA[智力题-找机器
十个机器，其中九个机器生产的货物是5g，只有一个机器生产的货物是4g，给你一个称，如何一次找出那个生产4g货物的机器。
解题：
将10个机器依次进行编号，分别为1-10。1号机器生产1个货物，2号机器生产2个货物，以此类推，10号机器生产10个货物，共计55个货物。
假设每个机器生产的货物都是5g，则这55个货物的总重量为275g。因此，275g - 实际的重量 = 机器的编号。
原因：假设是n号机器生产的货物为4g，则n号机器总共生产n个货物，即重量减少了ng。

...]]></description><category></category></item><item><title><![CDATA[智力题：抢30]]></title><link>https://blog.csdn.net/Guo_Chuang/article/details/118814112</link><guid>https://blog.csdn.net/Guo_Chuang/article/details/118814112</guid><author>Guo_Chuang</author><pubDate>Fri, 16 Jul 2021 18:14:03 +0800</pubDate><description><![CDATA[智力题：抢30
游戏规则是：第一个人喊 “ 1 ”或 “ 2 ”，第二个人要接着往下喊一个或两个数，然后再轮到第一个人。两人轮流进行下去。最后喊 30 的人获胜。问喊数字的最佳策略。
答案：尽量喊3的倍数。
解析：倒着看，其实，喊 27 时，就决定胜负了。假设 A 喊了 27，B只能喊 28 或 29 ，下个回合，A 一定可以喊30。也就是说，喊 27 者必胜。
再倒着看，其实喊 24 时，就定胜负了。假设 A 喊了 24 ，B 只能喊 25 或 26 ，下个回合 A 一定能喊 27 。
由于喊 27 者必]]></description><category></category></item><item><title><![CDATA[LeetCode 2-两数相加]]></title><link>https://blog.csdn.net/Guo_Chuang/article/details/118641746</link><guid>https://blog.csdn.net/Guo_Chuang/article/details/118641746</guid><author>Guo_Chuang</author><pubDate>Sat, 10 Jul 2021 22:19:12 +0800</pubDate><description><![CDATA[给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照 逆序的方式存储的，并且每个节点只能存储一位数字。请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例 1： 

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

解题思路：
将两个链表看成是相同长度链表的进行遍历，如果一个链表较短则在前面补0。每一位计算的同时需要考虑上一位的进位问题，而当前位计算结束后同样需]]></description><category></category></item><item><title><![CDATA[LeetCode 92-反转链表 II]]></title><link>https://blog.csdn.net/Guo_Chuang/article/details/118641563</link><guid>https://blog.csdn.net/Guo_Chuang/article/details/118641563</guid><author>Guo_Chuang</author><pubDate>Sat, 10 Jul 2021 22:06:34 +0800</pubDate><description><![CDATA[给你单链表的头指针 head 和两个整数 left 和 right ，其中 left &lt;= right 。请你反转从位置 left 到位置 right 的链表节点，返回反转后的链表。
输入：head = [1,2,3,4,5], left = 2, right = 4
输出：[1,4,3,2,5]

解题思路：
代码：
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ]]></description><category></category></item><item><title><![CDATA[LeetCode141-环形链表]]></title><link>https://blog.csdn.net/Guo_Chuang/article/details/118641034</link><guid>https://blog.csdn.net/Guo_Chuang/article/details/118641034</guid><author>Guo_Chuang</author><pubDate>Sat, 10 Jul 2021 21:32:50 +0800</pubDate><description><![CDATA[给定一个链表，判断链表中是否有环。如果链表中存在环，则返回 true。 否则，返回false。
解题思路：
定义两个指针，快指针和慢指针，均指向链表的头节点。慢指针一次走一步，快指针一次走两步。如果两个指针相遇，表明链表有环，否则无环。
代码：
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *      ]]></description><category></category></item><item><title><![CDATA[LeetCode 21-合并两个有序链表]]></title><link>https://blog.csdn.net/Guo_Chuang/article/details/118615659</link><guid>https://blog.csdn.net/Guo_Chuang/article/details/118615659</guid><author>Guo_Chuang</author><pubDate>Sat, 10 Jul 2021 21:22:14 +0800</pubDate><description><![CDATA[将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
解题思路：
类似于归并排序中的merge操作，只不过是在两个链表上进行操作。
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
    	// 1. 新建虚拟节点，便于后续的操作
        ListNode dummy = new ListNode(0);
        // 2. 新链表中的索引节点]]></description><category></category></item><item><title><![CDATA[LeetCode 160-相交链表]]></title><link>https://blog.csdn.net/Guo_Chuang/article/details/118615191</link><guid>https://blog.csdn.net/Guo_Chuang/article/details/118615191</guid><author>Guo_Chuang</author><pubDate>Fri, 09 Jul 2021 21:49:45 +0800</pubDate><description><![CDATA[给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
题目数据保证整个链式结构中不存在环。
注意，函数返回结果后，链表必须保持其原始结构。
解题思路：
定义两个指针分别指向两个链表的头部, 首先让两个指针向后移动，让先移动到末尾的指针从另一个链表的头部再次移动，
最后如果相遇则为交点。
原理：在第一轮移动中恰好抹除了长度差，两个指针等于移动了相同的距离, 有交点就返回, 无交点就是各走了两条指针的长度。
/**
 * Defi]]></description><category></category></item><item><title><![CDATA[LeetCode 206-反转链表]]></title><link>https://blog.csdn.net/Guo_Chuang/article/details/118614382</link><guid>https://blog.csdn.net/Guo_Chuang/article/details/118614382</guid><author>Guo_Chuang</author><pubDate>Fri, 09 Jul 2021 20:50:13 +0800</pubDate><description><![CDATA[给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

解题思路：
从前向后遍历链表的节点，依次进行反转。
代码：
class Solution {
    public ListNode reverseList(ListNode head) {
    	// 1. 新建一个空节点，指向当前链表反转时的下一个节点
        ListNode dummy = null;
        // 2. 当]]></description><category></category></item><item><title><![CDATA[LeetCode 56-合并区间]]></title><link>https://blog.csdn.net/Guo_Chuang/article/details/118613148</link><guid>https://blog.csdn.net/Guo_Chuang/article/details/118613148</guid><author>Guo_Chuang</author><pubDate>Fri, 09 Jul 2021 19:17:19 +0800</pubDate><description><![CDATA[以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。
示例 1：

输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

解题思路：
排序+合并
代码：
class Solution {]]></description><category></category></item></channel></rss>