<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[AndyJson的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/AndyJson</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; AndyJson]]></copyright><item><title><![CDATA[分布式事务的详细介绍]]></title><link>https://blog.youkuaiyun.com/AndyJson/article/details/157362425</link><guid>https://blog.youkuaiyun.com/AndyJson/article/details/157362425</guid><author>AndyJson</author><pubDate>Mon, 26 Jan 2026 10:00:00 +0800</pubDate><description><![CDATA[简单来说，就是一次大的操作由不同的小操作组成，这些小操作分布在不同的服务器上，且属于不同的应用，分布式事务需要保证这些小操作要么全部成功，要么全部失败。最终一致性模型是应对高并发和可用性要求场景的普遍选择，它通过接受短暂的延迟，换取了系统处理网络不确定性的能力和更高的吞吐量。为了在现实中生存，BASE理论对CAP的强一致性要求进行了务实的修正，并催生了不同的一致性模型，这正是工程师们直面上述挑战的解决方案。该定理指出，在存在网络分区（P）的分布式系统中，一致性（C）和可用性（A）无法同时被完美满足。]]></description><category></category></item><item><title><![CDATA[Seata 的详细介绍]]></title><link>https://blog.youkuaiyun.com/AndyJson/article/details/157362540</link><guid>https://blog.youkuaiyun.com/AndyJson/article/details/157362540</guid><author>AndyJson</author><pubDate>Sun, 25 Jan 2026 18:55:35 +0800</pubDate><description><![CDATA[Resource Manager（资源管理器RM）：管理分支事务所涉及的资源（如数据库连接），向 TC 注册分支事务，并执行本地事务。Transaction Coordinator（事务协调器TC）：全局事务的协调者，负责维护全局事务状态，驱动分支事务提交或回滚。Transaction Manager（事务管理器TM）：定义全局事务的边界（开始、提交、回滚），通常位于发起全局事务的服务中。TC（Transaction Coordinator）是独立的服务，需单独部署。]]></description><category></category></item><item><title><![CDATA[分布式锁从入门到精通]]></title><link>https://blog.youkuaiyun.com/AndyJson/article/details/157362257</link><guid>https://blog.youkuaiyun.com/AndyJson/article/details/157362257</guid><author>AndyJson</author><pubDate>Sun, 25 Jan 2026 18:26:41 +0800</pubDate><description><![CDATA[在分布式系统中，当不同的系统或同一个系统的不同主机之间共享资源时，需要互斥访问来保证数据一致性，这时便需要使用到分布式锁。Redisson 提供了丰富的分布式同步器，包括：分布式锁：RLock（可重入锁）、RFairLock（公平锁）、RedLock（红锁）。它是Redis分布式锁的"防弹衣"，通过多节点投票机制，即使部分节点崩溃，也能保证锁的绝对安全。目前主流的分布式锁实现方式包括：Redis的SETNX命令结合Lua脚本：最常用的实现方式。这是Redisson的重要改进，大大简化了分布式锁的使用。]]></description><category></category></item><item><title><![CDATA[栈---车队]]></title><link>https://blog.youkuaiyun.com/AndyJson/article/details/84247246</link><guid>https://blog.youkuaiyun.com/AndyJson/article/details/84247246</guid><author>AndyJson</author><pubDate>Mon, 19 Nov 2018 14:17:30 +0800</pubDate><description><![CDATA[
题目
N  辆车沿着一条车道驶向位于 target 英里之外的共同目的地。
每辆车 i 以恒定的速度 speed[i] （英里/小时），从初始位置 position[i] （英里） 沿车道驶向目的地。
一辆车永远不会超过前面的另一辆车，但它可以追上去，并与前车以相同的速度紧接着行驶。
此时，我们会忽略这两辆车之间的距离，也就是说，它们被假定处于相同的位置。
车队 是一些由行驶在相同位置、具有相同...]]></description><category></category></item><item><title><![CDATA[栈---股票每日价格]]></title><link>https://blog.youkuaiyun.com/AndyJson/article/details/84190824</link><guid>https://blog.youkuaiyun.com/AndyJson/article/details/84190824</guid><author>AndyJson</author><pubDate>Sat, 17 Nov 2018 17:30:09 +0800</pubDate><description><![CDATA[
题目
编写一个 StockSpanner 类，它收集某些股票的每日报价，并返回该股票当日价格的跨度。 编写一个 StockSpanner 类，它收集某些股票的每日报价，并返回该股票当日价格的跨度。
今天股票价格的跨度被定义为股票价格小于或等于今天价格的最大连续日数（从今天开始往回数，包括今天）。
例如，如果未来7天股票的价格是 [100, 80, 60, 70, 60, 75, 85]，那么股票...]]></description><category></category></item><item><title><![CDATA[栈---行星碰撞]]></title><link>https://blog.youkuaiyun.com/AndyJson/article/details/84190183</link><guid>https://blog.youkuaiyun.com/AndyJson/article/details/84190183</guid><author>AndyJson</author><pubDate>Sat, 17 Nov 2018 16:35:15 +0800</pubDate><description><![CDATA[
题目
给定一个整数数组 asteroids，表示在同一行的行星。
对于数组中的每一个元素，其绝对值表示行星的大小，正负表示行星的移动方向（正表示向右移动，负表示向左移动）。每一颗行星以相同的速度移动。
找出碰撞后剩下的所有行星。碰撞规则：两个行星相互碰撞，较小的行星会爆炸。如果两颗行星大小相同，则两颗行星都会爆炸。两颗移动方向相同的行星，永远不会发生碰撞。
示例

