chapter_tree/avl_tree/

[giscus[bot]]

chapter_tree/avl_tree/

Your first book to learn Data Structure And Algorithm.

https://www.hello-algo.com/chapter_tree/avl_tree/

[hello-ikun]

这部分确实是有点难度

[krahets]

很是同意，所以本章标了选读符号 doge

[hello-ikun]

k宝 你说的并查集什么时候更新呢

[krahets]

并查集近期不会更新 T T

[zrcoder]

@xia-Sang 之前写过一篇并查集，虚构程序员写武侠游戏的故事来说： https://rdcode.netlify.app/docs/graph/union-find/index.html

[hello-ikun]

感谢你的回复！

[symbolworld]

K神有时间可以更新一章红黑树的区别吗？想看看它们的区别和各自的应用场景，感谢！

[krahets]

红黑树暂时不在内容大纲里，抱歉哇！近期应该不会更新

[Mahaotian1]

您好，请问python的会更新吗

[krahets]

已更新～

[anzhen3531]

K神会更新图数据结构嘛 ？

[krahets]

必须的！

[GarveyH]

大佬，请问这一节中哪些函数归在private，哪些函数归在public中，这方面有什么考量吗？比如为什么要将 height 函数和 updateHeight 函数 分别放在 public 和 private 中呢？

[krahets]

Hi! 主要看方法的使用范围，如果方法只在类内部使用（一般也不希望用户调用），那么就设计为 private ，比如用户单独调用 updateHeight() 是没有意义的，它只是插入、删除操作中的一步。而 height() 是访问结点高度，类似于 vector.size() ，可以设置成 public 以便使用。

[TujinLee]

有个疑问，我看右旋操作是处理失衡节点node、child、grandchild之间的关系，那node的父级和node原来的连接不需要维护吗？右旋操作后岂不是断掉了？

[krahets]

@jiangyuxustore Bingo! 或者可以把“该节点的左子树中的最大节点”替换到删除节点上，本质上是不希望破坏二叉搜索树“左<根<右”的性质。

[plwater]

removeHelper(TreeNode node, int val) 方法（Java代码）的注释我觉得写得不是很规范，导致这部分代码有点晦涩难懂（也有可能是我太菜了ww），需要花很多时间和翻看评论区的讨论才能逐渐消化，如果把算法的方法注释（特别是方法入口处的注释）写得规范一点，我想对于帮助读者自行消化可能会起到很大的帮助，也会让这个项目价值更高。
特别感谢K老师和其他人的开源贡献，最近复习算法，收获特别大。
下面是根据我的理解补充的注释，可能不准确，仅为参考。

 /**
     * 递归删除节点（辅助方法）
     * @param node 二叉树的根节点（也可能是二叉树子树的根节点）
     * @param val 要删除的节点的值
     * @return 删除对应节点后的子树的根节点
     */
    private TreeNode removeHelper(TreeNode node, int val) {
    }

[krahets]

@plwater Hi，谢谢建议！建议前往代码仓库下载完整代码并运行，在调试过程中理解复杂代码。本书为了提升篇幅的紧凑性，部分放弃了代码注释的规范性

[plwater]

感谢建议，我会尝试在本地调试，理解你的用意了。

[xlyyddy]

       # 先左旋后右旋
        node.left = self.left_rotate(node.left)
        return self.right_rotate(node)

那这个是不是应该在左旋函数返回之后进行子树的根节点和其父节点的连接啊

[CAgent05]

k神，这部分还会介绍红黑树吗？

[krahets]

正在考虑～！

[fallenleavesguy]

一定要介绍啊，我的大佬，嘿嘿

[limuzi9806]

加一

[Hutu-666]

大佬，想问一下，updateHeight()方法里为啥要 + 1 操作？

[krahets]

Hi，这个公式的含义是 高度 = max(左子树高度, 右子树高度) + 1 。其中，左子树高度和右子树高度是不包含该节点的高度的，因此要加 1 。

[UFO583]

/* 右旋操作 */
TreeNode *rightRotate(TreeNode *node) {
TreeNode *child = node->left;
TreeNode *grandChild = child->right;
// 以 child 为原点，将 node 向右旋转
child->right = node;
node->left = grandChild;
// 更新节点高度
updateHeight(node);
updateHeight(child);
// 返回旋转后子树的根节点
return child;
}
K神为什么这里没有更新 grandChild 的高度呢

