链表模板
链表结构
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; }
}
虚拟头节点
虚拟头节点用于是链表每一个节点都具有前一个节点，结构统一，可以规避特殊情况，使得链表头节点也可以当作普通节点处理。
ListNode dummy = new ListNode(-1);
dummy.next = head;
/**********/
return dummy.next;
获取链表倒数第k个节点
ListNode dummy = new ListNode(-1);
dummy.next = head; //虚拟头节点
ListNode l = dummy; //l是慢指针，指向虚拟头节点
ListNode r = dummy; //r是快指针，指向虚拟头节点
for (int i = 0; i < k; i++) {
r = r.next; //快指针移动k次
}
while (r != null) {
l = l.next;
r = r.next;
}
// l所指向的节点就是链表倒数第k个节点
链表节点交换
ListNode tmp = pos.next;
pos.next = cur;
cur.next = tmp;
pre.next = pos;
链表反转
整个链表反转
🌈 法一：使用虚拟头节点
public ListNode reverseList(ListNode head) {
if(head == null || head.next == null) return head;
ListNode dummy = new ListNode(-1);
dummy.next = head;
ListNode pre = dummy;
ListNode cur = dummy.next;
while(cur != null) {
ListNode tmp = cur.next;
cur.next = pre;
pre = cur;
cur = tmp;
}
dummy.next.next = null;
dummy.next = pre;
return dummy.next;
}
🌈 法二：不使用虚拟头节点（最快的方式）
public ListNode reverseList(ListNode head) {
if(head == null || head.next == null) return head;
ListNode pre = null;
ListNode cur = head;
while(cur != null) {
ListNode t = cur.next;
cur.next = pre;
pre = cur;
cur = t;
}
return pre;
}
链表局部反转
翻转链表从left到right范围内的节点
比如：翻转第2到第4个节点之间的链表
public ListNode reverseBetween(ListNode head, int left, int right) {
int length = right - left + 1; //一共要反转length个节点
ListNode dummy = new ListNode(-1);
dummy.next = head;
ListNode hh = dummy; //hh指向目标反转范围的前一个节点
while(left-- > 1) {
hh = hh.next;
}
ListNode a = hh.next, b = a.next;
while(length-- > 1) { //一共要反转length个节点， 中间就有 length - 1 个 next 指针需要翻转
ListNode tmp = b.next;
b.next = a;
a = b;
b = tmp;
}
hh.next.next = b;
hh.next = a;
return dummy.next;
}
双向链表
🌈 节点：
class Node{
int k,v;
Node l,r;
Node(int key, int value){
this.k = key;
this.v = value;
}
}
🌈 虚拟头尾节点
🌈 双向链表节点的插入
target.r = node.r;
node.r.l = target;
target.l = node;
node.r = target
🌈 双向链表节点的删除
node.r.l = node.l;
node.l.r = node.r;
例题
两数相加
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例 1：
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]
提示：
每个链表中的节点数在范围 [1, 100] 内
0 <= Node.val <= 9
题目数据保证列表表示的数字不含前导零
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
if (l1 == null) return l2;
if (l2 == null) return l1;
ListNode head = new ListNode(0); //虚拟头节点
ListNode tail = head;
int addition = 0; //记录进位
while (l1 != null && l2 != null) {
int num = l1.val + l2.val + addition;
if (num >= 10) { //两数和大于0，进位为1；否则进位为0
addition = 1;
num -= 10;
} else
addition = 0;
tail.next = new ListNode(num); //尾插法
tail = tail.next;
l1 = l1.next;
l2 = l2.next;
}
while (l1 != null) { //再处理l1和l2中长的链表
int num = l1.val + addition;
if (num >= 10) {
addition = 1;
num -= 10;
} else addition = 0;
tail.next = new ListNode(num);
tail = tail.next;
l1 = l1.next;
}
while (l2 != null) {
int num = l2.val + addition;
if (num >= 10) {
addition = 1;
num -= 10;
} else addition = 0;
tail.next = new ListNode(num);
tail = tail.next;
l2 = l2.next;
}
if (addition == 1) { //注意如果最后一次运算仍然有进位（1+9）
//需要再创建一个节点保存进位
tail.next = new ListNode(1);
tail = tail.next;
}
return head.next;
}
}
删除链表的倒数第 N 个结点
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
进阶：你能尝试使用一趟扫描实现吗？
示例 1：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：
输入：head = [1], n = 1
输出：[]
示例 3：
输入：head = [1,2], n = 1
输出：[1]
提示：
链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
if (head == null) return head;
ListNode h = new ListNode(0); //虚拟头节点
h.next = head;
ListNode l = h; //l指向目标节点的前一个节点
ListNode r = h; //r是快指针
for (int i = 0; i < n; i++) {
r = r.next;
}
while (r.next != null) {
l = l.next;
r = r.next;
}
if (l.next.next == null) l.next = null;
else {
l.next = l.next.next;
}
return h.next;
}
}
合并两个有序链表
LeetCode 21.https://leetcode-cn.com/problems/merge-two-sorted-lists/
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例 1：
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
示例 2：
输入：l1 = [], l2 = []
输出：[]
示例 3：
输入：l1 = [], l2 = [0]
输出：[0]
提示：
两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 非递减顺序 排列
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
ListNode h = new ListNode(0); //虚拟头节点
ListNode tail = h;
while (l1 != null && l2 != null) {
if (l1.val < l2.val) {
tail.next = l1; //尾插法
tail = tail.next;
l1 = l1.next;
} else {
tail.next = l2;
tail = tail.next;
l2 = l2.next;
}
}
if (l1 != null) tail.next = l1; //处理l1和l2中长的剩余链表
if (l2 != null) tail.next = l2;
return h.next;
}
}
合并K个升序链表
给你一个链表数组，每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中，返回合并后的链表。
示例 1：
输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
1->4->5,
1->3->4,
2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6
示例 2：
输入：lists = []
输出：[]
示例 3：
输入：lists = [[]]
输出：[]
提示：
k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] 按 升序 排列
lists[i].length 的总和不超过 10^4
class Solution {
public ListNode mergeKLists(ListNode[] lists) {
PriorityQueue<ListNode> q = new PriorityQueue<>((a, b) -> a.val - b.val);
for (ListNode node : lists) { //第一次一股脑把所有链表的头节点塞进优先队列
if (node != null) q.add(node);
}
ListNode h = new ListNode(0); //虚拟头节点
ListNode tail = h;
while (!q.isEmpty()) {
ListNode node = q.poll(); //每次弹出最小的节点
tail.next = node; //尾插法
tail = tail.next;
if (node.next != null) q.add(node.next); //弹出节点的后继节点放入队列
}
return h.next;
}
}
两两交换链表中的节点
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例 1：
输入：head = [1,2,3,4]
输出：[2,1,4,3]
示例 2：
输入：head = []
输出：[]
示例 3：
输入：head = [1]
输出：[1]
提示：
链表中节点的数目在范围 [0, 100] 内
0 <= Node.val <= 100
进阶：你能在不修改链表节点值的情况下解决这个问题吗?（也就是说，仅修改节点本身。）
class Solution {
public ListNode swapPairs(ListNode head) {
if(head==null || head.next==null) return head;
ListNode dummy = new ListNode(0);
dummy.next = head;
ListNode cur = dummy;
while(cur.next != null && cur.next.next != null) {
ListNode a = cur.next;
ListNode b = a.next;
cur.next = b;
a.next = b.next;
b.next = a;
cur = a;
}
return dummy.next;
}
}
K 个一组翻转链表
给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。
k 是一个正整数，它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
进阶：
你可以设计一个只使用常数额外空间的算法来解决此问题吗？
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。
示例 1：
输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]
示例 2：
输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]
示例 3：
输入：head = [1,2,3,4,5], k = 1
输出：[1,2,3,4,5]
示例 4：
输入：head = [1], k = 1
输出：[1]
提示：
列表中节点的数量在范围 sz 内
1 <= sz <= 5000
0 <= Node.val <= 1000
1 <= k <= sz
class Solution {
public ListNode reverseKGroup(ListNode head, int k) {
if (head == null || head.next == null) return head;
ListNode dummy = new ListNode(-1); //虚拟头节点
dummy.next = head;
ListNode cur = dummy; //cur指向反转链表前一个节点
while (cur != null) {
reverse(cur, k);
int u = k;
while (u-- > 0 && cur != null) {
cur = cur.next;
}
}
return dummy.next;
}
public void reverse(ListNode root, int k) {
int u = k;
ListNode cur = root;
while (u-- > 0 && cur != null) cur = cur.next;
if (cur == null) return;
ListNode a = root.next;
ListNode b = a.next;
// 当需要翻转 k 个节点时，中间就有 k - 1 个 next 指针需要翻转
while (k-- > 1) {
ListNode tmp = b.next;
b.next = a;
a = b;
b = tmp;
}
root.next.next = b;
root.next = a;
}
}
旋转链表
给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。
示例 1：
输入：head = [1,2,3,4,5], k = 2
输出：[4,5,1,2,3]
示例 2：
输入：head = [0,1,2], k = 4
输出：[2,0,1]
提示：
链表中节点的数目在范围 [0, 500] 内
-100 <= Node.val <= 100
0 <= k <= 2 * 109
思路：
-
注意到k的数据极大，要对k取模，避免不必要的循环。
-
遍历链表，首尾相连，形成环形链表。
-
在length - k的位置断开链表，返回下一个节点即可。
class Solution {
public ListNode rotateRight(ListNode head, int k) {
if (head == null || head.next == null) return head;
ListNode dummy = new ListNode(0);
dummy.next = head;
ListNode a = head;
ListNode b = a.next;
int length = 1;
while (b != null) {
a = a.next;
b = b.next;
length++;
}
a.next = head;
k = k % length;
int cnt = length - k;
while (cnt-- > 0) dummy = dummy.next;
ListNode ans = dummy.next;
dummy.next = null;
return ans;
}
}
删除排序链表中的重复元素
存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除链表中所有存在数字重复情况的节点，只保留原始链表中 没有重复出现 的数字。
返回同样按升序排列的结果链表。
示例 1：
输入：head = [1,2,3,3,4,4,5]
输出：[1,2,5]
示例 2：
输入：head = [1,1,1,2,3]
输出：[2,3]
提示：
链表中节点数目在范围 [0, 300] 内
-100 <= Node.val <= 100
题目数据保证链表已经按升序排列
class Solution {
public ListNode deleteDuplicates(ListNode head) {
ListNode dummy = new ListNode();
ListNode tail = dummy;
while (head != null) {
// 进入循环时，确保了 head 不会与上一节点相同
if (head.next == null || head.val != head.next.val) {
tail.next = head;
tail = head;
}
// 如果 head 与下一节点相同，跳过相同节点
while (head.next != null && head.val == head.next.val) head = head.next;
head = head.next;
}
tail.next = null;
return dummy.next;
}
}
存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除所有重复的元素，使每个元素 只出现一次 。
返回同样按升序排列的结果链表。
示例 1：
输入：head = [1,1,2]
输出：[1,2]
示例 2：
输入：head = [1,1,2,3,3]
输出：[1,2,3]
提示：
链表中节点数目在范围 [0, 300] 内
-100 <= Node.val <= 100
题目数据保证链表已经按升序排列
class Solution {
public ListNode deleteDuplicates(ListNode head) {
if(head==null||head.next==null) return head;
ListNode index = head;
while(index.next!=null){
if(index.val==index.next.val){
index.next = index.next.next;
}else{
index = index.next;
}
}
return head;
}
}
相交链表
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
图示两个链表在节点 c1 开始相交：
题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。
示例 1：
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
示例 2：
输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。
示例 3：
输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。
提示：
listA 中节点数目为 m
listB 中节点数目为 n
0 <= m, n <= 3 * 104
1 <= Node.val <= 105
0 <= skipA <= m
0 <= skipB <= n
如果 listA 和 listB 没有交点，intersectVal 为 0
如果 listA 和 listB 有交点，intersectVal == listA[skipA + 1] == listB[skipB + 1]
思路：
- 差值解法：先对两条链表扫描一遍，取得两者长度，然后让长的链表先走「两者的长度差值」，然后再同时走，遇到第一个节点即是答案。
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
if(headA == headB) return headA;
ListNode a = headA;
ListNode b = headB;
int lenA = 0;
int lenB = 0;
while(a != null) {
a = a.next;
lenA++;
}
while(b != null) {
b = b.next;
lenB++;
}
if(lenB > lenA) {
int l = lenB - lenA;
while(l-- > 0) {
headB = headB.next;
}
}
else{
int l = lenA - lenB;
while(l-- > 0) {
headA = headA.next;
}
}
while(headA != null && headB != null) {
if(headA == headB) return headA;
headA = headA.next;
headB = headB.next;
}
return null;
}
}
环形链表
给定一个链表，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
如果链表中存在环，则返回 true 。 否则，返回 false 。
进阶：
你能用 O(1)（即，常量）内存解决此问题吗？
示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：
输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：
输入：head = [1], pos = -1
输出：false
解释：链表中没有环。
提示：
链表中节点的数目范围是 [0, 104]
-105 <= Node.val <= 105
pos 为 -1 或者链表中的一个 有效索引 。
快慢指针法：
public class Solution {
public boolean hasCycle(ListNode head) {
if(head == null) return false;
ListNode fast = head;
ListNode slow = head;
while(fast != null && fast.next != null) {
fast = fast.next.next;
slow = slow.next;
if(fast == slow) return true;
}
return false;
}
}
给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。
说明：不允许修改给定的链表。
进阶：
你是否可以使用 O(1) 空间解决此题？
示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：
输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：
输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。
提示：
链表中节点的数目范围在范围 [0, 104] 内
-105 <= Node.val <= 105
pos 的值为 -1 或者链表中的一个有效索引
public class Solution {
public ListNode detectCycle(ListNode head) {
if(head == null || head.next == null) return null;
ListNode fast = head;
ListNode slow = head;
while(fast != null && fast.next != null) {
fast = fast.next.next;
slow = slow.next;
if(fast == slow) {
break;
}
}
if(fast == null || fast.next == null) return null;
fast = head;
while(fast != slow) {
fast = fast.next;
slow = slow.next;
}
return fast;
}
}
奇偶链表
给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。
请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1)，时间复杂度应为 O(nodes)，nodes 为节点总数。
示例 1:
输入: 1->2->3->4->5->NULL
输出: 1->3->5->2->4->NULL
示例 2:
输入: 2->1->3->5->6->4->7->NULL
输出: 2->3->6->7->1->5->4->NULL
说明:
应当保持奇数节点和偶数节点的相对顺序。
链表的第一个节点视为奇数节点，第二个节点视为偶数节点，以此类推。
class Solution {
public ListNode oddEvenList(ListNode head) {
if(head == null || head.next == null) return head;
ListNode evenHead = head.next;
ListNode odd = head;
ListNode even = evenHead;
while(even != null && even.next != null) {
odd.next = odd.next.next;
odd = even.next;
even.next = even.next.next;
even = odd.next;
}
odd.next = evenHead;
return head;
}
}
回文链表
给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。
示例 1：
输入：head = [1,2,2,1]
输出：true
示例 2：
输入：head = [1,2]
输出：false
提示：
链表中节点数目在范围[1, 105] 内
0 <= Node.val <= 9
进阶：你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？
思路：后半段链表反转，一个指针指开头，一个指针指中间，双指针扫描
class Solution {
public boolean isPalindrome(ListNode head) {
if(head.next == null) return true;
ListNode dummy = new ListNode(0);
dummy.next = head;
ListNode l = dummy;
ListNode r = dummy;
while(r != null && r.next != null) {
l = l.next;
r = r.next.next;
}
ListNode a = l.next;
ListNode b = a.next;
while(b != null) {
ListNode tmp = b.next;
b.next = a;
a = b;
b = tmp;
}
l.next.next = b;
l.next = a;
ListNode right = l.next;
ListNode left = dummy.next;
while(right != null) {
if(right.val != left.val) return false;
left = left.next;
right = right.next;
}
return true;
}
}
LRU 缓存机制
运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制 。
实现 LRUCache 类：
LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。
进阶：你是否可以在 O(1) 时间复杂度内完成这两种操作？
示例：
输入
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]
解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1); // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2); // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1); // 返回 -1 (未找到)
lRUCache.get(3); // 返回 3
lRUCache.get(4); // 返回 4
提示：
1 <= capacity <= 3000
0 <= key <= 10000
0 <= value <= 105
最多调用 2 * 105 次 get 和 put
class LRUCache {
Map<Integer,Node> map;
int n;
Node head;
Node tail;
class Node{
int k,v;
Node l,r;
Node(int key, int value){
this.k = key;
this.v = value;
}
}
public LRUCache(int capacity) {
n = capacity;
map = new HashMap<>();
head = new Node(-1, -1);
tail = new Node(-1, -1);
head.r = tail;
tail.l = head;
}
public int get(int key) {
if(map.containsKey(key)) {
Node node = map.get(key);
refresh(node);
return node.v;
}
return -1;
}
public void put(int key, int value) {
Node node = null;
if(map.containsKey(key)) {
node = map.get(key);
node.v = value;
}else {
if(n == map.size()) {
Node del = tail.l;
map.remove(del.k);
delete(del);
}
node = new Node(key, value);
map.put(key, node);
}
refresh(node);
}
public void refresh(Node node) {
delete(node);
node.r = head.r;
node.l = head;
head.r.l = node;
head.r = node;
}
public void delete(Node node) {
if(node.l != null) {
Node tmp = node.r;
node.l.r = node.r;
tmp.l = node.l;
}
}
}