输入: 
asteroids ...]]></description><category></category></item><item><title><![CDATA[栈---字符串解码]]></title><link>https://blog.youkuaiyun.com/AndyJson/article/details/84145800</link><guid>https://blog.youkuaiyun.com/AndyJson/article/details/84145800</guid><author>AndyJson</author><pubDate>Fri, 16 Nov 2018 20:59:19 +0800</pubDate><description><![CDATA[
题目
给定一个经过编码的字符串，返回它解码后的字符串。
编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。
你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。
此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[...]]></description><category></category></item><item><title><![CDATA[栈---函数的独占时间]]></title><link>https://blog.youkuaiyun.com/AndyJson/article/details/84145119</link><guid>https://blog.youkuaiyun.com/AndyJson/article/details/84145119</guid><author>AndyJson</author><pubDate>Fri, 16 Nov 2018 20:09:21 +0800</pubDate><description><![CDATA[
题目
给出一个非抢占单线程CPU的 n 个函数运行日志，找到函数的独占时间。
每个函数都有一个唯一的 Id，从 0 到 n-1，函数可能会递归调用或者被其他函数调用。
日志是具有以下格式的字符串：function_id：start_or_end：timestamp。例如：“0:start:0” 表示函数 0 从 0 时刻开始运行。“0]]></description><category></category></item><item><title><![CDATA[栈---逆波兰表达式求值]]></title><link>https://blog.youkuaiyun.com/AndyJson/article/details/84137289</link><guid>https://blog.youkuaiyun.com/AndyJson/article/details/84137289</guid><author>AndyJson</author><pubDate>Fri, 16 Nov 2018 12:41:12 +0800</pubDate><description><![CDATA[
题目
根据逆波兰表示法，求表达式的值。
有效的运算符包括 +, -, *, / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。
说明：
整数除法只保留整数部分。
给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。
示例

输入: [&quot;2&quot;, &quot;1&quot;, &quot;+&quot;, &quot;3&quot;, &quot;*&quot;]
输出: 9
解释: ((2 + 1) * 3) = 9

输入: [&quot;.]]></description><category></category></item><item><title><![CDATA[栈---下一个更大元素]]></title><link>https://blog.youkuaiyun.com/AndyJson/article/details/84137155</link><guid>https://blog.youkuaiyun.com/AndyJson/article/details/84137155</guid><author>AndyJson</author><pubDate>Fri, 16 Nov 2018 12:24:38 +0800</pubDate><description><![CDATA[
题目
给定一个循环数组（最后一个元素的下一个元素是数组的第一个元素），输出每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1。
示例