[krahets]

Hi ，这是因为执行右旋（或左旋）后，节点 grandChild 的高度不会改变，可以观察文中配图来验证一下

[bethewind]

讲的不错,经过你的讲解感觉AVL树只有红黑树10%的难度

[hello-ikun]

复刻了一下 感觉可以的

[riiyn]

大佬，先左旋再右旋那张图，child.left=node, node.left=null也可以达到平衡吧，只是破坏了二叉搜索树的规则，这种做法属于左旋吗？左旋的时候child既可以取node左子节点也可以取右子节点吧，右旋同理

[krahets]

是的，这样会破坏二叉搜索树的性质，所以不能称为旋转操作了。旋转操作的意义就是在保持二叉搜索树性质的基础上，恢复二叉树的平衡性。两者缺一不可

[riiyn]

@krahets 明白了，谢谢大佬，还有个疑问，rotate那个方法，node的平衡因子判断应该是>0和<0吧，要不然不是忽略了1和-1的情况

[krahets]

@riiyn 客气啦，平衡因子判断是 $&gt; 1$ 和 $&lt; -1$ ，因为子树在这种情况下才是失衡的，${-1, 0, 1}$ 这三种情况是平衡状态，无需旋转。

[bukexiusi]

if t.balanceFactor(node.Left) >= 0 {
// 右旋
return t.rightRotate(node)
} else {
// 先左旋后右旋
node.Left = t.leftRotate(node.Left)
return t.rightRotate(node)
}

为什么判断条件是 >= 0，是不是 > 0 也可以，因为左右高度差不可能为 0

[krahets]

Hi，node.left 的左右高度差可能为 0 哈。例如在文中的 grandChild 底下再添加一个子节点。

[Liuhyi]

=0的时候可以直接右旋，也可以先左旋在右旋

[wanlufun]

为什么不用 updateHeight(grandChild) 呀？

[wanlufun]

我懂了 我懂了 基础知识忘记啦

分析原因

节点的高度，只与这个节点的子节点高度有关，由于没有修改grandchild 的子节点， 所以不需要updateHeight(grandChild)

[jincet]

这里讲的真好，清楚易懂

[CNiq527]

文章已经写的很清晰了，但是没有动图， 看了这篇文章更好理解 🫡

[CNiq527]

另外树旋转的图中，节点底下的数字描述的是平衡因子，对于新手可能不能第一时间反应过来

[0101qwe]

我想知道这个应该学到什么程度才算掌握啊，是不是要能凭借自己可以全敲出来才算掌握，然后在去学下一个结构啊

[Kruogu]

第1遍先快速理解大意，之后可以再集中写一遍所有算法，相信没有人仅凭一次学习就可以掌握数据结构与算法，都是需要反复刷题练习，在一次次debug中加深对算法的理解，最终才能彻底掌握数据结构。

[double-leaves]

这个左旋右旋操作结束后，原本指向node的pre会直接指向操作后的child吗?是操作少了一步还是我的理解有问题

[MrPans]

你看，方法传入是 node, return 是 child。 node 的 parent 节点的指针不在右旋左旋的方法处理范围内。按照递归的思想，应该是在调用 rotate 方法处拿到 return 回来的指针后更新。

[MrPans]

把插入部分的代码连起来看，insertHelper 里面 return 了一个新的 node 指针，insert 方法中更新了 root 指针。

[MottoYoung]

+1

[MottoYoung]

看完插入了，左右旋的时候返回的是孩子，也就是如果旋转的话，inserthelper返回的是要选旋转的那个节点的孩子节点，即在if的条件判断力，node的孩子指向了要指向的节点

[HighBigSky]

手搓翻转红黑

[HighBigSky]

//我一个一个右鞭腿，一个左正蹬

// 右旋操作
public void rightRotate(TreeNode x) {
    if (x == null || x.left == null) {
        return;
    }

    TreeNode y = x.left; // y 是 x 的左子节点
    TreeNode T3 = y.right; // T3 是 y 的右子节点

    // 将 T3 设置为 x 的左子节点
    x.left = T3;
    if (T3 != null) {
        T3.parent = x;
    }

    // 将 y 的右子节点设置为 x
    y.right = x;

    // 更新 x 的父节点
    y.parent = x.parent;
    x.parent = y;

    // 更新 y 的父节点的子节点指针
    if (y.parent == null) {
        // 如果 x 是根节点，更新根节点为 y
        // 在实际的红黑树实现中，需要更新根节点的引用
    } else if (x == y.parent.left) {
        y.parent.left = y;
    } else {
        y.parent.right = y;
    }
}

// 左旋操作
public void leftRotate(TreeNode x) {
if (x == null || x.right == null) {
return;
}

    TreeNode y = x.right; // y 是 x 的右子节点
    TreeNode T3 = y.left; // T3 是 y 的左子节点

    // 将 T3 设置为 x 的右子节点
    x.right = T3;
    if (T3 != null) {
        T3.parent = x;
    }

    // 将 y 的左子节点设置为 x
    y.left = x;

    // 更新 x 的父节点
    y.parent = x.parent;
    x.parent = y;

    // 更新 y 的父节点的子节点指针
    if (y.parent == null) {
        // 如果 x 是根节点，更新根节点为 y
        // 在实际的红黑树实现中，需要更新根节点的引用
    } else if (x == y.parent.left) {
        y.parent.left = y;
    } else {
        y.parent.right = y;
    }
}

[fuochai]

这个树是要每次增减都进行维护才能保持平衡吗？
如果初始是

[[2],
[1,5],
[None,None,4,6],
[None,None,None,None,3,None,None,None]]

就会死循环吧

[sacredcodex]

自下而上，根节点2不平衡，高的在右子节点，右子节点的左子节点更高，所以先对节点5做右旋，然后根节点2做左旋。

        2
       / \
      1   5
         / \
        4   6
       /
      3

节点5右旋

        2
       / \
      1   4
         / \
        3   5
             \
              6

节点2左旋

        4
       / \
      2   5
     / \   \
    1   3   6

[SuperZhangRui]

我看完了，， 但感觉好难实现啊， 我准备实现以下，，，

[SuperZhangRui]

频繁的递归操作， 要对递归有很深的理解才能实现。。。。。

[SuperZhangRui]

写了一个小时 eeee
package thread.method.day3;