输入: [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2；
数字 2 找不到下一个更大的数；
第二个 ...]]></description><category></category></item><item><title><![CDATA[栈---验证二叉树的前序序列]]></title><link>https://blog.youkuaiyun.com/AndyJson/article/details/84135696</link><guid>https://blog.youkuaiyun.com/AndyJson/article/details/84135696</guid><author>AndyJson</author><pubDate>Fri, 16 Nov 2018 10:59:21 +0800</pubDate><description><![CDATA[
题目
序列化二叉树的一种方法是使用前序遍历。当我们遇到一个非空节点时，我们可以记录下这个节点的值。如果它是一个空节点，我们可以使用一个标记值记录，例如 #。

    _9_
    /   \
   3     2
  / \   / \
 4   1  #  6
/ \ / \   / \
# # # #   # #

例如，上面的二叉树可以被序列化为字符串 &quot;9,3,4,#,#,1,#,#...]]></description><category></category></item><item><title><![CDATA[栈---二叉树的锯齿形层次遍历]]></title><link>https://blog.youkuaiyun.com/AndyJson/article/details/84134834</link><guid>https://blog.youkuaiyun.com/AndyJson/article/details/84134834</guid><author>AndyJson</author><pubDate>Fri, 16 Nov 2018 10:22:40 +0800</pubDate><description><![CDATA[
题目
给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
示例

给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回锯齿形层次遍历如下：

[
  [3],
  [20,9],
  [15,7]
]


代码实现

import ...]]></description><category></category></item><item><title><![CDATA[栈---括号的分数]]></title><link>https://blog.youkuaiyun.com/AndyJson/article/details/84067882</link><guid>https://blog.youkuaiyun.com/AndyJson/article/details/84067882</guid><author>AndyJson</author><pubDate>Wed, 14 Nov 2018 15:48:27 +0800</pubDate><description><![CDATA[
题目
给定一个平衡括号字符串 S，按下述规则计算该字符串的分数： 给定一个平衡括号字符串 S，按下述规则计算该字符串的分数：
() 得 1 分。
AB 得 A + B 分，其中 A 和 B 是平衡括号字符串。
(A) 得 2 * A 分，其中 A 是平衡括号字符串。
示例

输入： &amp;quot;()&amp;quot;
输出： 1

输入： &amp;quot;(())&amp;quot;
输出： 2

输入： &amp;quot;()()&amp;quot;
输出：]]></description><category></category></item><item><title><![CDATA[栈---二叉搜索树迭代器]]></title><link>https://blog.youkuaiyun.com/AndyJson/article/details/84067324</link><guid>https://blog.youkuaiyun.com/AndyJson/article/details/84067324</guid><author>AndyJson</author><pubDate>Wed, 14 Nov 2018 15:26:08 +0800</pubDate><description><![CDATA[
题目
实现一个二叉搜索树迭代器。你将使用二叉搜索树的根节点初始化迭代器。
调用 next() 将返回二叉搜索树中的下一个最小的数。
注意: next() 和hasNext() 操作的时间复杂度是O(1)，并使用 O(h) 内存，其中 h 是树的高度。
概念
二叉搜索树概念：
（1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；
（2）若右子树不空，则右子树上所有结点的值均大于它的根结...]]></description><category></category></item><item><title><![CDATA[栈---每日温度]]></title><link>https://blog.youkuaiyun.com/AndyJson/article/details/84066616</link><guid>https://blog.youkuaiyun.com/AndyJson/article/details/84066616</guid><author>AndyJson</author><pubDate>Wed, 14 Nov 2018 14:57:37 +0800</pubDate><description><![CDATA[
题目
根据每日气温列表，请重新生成一个列表，对应位置的输入是你需要再等待多久温度才会升高的天数。如果之后都不会升高，请输入 0 来代替。
示例

例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，
你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。