/**

• 实现一个AVL树
  */
  public class AVLTree <E extends Comparable> {
  private TreeNode root;
  private int size;

  class TreeNode{
  E value;
  TreeNode left;
  TreeNode right;
  int height; // 节点的高度
  public TreeNode(E value) {
  this.value = value;
  }
  }
  /**

  • Avl是一种 平衡的二叉搜索树
  • 搜索与普通的二叉查找树一样
  • 插入以及删除节点的时候需要维护每个节点的高度即树旋转
  • 有一个概念叫 节点平衡因子 f 其左节点的高度减去右节点的高度 AVL树的所有结节点的平衡因子都满足 -1<=f<=1
  • f > 1时 左子树比右子树高 需要右旋
  • f <-1 时 右子树比左子树高 需要 左旋
    */
    // 获得节点高度的函数
    int height(TreeNode node) {
    // 空节点高度为 -1 ，叶节点高度为 0
    return node == null ? -1 : node.height;
    }
    // 更新节点的高度
    void updateHight(TreeNode node){
    node.height = Math.max(height(node.left),height(node.right)) + 1;
    }

  // 计算节点的平衡因子 即 f
  int balanceFactor(TreeNode node) {
  // 空节点平衡因子为 0
  if (node == null)
  return 0;
  // 节点平衡因子 = 左子树高度 - 右子树高度
  return height(node.left) - height(node.right);
  }
  // 当 平衡因子 f > 1 时需要右旋
  // 方法返回 右旋以后的根节点
  // 入参是 需要右旋的子树的根节点
  TreeNode rightRotate(TreeNode node){
  TreeNode child = node.left;
  TreeNode grandChild = child.right;
  child.right = node;
  node.left = grandChild;
  // 还要更新node节点的高度
  updateHight(node);
  updateHight(child);
  return child;
  }

  // 当 平衡因子 f < 1 时需要左旋
  // 方法返回 左旋以后的根节点
  // 入参是 需要左旋的子树的根节点
  TreeNode leftRotate(TreeNode node){
  TreeNode child = node.right;
  TreeNode grandChild = child.left;
  child.left = node;
  node.right = grandChild;
  // 还要更新node节点的高度
  updateHight(node);
  updateHight(child);
  return child;
  }

  // 普通的右旋和左旋不能满足所有情况 当右旋时 child的右节点有值则需要 子节点先左旋
  // 即 当 f >1 时需要 右旋 但 f(child) < 0 需要子节点先左旋 且 反之亦然
  TreeNode rotate(TreeNode node) {
  int i = balanceFactor(node);
  if (i >1){
  int i1 = balanceFactor(node.right);
  if (i1 < 0){
  // 此时需要子节点先左旋 父节点再右旋
  node.right = leftRotate(node.right);
  return rightRotate(node);
  }else{
  return rightRotate(node);
  }
  }
  if (i < -1){
  int i1 = balanceFactor(node.left);
  if (i1 > 0){
  // 此时需要子节点先左旋 父节点再右旋
  node.left = rightRotate(node.left);
  return leftRotate(node);
  }else{
  return leftRotate(node);
  }
  }
  // 无需旋转
  return node;
  }

  // 插入元素
  // 思路： 普通的 二叉查找树的 插入方式， 但 每次插入节点后需要判断是否需要旋转
  void insert(E val) {
  root = insertHelper(root, val);
  }

  /* 递归插入节点（辅助方法） */
  TreeNode insertHelper(TreeNode node, E val) {
  if (node == null) {
  size++;
  return new TreeNode(val);
  }
  if (val.compareTo(node.value) < 0) { // 插入的元素 比 当前递归到的元素 小
  node.left = insertHelper(node.left, val);
  }else if(val.compareTo(node.value) > 0){
  node.right = insertHelper(node.right, val);
  }else{
  // 此时 该节点在 AVL树中已经有了 (即 该AVL树中不允许重复元素)
  return node;
  }
  // 节点插入元素之后要维护节点的高
  updateHight(node);
  // 还需要判断 树是否需要旋转
  node = rotate(node);
  return node;
  }

  void remove(E val) {
  root = removeHelper(root, val);
  }

  /* 递归插入节点（辅助方法） */
  TreeNode removeHelper(TreeNode node, E val) {
  if (node == null) return null;
  if (val.compareTo(node.value) < 0) { // 插入的元素 比 当前递归到的元素 小
  node.left = removeHelper(node.left, val);
  }else if(val.compareTo(node.value) > 0){
  node.right = removeHelper(node.right, val);
  }else{
  //终于找到你了小伙子
  if (node.left == null || node.right == null) {
  TreeNode child = node.left != null ? node.left : node.right;
  if (child == null) {
  return null;
  }else{
  node = child;
  }
  }else{
  // 当左右节点都存在时 取 右子节点的 最小节点即 最左的节点
  TreeNode child = node.right;
  while (child.left != null) {
  child = child.left;
  }
  E value = child.value;
  node.right = removeHelper(node.right, value);
  node.value = value;
  }
  }
  // 节点插入元素之后要维护节点的高
  updateHight(node);
  // 还需要判断 树是否需要旋转
  node = rotate(node);
  return node;
  }

  // 以下代码为测试代码

  // 我想写一个 可以直接把树结构遍历出来的方法
  public void preOrder(TreeNode root) {
  if (root == null) return;

   preOrder(root.left);              // 遍历左子树
   System.out.print(root.value + " "); // 访问根节点
   preOrder(root.right);             // 遍历右子树
  

  }

  public static void main(String[] args) {
  AVLTree tree = new AVLTree();
  tree.insert(1);
  tree.insert(2);
  tree.insert(3);
  tree.insert(7);
  tree.insert(0);

   tree.insert(4);
   tree.insert(4);
   tree.remove(3);
   tree.preOrder(tree.root);
  

  }
  }

[jiuerya7]

你的Rotate方法是不是写错了？
平衡因子大于1，说明是左偏衡，应该进一步对左子节点的平衡因子进行判断，而不是右子节点，而且，如果左子节点有右偏衡的话，应该更新的失衡节点的左子节点。然后你下面那个也是一样的

[xiaozhuge123]

day07

[Tans5]

先左旋后右旋的例子中如果 1 节点的左边有一个 0 的节点该怎么旋转？

[mygit10636]

个人理解，不是所有的二叉树都能旋转，必须是一个平衡二叉树 插入或删除节点后 变得不平衡了 才应该旋转，这样才能转平衡。

[mygit10636]

楼上说的好像也有道理，我也有点弄不清了

[mygit10636]

反正这个插入和删除操作都是在AVL树的基础上进行的

[mygit10636]

今天我又感觉楼上说的不对了【笑哭】