代码实现
思路：可类比找下一个更大元素。
提示：气温 列表长度...]]></description><category></category></item><item><title><![CDATA[栈---扁平化嵌套列表迭代器]]></title><link>https://blog.youkuaiyun.com/AndyJson/article/details/84033535</link><guid>https://blog.youkuaiyun.com/AndyJson/article/details/84033535</guid><author>AndyJson</author><pubDate>Tue, 13 Nov 2018 18:24:06 +0800</pubDate><description><![CDATA[
题目
给定一个嵌套的整型列表。设计一个迭代器，使其能够遍历这个整型列表中的所有整数。
列表中的项或者为一个整数，或者是另一个列表。
示例

输入: [[1,1],2,[1,1]]
输出: [1,1,2,1,1]
解释: 通过重复调用 next 直到 hasNext 返回false，next 返回的元素的顺序应该是: [1,1,2,1,1]。

输入: [1,[4,[6]]]
输出: [1,4,6...]]></description><category></category></item><item><title><![CDATA[栈---二叉树的前序遍历]]></title><link>https://blog.youkuaiyun.com/AndyJson/article/details/84028327</link><guid>https://blog.youkuaiyun.com/AndyJson/article/details/84028327</guid><author>AndyJson</author><pubDate>Tue, 13 Nov 2018 14:27:50 +0800</pubDate><description><![CDATA[
题目
给定一个二叉树，返回它的前序遍历。
示例

输入: [1,null,2,3]  
   1
    \
     2
    /
   3 

输出: [1,2,3]


代码实现
方法一：
a.根节点入栈；
b.弹出根节点，访问根节点；判断右孩子是否为空，如果不为空，push入栈；判断左孩子是否为空，如果不为空，push入栈。
注：右孩子先入栈，左孩子后入栈，这样可以保证下一次出栈的时候...]]></description><category></category></item><item><title><![CDATA[栈---二叉树的中序遍历]]></title><link>https://blog.youkuaiyun.com/AndyJson/article/details/84027133</link><guid>https://blog.youkuaiyun.com/AndyJson/article/details/84027133</guid><author>AndyJson</author><pubDate>Tue, 13 Nov 2018 13:06:50 +0800</pubDate><description><![CDATA[
题目
给定一个二叉树，返回它的中序 遍历。
示例

输入: [1,null,2,3]
   1
    \
     2
    /
   3

输出: [1,3,2]


代码实现
对于任意节点，若其左孩子不为空，则将该节点入栈，并将其左孩子置为当前节点，再进行相同处理；
若其左孩子为空，弹出栈顶元素，访问该栈顶元素，然后将栈顶元素的右孩子置为当前节点；
直到当前节点为null并且栈为空则遍历...]]></description><category></category></item><item><title><![CDATA[栈---有效的括号]]></title><link>https://blog.youkuaiyun.com/AndyJson/article/details/83989875</link><guid>https://blog.youkuaiyun.com/AndyJson/article/details/83989875</guid><author>AndyJson</author><pubDate>Mon, 12 Nov 2018 12:12:46 +0800</pubDate><description><![CDATA[
题目
给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
示例

输入: &quot;()&quot;
输出: true

输入: &quot;()[]{}&quot;
输出: true

输入: &quot;(]&quot;
输出: false

输入: &quot;([)]&quot;
输出: false
...]]></description><category></category></item><item><title><![CDATA[栈---比较含退格的字符串]]></title><link>https://blog.youkuaiyun.com/AndyJson/article/details/83989133</link><guid>https://blog.youkuaiyun.com/AndyJson/article/details/83989133</guid><author>AndyJson</author><pubDate>Mon, 12 Nov 2018 11:24:36 +0800</pubDate><description><![CDATA[
题目
给定 S 和 T 两个字符串，当它们分别被输入到空白的文本编辑器后，判断二者是否相等，并返回结果。 # 代表退格字符。
示例

输入：S = &quot;ab#c&quot;, T = &quot;ad#c&quot;
输出：true
解释：S 和 T 都会变成 “ac”。

输入：S = &quot;ab##&quot;, T = &quot;c#d#&quot;
输出：true
解释：S 和 T 都会变成 “”。

输入：S = &quot;a##c&quot;, T = &quot;#a#c.]]></description><category></category></item></channel></rss>