[sacredcodex]

所有二叉树都能旋转，只是AVL树在维护平衡的过程中，使用到了左旋和右旋

[MaOoOxiao]

失衡的节点旋转完成后，对于原先失衡的父节点来说这个操作应该是不可知的，他指向的还是失衡的节点。所以在main函数里面进行平衡的时候的代码是 root->right = rotate(root->right); 这样吗

[ustcxmz]

旋转的核心在于爸爸变儿子

[fug-0117]

写一个

// AVL树节点结构
template<typename T>
struct AVLNode {
    T key;
    AVLNode* left;
    AVLNode* right;
    int height;  // 节点高度
    
    AVLNode(T value) : key(value), left(nullptr), right(nullptr), height(1) {}
};

template<typename T>
class AVLTree {
private:
    AVLNode<T>* root;
    
    // 获取节点高度
    int height(AVLNode<T>* node) {
        return node ? node->height : 0;
    }
    
    // 获取平衡因子（左子树高度 - 右子树高度）
    int getBalance(AVLNode<T>* node) {
        return node ? height(node->left) - height(node->right) : 0;
    }
    
    /*
    初始状态：
        y
       / \
      x   γ
     / \
    α   T2

    右旋后：
        x
       / \
      α   y
         / \
        T2  γ
    */
    // 右旋操作
    AVLNode<T>* rightRotate(AVLNode<T>* y) {
        AVLNode<T>* x = y->left;
        AVLNode<T>* T2 = x->right;
        
        // 执行旋转
        x->right = y;
        y->left = T2;
        
        // 更新高度
        y->height = max(height(y->left), height(y->right)) + 1;
        x->height = max(height(x->left), height(x->right)) + 1;
        
        return x;  // 返回新的根节点
    }
    
    /*
    初始状态：
        x
       / \
      α   y
         / \
        T2  β

    左旋后：
        y
       / \
      x   β
     / \
    α   T2
    */
    // 左旋操作
    AVLNode<T>* leftRotate(AVLNode<T>* x) {
        AVLNode<T>* y = x->right;
        AVLNode<T>* T2 = y->left;
        
        // 执行旋转
        y->left = x;
        x->right = T2;
        
        // 更新高度
        x->height = max(height(x->left), height(x->right)) + 1;
        y->height = max(height(y->left), height(y->right)) + 1;
        
        return y;  // 返回新的根节点
    }
    
    // 插入节点（递归辅助函数）
    AVLNode<T>* insert(AVLNode<T>* node, T key) {
        // 1. 执行标准BST插入
        if (node == nullptr)
            return new AVLNode<T>(key);
            
        if (key < node->key)
            node->left = insert(node->left, key);
        else if (key > node->key)
            node->right = insert(node->right, key);
        else  // 不允许重复键
            return node;
        
        // 2. 修复平衡
        return fixBalance(node);
    }
    
    // 删除节点（递归辅助函数）
    AVLNode<T>* remove(AVLNode<T>* node, T key) {
        // 1. 执行标准BST删除
        if (node == nullptr)
            return node;
            
        // 递归查找要删除的节点
        if (key < node->key)
            node->left = remove(node->left, key);
        else if (key > node->key)
            node->right = remove(node->right, key);
        else {  // 找到要删除的节点
            // 节点只有一个子节点或没有子节点
            if (node->left == nullptr || node->right == nullptr) {
                AVLNode<T>* temp = node->left ? node->left : node->right;
                
                // 没有子节点的情况
                if (temp == nullptr) {
                    temp = node;
                    node = nullptr;
                } else {  // 有一个子节点的情况
                    *node = *temp;  // 复制子节点的数据到当前节点
                }
                
                delete temp;  // 释放内存
            } else {
                // 节点有两个子节点：获取右子树的最小键值
                AVLNode<T>* temp = minValueNode(node->right);
                
                // 复制后继节点的数据到当前节点
                node->key = temp->key;
                
                // 删除后继节点
                node->right = remove(node->right, temp->key);
            }
        }
        
        return fixBalance(node);  
    }
    
    // 找到最小键值节点（辅助函数）
    AVLNode<T>* minValueNode(AVLNode<T>* node) {
        AVLNode<T>* current = node;
        while (current->left != nullptr)
            current = current->left;
        return current;
    }
    
    // 平衡修复
    AVLNode<T>* fixBalance(AVLNode<T>* node) {
        if (!node) return nullptr;
        
        // 更新高度
        node->height = max(height(node->left), height(node->right)) + 1;
        
        // 获取平衡因子
        int balance = getBalance(node);
        
        // 四种失衡情况处理
        // 左左情况
        if (balance > 1 && getBalance(node->left) >= 0)
            return rightRotate(node);
            
        // 左右情况
        if (balance > 1 && getBalance(node->left) < 0) {
            node->left = leftRotate(node->left);  // 先左旋后右旋
            return rightRotate(node);
        }
        
        // 右右情况
        if (balance < -1 && getBalance(node->right) <= 0)
            return leftRotate(node);
            
        // 右左情况
        if (balance < -1 && getBalance(node->right) > 0) {
            node->right = rightRotate(node->right);  // 先右旋后左旋
            return leftRotate(node);
        }
        
        return node;  // 未失衡，直接返回
    }
    
    // 查找节点（递归辅助函数）
    bool search(AVLNode<T>* node, T key) const {
        if (node == nullptr)
            return false;
            
        if (key == node->key)
            return true;
        else if (key < node->key)
            return search(node->left, key);
        else
            return search(node->right, key);
    }
    
    // 中序遍历（辅助函数）
    void inorder(AVLNode<T>* node) const {
        if (node != nullptr) {
            inorder(node->left);
            cout << node->key << " ";
            inorder(node->right);
        }
    }
    
    // 销毁树（辅助函数）
    void destroyTree(AVLNode<T>* node) {
        if (node != nullptr) {
            destroyTree(node->left);
            destroyTree(node->right);
            delete node;
        }
    }
    
public:
    // 构造函数
    AVLTree() : root(nullptr) {}
    
    // 析构函数
    ~AVLTree() {
        destroyTree(root);
    }
    
    // 插入接口
    void insert(T key) {
        root = insert(root, key);
    }
    
    // 删除接口
    void remove(T key) {
        root = remove(root, key);
    }
    
    // 查找接口
    bool search(T key) const {
        return search(root, key);
    }
    
    // 中序遍历接口
    void inorder() const {
        inorder(root);
        cout << endl;
    }
};

[christophe-gu]

K神，非常感谢你的讲解！
对于删除的代码：

def remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None:
    """递归删除节点（辅助方法）"""
    if node is None:
        return None
    # 1. 查找节点并删除
    if val < node.val:
        node.left = self.remove_helper(node.left, val)
    elif val > node.val:
        node.right = self.remove_helper(node.right, val)
    else:
        if node.left is None or node.right is None:
            child = node.left or node.right
            # 子节点数量 = 0 ，直接删除 node 并返回
            if child is None:
                return None
            # 子节点数量 = 1 ，直接删除 node
            else:
                node = child
        else:
            # 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
            temp = node.right
            while temp.left is not None:
                temp = temp.left
            node.right = self.remove_helper(node.right, temp.val)
            node.val = temp.val
    # 更新节点高度
    self.update_height(node)
    # 2. 执行旋转操作，使该子树重新恢复平衡
    return self.rotate(node)

child = node.left or node.right 之后是否可以直接 return child? 感觉不需要更新节点高度及旋转。

[kINo204]

AVL树插入/删除之后，应该只需要对路径上第一个失衡节点做旋转，因为旋转会把高度更新限制在其子树内。不需要对整个路径都检查。

[christophe-gu]

感谢确认！

[MzoroHaHa]

我想问一个关于 红黑树的问题， 《算法导论》里面：

RB-DELETE(T, z)
1   y = z
2   y.original-color = y.color
3   if z.left == T.nil
4       x = z.right
5       RB-TRANSPLANT(T, z, z.right)
6   elseif z.right == T.nil
7       x = z.left
8       RB-TRANSPLANT(T, z, z.left)
9   else y = TREE-MINIMUM(z.right)
10      y.original-color = y.color
11      x = y.right
12      if y.p == z
13          x.p = y
14      else RB-TRANSPLANT(T, y, y.right)
15          y.right = z.right
16          y.right.p = y
17      RB-TRANSPLANT(T, z, y)
18      y.left = z.left
19      y.left.p = y
20      y.color = z.color
21  if y.original-color == BLACK
22      RB-DELETE-FIXUP(T, x)

第13行， x.p 不已经是 y 了吗， 为什么要重新设置一下呢 ？ k 神， 求解。