数据结构知识点总结：树结构

已于 2023-03-10 07:37:15 修改
阅读量495 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 树结构 c++
于 2021-07-01 19:25:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29169285/article/details/118391646
版权

前言
 
  数据结构知识点总结文档：树结构。该文档总结了3种经典的树结构，包括他们各自的原理，以及代码实现。

目录


 
 

1. 树

 

1.1 树的种类

  1. 二叉搜索树
  2. 红黑树
  3. AVL树
  4. B树
  5. B+树
    ······

 

1.2 树的遍历

  • 前序遍历（pre-order）
    • DLR，先遍历根节点，接着是左子树，最后是右子树。
    • 可分别使用递归和栈结构来实现：
/* Recursive Solution */
void PreOrder(Node* ptr)
{
	visit(root);
	PreOrder(root->left);
	PreOrder(root->right);
}

/* Stack Solution */
while(stack.empty() == false)
{
	root = stack.top()
	visit(root);
	stack.pop();
	stack.push(root->right);	// Stack is FIFO, hence we need to push right child first. 
	stack.push(root->left);
}

 

  • 中序遍历（in-order）
    • LDR，先遍历左子树，接着是根节点，最后是右子树。
       
  • 后序遍历（post-order）
    • LRD，先遍历左子树，接着是右子树，最后是根节点。
       
  • 广度优先搜索（Breadth-First Search）
    • 先遍历每层的所有节点，完成遍历后才会进入下一层遍历。
    • 在代码实现中，通常使用单向队列（queue）来实现。
 while(queue.empty() == false)
 {
 	node = queue.head();
 	visit(node);
 	queue.enqueue(node->left);
 	queue.enqueue(node->right);
 	queue.dequeue();
 }

 

  • 深度优先搜索（Depth-First Search）
    • 从根节点一直向下探查，抵达叶节点后切换到另一条路径探查，直到抵达另一个叶节点。
    • 在代码实现中，通常使用栈（stack）搭配前序遍历来实现。
 while(stack.empty() == false)
 {
	root = stack.top()
	visit(root);
	stack.pop();
	stack.push(root->right);	// Stack is FIFO, hence we need to push right child first. 
	stack.push(root->left);
 }

 
 

 

2. 二叉搜索树

 

2.1 基本知识点

  • 对于每个节点，如果不是叶子节点，那么只能有最多两个子节点。
  • 若节点的左子树存在，则左子树中的每一个节点值都不大于该节点值，若节点的右子树存在，则右子树中的每一个节点值都不小于该节点值。
  • 假设二叉搜索树有 N N N 个节点，那么最优深度出现在二叉树平衡分布时，为 log ⁡ ( N + 1 ) \log(N+1) log(N+1)。 最差深度出现在线性分布时，为 N N N。
    • 推导：完美二叉搜索树的节点数为 N = 2 d − 1 N=2^d - 1 N=2d−1，但由于底层未必被叶节点填满，因此 N ≤ 2 d − 1      ⟹      log ⁡ ( N + 1 ) ≤ d N \le 2^d - 1 \ \implies \ \log(N+1) \le d N≤2d−1 ⟹ log(N+1)≤d

 

2.2 查询节点

  • 二叉搜索树的查询操作比较简单，仅需要从根节点开始向下遍历整棵树，让需要查询的值与途中遍历到的每个节点的值相比较，如果相等则返回当前节点；若待查询值大于节点值，则遍历节点的右子树；若待查询值小于节点值，则遍历节点的左子树；若节点不存在于树中，则返回空指针。
  • 在具体的代码实现中，即可通过迭代的方式，也可通过递归的方式来遍历二叉搜索树。一般来说，递归会消耗更多资源，性能较低，但由于其能够保留遍历中探查到的每一个节点，因此在某些需要记录遍历路径的情况下具有优势。
  • 当二叉搜索树平衡分布时为 O ( log ⁡ ( n ) ) O(\log(n)) O(log(n))。当二叉搜索树线性分布时为 O ( n ) O(n) O(n)

 

2.3 插入节点

  • 在插入新节点前，需要先查询到新节点所应该插入的位置。查询的方法和上述的操作是一样的。查询到合适的位置后，由于插入的位置必定为上一个节点的某个空子节点，即新节点必将以叶节点的身份被插入到树中。因此可直接构造新的节点，令新节点与上一个节点相连即可。
  • 与查询复杂度类似，插入新的节点仅需要找到节点应属的位置即可，因此平衡分布时为 O ( log ⁡ ( n ) ) O(\log(n)) O(log(n))。线性分布时为 O ( n ) O(n) O(n)

 

2.4 删除节点

  • 二叉搜索树删除节点需要先查询到指定节点再执行删除。删除时存在三种情况：
    • 第一种情况： 若待删除节点为叶节点，则可直接删除。
    • 第二种情况： 若待删除节点只有一个子节点。则删除该节点，令该节点的父节点指向该节点的子节点。
    • 第三种情况： 若待删除节点有两个子节点。先找到左子树中的最大节点（或右子树中的最小节点），用最大节点值替代当前节点值，然后删除最大节点。
  • 在具体的代码实现中，需要单独处理待删除节点为根节点的情况。
  • 因为删除操作为常数复杂度。第一、二种情况下只查询一次，第三种情况查询两次。所以删除复杂度与查询复杂度类似，为 O ( log ⁡ ( n ) ) O(\log(n)) O(log(n)) 或 O ( n ) O(n) O(n)。

 

2.5 代码实现

  • 树节点实现
/* Data structure for tree node */
struct Node 
{
    double data;
    Node* left;
    Node* right;
    Node* parent;

    Node() {
        data = 0.0;
        left = nullptr;
        right = nullptr;
        parent = nullptr;
    }

    Node(double data_ = 0.0, 
         Node* left_ = nullptr, 
         Node* right_ = nullptr, 
         Node* parent_ = nullptr) {
        data = data_;
        left = left_;
        right = right_;
        parent = parent_;
    }
};
  • 树实现
/* Data Structure for Binary Search Tree */
struct Tree 
{
    int size;
    Node* root;

    Tree() {
        root = nullptr;
        size = 0;
    }

    /* Method for finding a specific node, return NULL if not exist */
    Node* Find(double value, Node* node) {
        while (node != nullptr && value != node->data ) {
            node = (value > node->data) ? node->right : node->left;
        }
        return node;
    }

    /* Method for finding the minimum node */
    Node* FindMin(Node* node) {
        while (node->left != nullptr) {
            node = node->left;
        }
        return node;
    }

    /* Method for finding the maximum node */
    Node* FindMax(Node* node) {
        while (node->right != nullptr) {
            node = node->right;
        }
        return node;
    }

    /* Method for inserting new node */
    void Insert(double value) {
        Node* locator = this->root;
        Node* temp = nullptr;
        while (locator != nullptr)  // Find the right place to insert new node
        {
            temp = locator;
            locator = (value > locator->data) ? locator->right : locator->left;
        }

        Node* newNode = new Node(value, nullptr, nullptr, temp);
        if (locator == this->root)
            this->root = newNode;
        else if (value > temp->data)
            temp->right = newNode;
        else 
            temp->left = newNode;

        this->size += 1;
        return;
    }

    /* Method for deleting specific node */
    Node* Delete(double value) {
        Node* node = Find(value, this->root);
        Node* parent = node->parent;

        if (node->left == nullptr && node->right == nullptr) {                   // Case 1
            if (node == this->root)
                this->root = nullptr;
            else if (parent->right == node)
                parent->right = nullptr;
            else 
                parent->left = nullptr;
        }
        else if (node->right == nullptr || node->left == nullptr) {              // Case 2
            Node* child = (node->right == nullptr) ? node->left : node->right;
            if (parent->right == node)
                parent->right = child;
            else 
                parent->left = child;
        }
        else {                                                                   // Case 3
            Node* minNode = FindMin(node->right);
            node->data = minNode->data;
            if (minNode->right != nullptr)
                minNode->parent->left = minNode->right;
            else 
                minNode->parent->left = nullptr;
        }
        
        this->size -= 1;
        return node;
    }

    void PrintTree(Node* node) {
    if (node != nullptr)
        std::cout << node->data << " ";
    else 
        return;
    
    PrintTree(node->left);
    PrintTree(node->right);
    return;
    }
};

 
 

 

3. 红黑树

 

3.1 基本知识点

  • 红黑树本质上是能够自动平衡的二叉搜索树，所有红黑树均满足以下五条规则：
    1. 每个节点要么是红色，要么是黑色。
    2. 红黑树的根节点必须是黑色。
    3. 红黑树的叶节点（NIL）必须是黑色（这里的叶节点不是指普通树的实体叶节点，而是实体叶节点下抽象出的为空的叶节点）
    4. 如果一个节点为红色，则其子节点必须为黑色。
    5. 对任意节点，从该节点到其所有叶节点的路径上，黑色节点的数量必须一样。
  • 假设红黑树有 N N N 个节点，那么红黑树深度最深为 2 log ⁡ ( N + 1 ) 2 \log(N+1) 2log(N+1)。

 

3.2 左旋操作

        |                                  |
        |                                  |
        X                                  Y
       / \        left rotate X           / \
      /   \      ---------------->       /   \
     a     Y                            X     c   
          / \                          / \
         /   \                        /   \
        b     c                      a     b
  • 伪代码可表示为
LEFT-ROTATE(T, x):
    y ← right[x]              # 前提：这里假设x的右子节点为y。下面开始正式操作
    right[x] ← left[y]        # 将 “y的左子节点” 设为 “x的右子节点”，即将β设为x的右子节点
    p[left[y]] ← x            # 将 “x” 设为 “y的左子节点的父节点”，即将β的父节点设为x
    p[y] ← p[x]               # 将 “x的父节点” 设为 “y的父节点”
    if p[x] = nil[T]:
        then root[T] ← y      # 情况1：如果 “x的父节点” 是空节点，则将y设为根节点
    else if x = left[p[x]] 
        then left[p[x]] ← y   # 情况2：如果 x是它父节点的左子节点，则将y设为“x的父节点的左子节点”
    else right[p[x]] ← y      # 情况3：(x是它父节点的右子节点) 将y设为“x的父节点的右子节点”
    left[y] ← x               # 将 “x” 设为 “y的左子节点”
    p[x] ← y                  # 将 “x的父节点” 设为 “y”

 

3.3 右旋操作

          |                                  |
          |                                  |
          Y                                  X
         / \        right rotate Y          / \
        /   \      ---------------->       /   \
       X     c                            a     Y   
      / \                                      / \
     /   \                                    /   \
    a     b                                  b     c
  • 伪代码可表示为
RIGHT-ROTATE(T, y):   
    x ← left[y]                # 前提：这里假设y的左子节点为x。下面开始正式操作
    left[y] ← right[x]         # 将 “x的右子节点” 设为 “y的左子节点”，即 将β设为y的左子节点
    p[right[x]] ← y            # 将 “y” 设为 “x的右子节点的父节点”，即 将β的父节点设为y
    p[x] ← p[y]                # 将 “y的父节点” 设为 “x的父节点”
    if p[y] = nil[T]: 
        then root[T] ← x       # 情况1：如果 “y的父节点” 是空节点，则将x设为根节点
    else if y = right[p[y]]:
        then right[p[y]] ← x   # 情况2：如果 y是它父节点的右子节点，则将x设为“y的父节点的左子节点”
    else left[p[y]] ← x        # 情况3：(y是它父节点的左子节点) 将x设为“y的父节点的左子节点”
    right[x] ← y               # 将 “y” 设为 “x的右子节点”
    p[y] ← x                   # 将 “y的父节点” 设为 “x”

 

3.4 查询节点

  • 由于红黑树本质上是二叉搜索树，因此节点的排列规律与二叉搜索树一致，因此红黑树的查询复杂度也为 O ( log ⁡ ( N ) ) O(\log(N)) O(log(N))

 

3.5 插入节点

  • 红黑树插入新节点的步骤分为三步。
    • 第一步： 按照二叉搜索树的规则，把新节点插入到树中。
    • 第二步： 把新的节点着色为"红色"。
      • 为何要着色为"红色"? 把新节点着色为红色，能够避免违反红黑树的第5条规则，即任意节点到其所有叶节点的路径上，黑节点的数量必须一样。少违背一条规则，后续需要处理的情况就越少。
    • 第三步： 着色后，红黑树的第2，3，4条规则不会违背，但第5条规则有可能违背。因此需要着色后需要检测新的红黑树是否违背第5条规则，若存在违背，则需调整红黑树。
  • 对于第三步，需要分为三种情况处理。
    • 第一种情况： 插入节点是根节点，则直接把新节点着色为黑色。
    • 第二种情况： 若插入节点的父节点为黑色，则符合红黑树平衡规则，无需进行调整。
    • 第三种情况： 若插入节点的父节点为红色，则父节点的父节点一定是非空(即祖父节点，除非是根节点)。进一步讲，祖父节点也一定存在另一个子节点(即插入节点的叔叔节点，即便其为空，我们也视之为存在)。这种情况下，需要进一步细化为三种情况。
现象说明处理策略
情况1插入节点的父节点是红色，且其叔叔节点也是红色
1）将“父节点”和“叔叔节点”设为黑色
2）将“祖父节点”设为红色
3）将“祖父节点”设为插入节点，并对新的“插入节点”继续进行检测和调整操作
情况2插入节点的父节点是红色，其叔叔节点是黑色，且插入节点是父节点的右子节点1）以“父节点”为支点进行左旋
2）将“父节点”设为新的插入节点继续进行检测和调整
情况3插入节点的父节点是红色，其叔叔节点是黑色，且插入节点是父节点的左子节点1）将“父节点”设为黑色
2）将“祖父节点”设为红色
3）以“祖父节点”为支点进行右旋
  • 红黑树调整的核心思路是把多出来的红色节点逐步转移到树的根节点，最后把根节点设为黑色。在这种情况下，红黑树的初步插入操作因为与二叉搜索树一样，所以复杂度为 O ( log ⁡ ( N ) ) O(\log(N)) O(log(N))。在后续的调整中，单步调整操作为常数复杂度，最坏的情况下需要从叶节点一直调整到根节点，遍历整个树高，复杂度也为 O ( log ⁡ ( N ) ) O(\log(N)) O(log(N))，因此红黑树插入的整体复杂度为 O ( log ⁡ ( N ) ) O(\log(N)) O(log(N))

在这里插入图片描述

情况1的示意图，z为需要调整的节点
 

在这里插入图片描述

情况2和情况3的示意图
 

 

3.6 删除节点

  • 红黑树删除操作和二叉搜索树删除操作是类似的，首先需要查询到待删除节点的位置，其后需要对其分为三种情况处理：
    • 第一种情况： 待删除节点没有子节点，则直接删除，对删除后的空节点进行调整操作。（由于空叶节点在代码中是一个空指针，所以在寻找兄弟节点时需要单独考虑这种情况）
    • 第二种情况： 待删除节点只有一个子节点，则直接删除待删除节点，令其子节点于其父节点相连，然后对其子节点进行平衡操作（因为“单分支黑-黑”和“单支红-黑”的情况会破坏红黑树第5条规则，不可能出现，所以平衡红黑树只存在“单分支黑-红”和双支情况）
    • 第三种情况： 待删除节点存在两个子节点，则从待删除节点的右子树中找到最小的节点，交换两者的数值，两者的颜色保持不变，改为删除最小节点。由于最小节点要么没有子节点，要么只有右子节点，因此由第三种情况转换为了第一或二种情况。
  • 假设待调整节点为 x x x，红黑树删除后的调整操作需要分为五种情况处理：
现象说明处理策略
情况1 x x x 为红色直接设为黑色即可
情况2 x x x 为黑色， x x x 的兄弟节点为红色（兄弟节点的子节点和父节点必为黑色）1）互换 x x x 的父节点与兄弟节点的颜色
3）以父节点为支点进行左旋
4）对 x x x 继续调整（转化为情况3，4，5处理）
情况3 x x x 为黑色，其兄弟节点为黑色，兄弟节点的子节点均为黑色1）将兄弟节点设置为红色
2）把 x x x 的父节点设置为新的 x x x 节点，继续调整（转化为情2，4，5处理）
情况4 x x x 为黑色，其兄弟节点为黑色，兄弟节点的右子节点为黑色1）互换兄弟节点与兄弟节点左子节点的颜色
2）对兄弟节点进行右旋
3）对 x x x 继续调整（转化为情况5处理）
情况5 x x x 为黑色，其兄弟节点为黑色，兄弟节点的左子节点为黑色，或子节点均为红色1）互换兄弟节点与父节点的颜色
2）对父节点进行左旋
3）把兄弟节点的右子节点设为黑色
  • 必须注意的是，上述的删除操作是基于待删除节点是一个左子节点的前提。如果待删除节点是一个右子节点，则需要把上述操作中，“左”和“右”的操作互换过来。
  • 在具体的代码实现中，对于待删除节点不存在子节点的情况。我们先新建一个黑色、数值为负无穷的节点、与待删除节点共用同一个父节点的临时节点，来表示待删除节点删除后留存的空节点。但我们不令父节点指向这个临时节点（因为空节点本身是不存在的）。通过这种方法，我们能够对空节点执行调整操作。在调整结束后，把临时节点释放掉即可。
  • 红黑树删除调整的核心思路是把删除后缺少的黑色节点通过旋转，从相邻的兄弟子树中“借”过来，利用逐步把矛盾往树的上层转移。由于删除前需要事先找到待删除的节点，复杂度为 O ( log ⁡ ( N ) ) O(\log(N)) O(log(N))。在调整中，单步调整操作为常数复杂度，最差的情况下需要遍历整个树高，复杂度也为 O ( log ⁡ ( N ) ) O(\log(N)) O(log(N))。因此红黑树删除的整体复杂度为 O ( log ⁡ ( N ) ) O(\log(N)) O(log(N))

在这里插入图片描述

情况2示意图，z为待调整节点，w为z的兄弟节点
 

在这里插入图片描述

情况3示意图
 

在这里插入图片描述

情况4示意图
 

在这里插入图片描述

情况5示意图
 

 

3.7 代码实现

  • 树节点实现
/* Data structure for tree node */
enum Color {RED, BLACK};

struct Node 
{
    double data;
    Color color;
    Node* left;
    Node* right;
    Node* parent;

    Node() {
        data = 0.0;
        color = RED;
        left = nullptr;
        right = nullptr;
        parent = nullptr;
    }

    Node(double data_ = 0.0,
         Color color_ = RED, 
         Node* left_ = nullptr, 
         Node* right_ = nullptr, 
         Node* parent_ = nullptr) {
        data = data_;
        color = color_;
        left = left_;
        right = right_;
        parent = parent_;
    }
};
  • 树实现
/* Data Structure for Red-Black Tree */
struct RBTree 
{
    int size;
    Node* root;

    RBTree() {
        root = nullptr;
        size = 0;
    }

    /* Method for finding a specific node, return NULL if not exist */
    Node* RBFind(double value, Node* node) {
        while (node != nullptr && value != node->data ) {
            node = (value > node->data) ? node->right : node->left;
        }
        return node;
    }

    /* Method for finding the minimum node */
    Node* RBFindMin(Node* node) {
        while (node->left != nullptr) {
            node = node->left;
        }
        return node;
    }

    /* Method for finding the maximum node */
    Node* RBFindMax(Node* node) {
        while (node->right != nullptr) {
            node = node->right;
        }
        return node;
    }

    /* Method for left rotate a tree */
    void LeftRotate(Node* node) {
        Node* successor = node->right;
        node->right = successor->left;
        if (successor->left != nullptr)
            successor->left->parent = node;

        successor->parent = node->parent;
        if (node->parent == nullptr)
            this->root = successor;
        else if (node->parent->left == node)
            node->parent->left = successor;
        else
            node->parent->right = successor;

        successor->left = node;
        node->parent = successor;
        return;
    }

    /* Method for right rotate a tree */
    void RightRotate(Node* node) {
        Node* successor = node->left;
        node->left = successor->right;
        if (successor->right != nullptr)
            successor->right->parent = node;
        
        successor->parent = node->parent;
        if (node->parent == nullptr)
            this->root = successor;
        else if (node->parent->left == node)
            node->parent->left = successor;
        else 
            node->parent->right = successor;
        
        successor->right = node;
        node->parent = successor; 
        return;
    }

    /* Method for inserting new node */
    void RBInsert(double value) {
        Node* locator = this->root;
        Node* parent = nullptr;
        while (locator != nullptr)  // Find the right place to insert new node
        {
            parent = locator;
            locator = (value > locator->data) ? locator->right : locator->left;
        }

        Node* newNode = new Node(value, RED, nullptr, nullptr, parent);
        if (locator == this->root)
            this->root = newNode;
        else if (value > parent->data)
            parent->right = newNode;
        else 
            parent->left = newNode;

        RBInsertFixup(newNode);
        this->size += 1;
        return;
    }

    /* Method for maintaining Red-Black Tree properties after insertion */
    void RBInsertFixup(Node* node) {
        Node* parent = node->parent;

        if (node == this->root) {                                       // Case 1
            node->color = BLACK;
        }
        else if (parent->color == RED) {                                // Case 3, don't need to deal with case 2
            Node* gparent = parent->parent;
            Node* uncle = (gparent->left == parent) ? gparent->right : gparent->left;
            Color uncleColor = (uncle == nullptr) ? BLACK : uncle->color;

            if (uncleColor == RED) {                                    // Case 3.1
                parent->color = BLACK;
                uncle->color = BLACK;
                gparent->color = RED;
                RBInsertFixup(gparent);
            }
            else if (uncleColor == BLACK && parent->right == node) {    // Case 3.2
                LeftRotate(parent);
                RBInsertFixup(parent);
            }
            else if (uncleColor == BLACK && parent->left == node) {     // Case 3.3
                parent->color = BLACK;
                gparent->color = RED;
                RightRotate(gparent);
            }
        }
        return;
    }

    /* Method for deleting specific node */
    Node* RBDelete(double value) {
        Node* node = this->RBFind(value, this->root);
        Node* parent = node->parent;
        Node* successor = nullptr;
        Color originColor = node->color;

        if (node->left == nullptr && node->right == nullptr) {                  // Case I: have no child node
            if (node == this->root)
                this->root = nullptr;
            else if (parent->right == node)
                parent->right = nullptr;
            else 
                parent->left = nullptr;

            successor = new Node(INT_MIN, BLACK, nullptr, nullptr, parent);
        }
        else if (node->right == nullptr || node->left == nullptr) {             // Case II: have one child node
            Node* child = (node->right == nullptr) ? node->left : node->right;
            if (parent->right == node)
                parent->right = child;
            else 
                parent->left = child;

            successor = child;
        }
        else {                                                                  // Case III: have two child nodes
            Node* minNode = RBFindMin(node->right);
            node->data = minNode->data;
            if (minNode->right != nullptr) {
                minNode->parent->left = minNode->right;
                successor = minNode->right;
            }
            else {
                minNode->parent->left = nullptr;
                successor = new Node(INT_MIN, BLACK, nullptr, nullptr, minNode->parent);
            }
            
            originColor = minNode->color;
        }
        
        if (originColor == BLACK) 
            RBDeleteFixup(successor);
        this->size -= 1;
        return node;
    }

    /* Method for maintaining Red-Black Tree properties after deletion */
    void RBDeleteFixup(Node* node) {
        if (node != this->root && node->color == BLACK) {
            Node* parent = node->parent;
            Node* sibling = nullptr;
            if (parent->left == nullptr || parent->right == nullptr)                // Deal with the case when node is NULL
                sibling = (parent->left == nullptr) ? parent->right : parent->left;
            else 
                sibling = (node == parent->left) ? parent->right : parent->left;

            if (sibling == parent->right){                                          // For the case when node is a left child
                if (sibling->color == RED) {                                        // Case 2
                    sibling->color = parent->color;                                 // Case 2
                    parent->color = RED;                                            // Case 2
                    LeftRotate(parent);                                             // Case 2
                    RBDeleteFixup(node);                                            // Case 2
                }
                else {
                    if ((sibling->left == nullptr || sibling->left->color == BLACK) && 
                        (sibling->right == nullptr || sibling->right->color == BLACK)) { 
                        sibling->color = RED;                                       // Case 3
                        RBDeleteFixup(parent);                                      // Case 3
                    }
                    else if (sibling->right == nullptr || sibling->right->color == BLACK) {
                        sibling->color = sibling->left->color;                      // Case 4
                        sibling->left->color = BLACK;                               // Case 4
                        RightRotate(sibling);                                       // Case 4
                        RBDeleteFixup(node);                                        // Case 4
                    }
                    else {
                        sibling->color = parent->color;                             // Case 5
                        parent->color = BLACK;                                      // Case 5
                        sibling->right->color = BLACK;                              // Case 5
                        LeftRotate(parent);                                         // Case 5
                    }
                }
            }
            else {                                                                  // Do the same as then clause with “right” and “left” exchanged
                if (sibling->color == RED) {
                    sibling->color = parent->color;
                    parent->color = RED;
                    RightRotate(parent);
                    RBDeleteFixup(node);
                }
                else {
                    if ((sibling->right == nullptr || sibling->right->color == BLACK) && 
                        (sibling->left == nullptr || sibling->left->color == BLACK)) { 
                        sibling->color = RED;
                        RBDeleteFixup(parent);
                    }
                    else if (sibling->left == nullptr || sibling->left->color == BLACK) {
                        sibling->color = sibling->right->color;
                        sibling->right->color = BLACK;
                        LeftRotate(sibling);
                        RBDeleteFixup(node);
                    }
                    else {
                        sibling->color = parent->color;
                        parent->color = BLACK;
                        sibling->left->color = BLACK;
                        RightRotate(parent);
                    }
                }
            }
        }
        else 
            node->color = BLACK;
        
        return;
    }

    void RBPrintTree(Node* node) {
        if (node != nullptr)
            std::cout << node->data << "-" << node->color << " ";
        else 
            return;
        
        RBPrintTree(node->left);
        RBPrintTree(node->right);
        return;
    }
};

 
 

 

4. AVL树

 

4.1 基本知识点

  • AVL树又被称作平衡二叉树（Self-balancing Binary Search Tree），因此AVL树本质上也是二叉搜索树，具有以下性质：
    • 若一颗AVL树不为空树，则其左右两个子树的高度差的绝对值不超过1
    • AVL树中，其任意的子树都是一颗AVL树
  • 在AVL树中，节点的高度被定义为其左右子节点的高度中的最大者+1（叶节点的可视为有两个空的子节点），空节点的高度为-1，因此叶节点的高度为0。
  • 由于AVL树是已经平衡的二叉搜索树，因此假设树中有 N N N 个节点，AVL树树高最多为 1.44 ( log ⁡ ( N ) ) 1.44(\log(N)) 1.44(log(N))

 

4.2 查询节点

  • AVL树查询节点的复杂度与完美二叉搜索树一样，为 O ( log ⁡ ( N ) ) O(\log(N)) O(log(N))

 

4.3 插入节点

  • 插入新的节点到AVL树中有可能会破坏AVL树原本的平衡性。因此，在插入节点后，需要对新的AVL树进行平衡性检查，在此需要引入一个被称为“平衡因子”的概念。
  • 平衡因子（Balance Factor）被定义为AVL树的左子树和右子树的高度差的绝对值，根据AVL树的性质，平衡因子必须为0或1，大于1则说明AVL树不平衡。为了方便计算，树中的每一个节点都会记录自身在树中的高度。
  • 如果插入的节点破坏了AVL树的平衡性，则需要进行平衡操作。我们假设需要进行平衡操作的节点为 x x x，需要分为四种情况处理：
    • 情况1： LL，即插入的节点位于 x x x 的左子节点（L）的左子树（L）。此时需要对 x x x 进行右旋操作。
    • 情况2： RR，即插入的节点位于 x x x 的右子节点（R）的右子树（R）。此时需要对 x x x 进行左旋操作。
    • 情况3： LR，即插入的节点位于 x x x 的左子节点（L）的右子树（R）。此时需要先对 x x x 左子节点进行一次左旋操作，然后对 x x x 进行一次右旋操作。
    • 情况4： RL，即插入的节点位于 x x x 的右子节点（R）的左子树（L）。此时需要先对 x x x 右子节点进行一次右旋操作，然后对 x x x 进行一次左旋操作。
  • 在具体的代码实现中，我们采用了递归的方法来查询新节点将要插入的位置。当完成插入后，递归会开始沿着查询的路线逐层返回，直到返回到根节点。我们每返回到一层，就对当前的节点进行平衡性检测，如果违反了平衡性，则对当前节点进行平衡操作。如此便确保了所有与插入操作有关联的节点都能被检测并调整。需要注意的是，在每次执行完平衡操作后，都需要更新节点的高度。
  • 查询合适的插入点需要遍历整个树高，递归返回同样需要遍历整个树高，因此两者的复杂度均为 O ( log ⁡ ( N ) ) O(\log(N)) O(log(N))。调整的操作为常数复杂度，因此AVL树插入节点的整体复杂度为 O ( log ⁡ ( N ) ) O(\log(N)) O(log(N))

 

4.4 删除节点

  • 从某种程度上讲，AVL树的删除可以被看作是另一种形式的AVL树插入。和二叉搜索树删除操作一样，AVL树首先要找到待删除节点的位置，若不存在子节点，则直接删除；若存在一个子节点，则删除后把其子节点与其父节点相连；若存在两个子节点，则在其右子树中，找到右子树中最小的节点，替换掉待删除节点的数值后，删除最小节点。
  • 如果删除节点导致了AVL树的平衡性被破坏，同样需要进行平衡操作。我们假设需要进行平衡操作的节点为 x x x，同样需要分为四种情况处理：
    • 情况1： x x x 的左子树（L）高度大于右子树，且 x x x 的左子节点的左子树（L）高度大于右子树，这种情况相当于插入平衡处理中的LL。此时需要对 x x x 进行右旋操作。
    • 情况2： x x x 的左子树（L）高度大于右子树，且 x x x 的左子节点的右子树（R）高度大于左子树，这种情况相当于插入平衡处理中的LR。此时需要对 x x x 的左子节点进行一次左旋操作，然后对 x x x 进行一次右旋操作。
    • 情况3： x x x 的右子树（R）高度大于左子树，且 x x x 的右子节点的右子树（R）高度大于左子树，这种情况相当于插入平衡处理中的RR。此时需要对 x x x 进行左旋操作。
    • 情况4： x x x 的右子树（R）高度大于左子树，且 x x x 的右子节点的左子树（L）高度大于右子树，这种情况相当于插入平衡处理中的RL。此时需要对 x x x 的右子节点进行一次右旋操作，然后对 x x x 进行一次左旋操作。
  • 在具体的代码实现中，我们同样采用递归的方法来查询待删除节点的位置。完成删除后，递归会开始沿着查询的路线逐层返回，直到返回到根节点。在每层中，我们都对当前节点的父节点进行平衡性检测（不对当前节点检测是因为当前节点已经被删掉了），如果违反了平衡性，则进行平衡操作。如此便确保了所有与删除操作有关联的节点都能被检测并调整。需要注意的是，在每次执行完平衡操作后，都需要更新节点的高度。
  • 查询待删除节点在最坏的情况下要遍历整个树高，递归返回同样需要遍历整个树高，因此两者的复杂度均为 O ( log ⁡ ( N ) ) O(\log(N)) O(log(N))。调整的操作为常数复杂度，因此AVL树删除节点的整体复杂度为 O ( log ⁡ ( N ) ) O(\log(N)) O(log(N))

 

4.5 代码实现

  • 树节点实现
/* Data structure for tree node */
struct Node 
{
    double data;
    int hight;
    Node* left;
    Node* right;
    Node* parent;

    Node() {
        data = 0.0;
        hight = 0;
        left = nullptr;
        right = nullptr;
        parent = nullptr;
    }

    Node(double data_ = 0.0,
         int hight_ = 0,
         Node* left_ = nullptr, 
         Node* right_ = nullptr, 
         Node* parent_ = nullptr) {
        data = data_;
        hight = hight_;
        left = left_;
        right = right_;
        parent = parent_;
    }
};
  • 树实现
#include <algorithm>

/* Data Structure for Red-Black Tree */
struct AVLTree 
{
    int size;
    Node* root;

    AVLTree() {
        root = nullptr;
        size = 0;
    }

    /* Method for finding a specific node, return NULL if not exist */
    Node* AVLFind(double value, Node* node) {
        while (node != nullptr && value != node->data ) {
            node = (value > node->data) ? node->right : node->left;
        }
        return node;
    }

    /* Method for finding the minimum node */
    Node* AVLFindMin(Node* node) {
        while (node->left != nullptr) {
            node = node->left;
        }
        return node;
    }

    /* Method for finding the maximum node */
    Node* AVLFindMax(Node* node) {
        while (node->right != nullptr) {
            node = node->right;
        }
        return node;
    }

    /* Method for calculating the tree hight */
    int GetTreeHight(Node* node) {
        return (node == nullptr) ? -1 : node->hight;
    }

    /* Method for calculating the balance factor of the node */
    int GetBalanceFactor(Node* node) {
        return abs(GetTreeHight(node->left) - GetTreeHight(node->right));
    }

    /* Method for testing if the current node is balanced */
    bool isBalanced(Node* node) {
        int BalanceFactor = GetBalanceFactor(node);
        return (BalanceFactor > 1) ? false : true;
    } 

    /* Method for left rotate a tree */
    void LeftRotate(Node* node) {
        Node* successor = node->right;
        node->right = successor->left;
        if (successor->left != nullptr)
            successor->left->parent = node;

        successor->parent = node->parent;
        if (node->parent == nullptr)
            this->root = successor;
        else if (node->parent->left == node)
            node->parent->left = successor;
        else
            node->parent->right = successor;

        successor->left = node;
        node->parent = successor;
        node->hight = 1 + std::max(GetTreeHight(node->left), GetTreeHight(node->right));
        successor->hight = 1 + std::max(GetTreeHight(successor->left), GetTreeHight(successor->right));
        return;
    }

    /* Method for right rotate a tree */
    void RightRotate(Node* node) {
        Node* successor = node->left;
        node->left = successor->right;
        if (successor->right != nullptr)
            successor->right->parent = node;
        
        successor->parent = node->parent;
        if (node->parent == nullptr)
            this->root = successor;
        else if (node->parent->left == node)
            node->parent->left = successor;
        else 
            node->parent->right = successor;
        
        successor->right = node;
        node->parent = successor;
        node->hight = 1 + std::max(GetTreeHight(node->left), GetTreeHight(node->right));
        successor->hight = 1 + std::max(GetTreeHight(successor->left), GetTreeHight(successor->right));
        return;
    }

    /* Method for inserting new node */
    void AVLInsert(double value) {
        AVLInsert(this->root, nullptr, value);
        return;
    }

    void AVLInsert(Node* locator, Node* parent, double value) {
        if (locator == nullptr) {
            Node* newNode = new Node(value, 0, nullptr, nullptr, parent);
            if (parent == nullptr)
                this->root = newNode;
            else if (value > parent->data)
                parent->right = newNode;
            else 
                parent->left = newNode;
            locator = newNode;
            this->size += 1;
        }
        else if (value > locator->data) {
            AVLInsert(locator->right, locator, value);
        } 
        else {
            AVLInsert(locator->left, locator, value);
        }

        AVLInsertFixup(locator, value);
        return;
    }

    /* Method for maintaining AVL Tree properties after insertion */
    void AVLInsertFixup(Node* node, double value) {
        if (!isBalanced(node)) {
            int leftValue = (node->left == nullptr) ? -1 : node->left->data;
            int rightValue = (node->right == nullptr) ? -1 : node->right->data;
            if (value < node->data && value < leftValue) {            // Case LL
                RightRotate(node);
            }
            else if (value > node->data && value > rightValue) {      // Case RR
                LeftRotate(node);
            }
            else if (value < node->data && value > leftValue) {       // Case LR
                LeftRotate(node->left);
                RightRotate(node);
            } 
            else if (value > node->data && value < rightValue) {      // Case RL
                RightRotate(node->right);
                LeftRotate(node);
            }
        }
        node->hight = 1 + std::max(GetTreeHight(node->left), GetTreeHight(node->right));
        return;
    }

    /* Method for deleting specific node */
    Node* AVLDelete(double value) {
        return AVLDelete(this->root, nullptr, value);
    }

    Node* AVLDelete(Node* locator, Node* parent, double value) {
        if (value == locator->data) {
            if (locator->left == nullptr && locator->right == nullptr) {
                if (locator == this->root)
                    this->root = nullptr;
                else if (parent->right == locator)
                    parent->right = nullptr;
                else 
                    parent->left = nullptr;
            }
            else if (locator->right == nullptr || locator->left == nullptr) {
                Node* child = (locator->right == nullptr) ? locator->left : locator->right;
                if (parent->right == locator)
                    parent->right = child;
                else 
                    parent->left = child;
            }
            else {
                Node* minNode = AVLFindMin(locator->right);
                locator->data = minNode->data;
                if (minNode->right != nullptr)
                    minNode->parent->left = minNode->right;
                else 
                    minNode->parent->left = nullptr;
                parent = minNode->parent;
            }
            this->size -= 1;
        }
        else if (value > locator->data) {
            AVLDelete(locator->right, locator, value);
        }
        else { 
            AVLDelete(locator->left, locator, value);
        }

        AVLDeleteFixup(parent);
        return locator;
    }

    /* Method for maintaining AVL Tree properties after deletion */
    void AVLDeleteFixup(Node* node) {
        if (node == nullptr)            // Do nothing if the node is NULL
            return;

        if (!isBalanced(node)) {
            if (GetTreeHight(node->left) > GetTreeHight(node->right)) {
                if (GetTreeHight(node->left->left) >= GetTreeHight(node->left->right))      // Case LL
                    RightRotate(node);
                else {                                                                      // Case LR
                    LeftRotate(node->left);
                    RightRotate(node);
                }
            }
            else {
                if (GetTreeHight(node->right->right) >= GetTreeHight(node->right->left))    // Case RR
                    LeftRotate(node);
                else {                                                                      // Case RL
                    RightRotate(node->right);
                    LeftRotate(node);
                }
            }
        }
        node->hight = 1 + std::max(GetTreeHight(node->left), GetTreeHight(node->right));
        return;
    }

    void AVLPrintTree(Node* node) {
        if (node != nullptr)
            std::cout << node->data << "-" << node->hight << " ";
        else 
            return;
        
        AVLPrintTree(node->left);
        AVLPrintTree(node->right);
        return;
    }
};

 
 

 

5. 测试数据集

  • 本文档中代码的测试数据集如下：
    Tree tree;
    tree.Insert(12);
    tree.Insert(4);
    tree.Insert(25);
    tree.Insert(3);
    tree.Insert(9);
    tree.Insert(6);
    tree.Insert(8);
    tree.Insert(19);
    tree.Insert(15);
    tree.Insert(21);
    tree.Insert(28);
    tree.Insert(14);
    tree.Insert(17);

    tree.Delete(3);
    tree.Delete(4);
    tree.Delete(9);

 
 

 

6. 参考文献

Thomas, H., Charles, E., Ronald, L., Clifford, S. (2009). Introduction to Algorithms (3rd Edition)

 
原创博客，不得转载、抄袭

ThreeWheelCar
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——树——知识点总结
MISAYAONE的博客
05-13 1万+
数据结构——树 定义：树是一个n(n>=0)个结点的有序合集 名词理解： 结点：指树中的一个元素； 结点的度：指结点拥有的子树的个数，二叉树的度不大于2； 数的度：指树中的最大结点度数； 叶子：度为0的结点，也称为终端结点； 高度：叶子节点的高度为1，根节点高度最高； 层：根在第一层，以此类推； 二叉树的定义：由一个结点和两颗互不相交、分别称为这个根的左子树和
【数据结构】树相关知识点整理
swag_wg的博客
05-21 1523
1、树的基本概念 树是一种非线性的数据结构，它是由n(n>=0)个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一颗倒挂的树，也就是说它是根朝上，而叶朝下的。 特点： 每个结点有零个或多个子结点； 没有父结点的结点称为根结点； 每一个非根结点有且只有一个父结点； 除了根结点外，每个子结点可以分为多个不相交的子树。 2、树的相关概念 下图为一个树，其中： 节...
数据结构 关于树的知识点
cocoklng的博客
08-13 174
数据结构 树
数据结构之树知识总结
最新发布
jack黄从零学c++的博客
07-26 1011
关于树的知识总结
AVL树的旋转与插入
08-11 236
typedefstructAVLNode*Position; typedefPositionAVLTree;/*AVL树类型*/ structAVLNode{ ElementTypeData;/*结点数据*/ AVLTreeLeft;/*指向左子树*/ AVLTreeRight;/*指向右子树*...
数据结构知识点-树
李昂的博客
09-14 332
二叉树 二叉树性质 性质1：二叉树的第i层至多有2^(i-1)个节点 性质2：深度为k的二叉树至多有2^(k)-1个节点 性质3：对于任意一颗二叉树，若度为2的节点有n2个，则叶子节点数n0必为n2+1个(n0=n2+1) 性质4：具有n个节点的完全二叉树的深度必为[log2n]+1(向下取整) 性质5：对于完全二叉树，从上至下，从左至右编号，则编号为i的节点，其左孩子编号必为2i，右孩子编号必为2i+1，其双亲编号必为i/2 结点和边的关系 二叉树共有结点n=n0+n1+n2，n0=n2+1，n=2n2+
《数据结构知识点总结》计算机考研复试应届生求职刷题必备.pdf
10-11
《数据结构知识点总结》这份文档正是为了帮助应届生和考研者高效复习而编写的。 文档首先介绍了数据结构的基础概念，包括相关术语的定义。比如，算法是解决问题的明确规范，它涉及到一系列特定的计算步骤，用于指导...
数据结构复习要点知识点总结笔记(整理版).doc
06-11
### 数据结构复习要点知识点总结 #### 一、数据结构概述 **1. 数据**: 在计算机科学领域中，数据指的是能够被计算机程序处理的各种符号的集合。这些符号包括但不限于数字、字母、图像等。 **2. 数据元素**: 数据...
数据结构知识点总结有工大老师多年经验编写公开课获奖课件.pptx
12-14
本资料是由工大老师多年经验编写的公开课获奖课件，涵盖了数据结构的重要知识点。 首先，我们要理解数据结构的基本概念。数据是描述客观事物的数值、字符、符号等，随着计算机技术的发展，其范围不断扩大。数据元素...
(精品word)数据结构知识点总结(计算机三级).(良心出品.doc
11-24
这份"(精品word)数据结构知识点总结(计算机三级).(良心出品.doc"文档，显然是一份针对计算机三级考试精心整理的资料，旨在帮助学习者全面掌握数据结构的基础概念、原理和应用。 首先，数据结构主要分为四大类：线性...
数据结构与算法基础知识总结.pdf
07-14
常见的数据结构包括线性结构（如线性表）、非线性结构（如树和图）等。线性表由有序数据元素组成，分为顺序存储和链式存储两种形式。顺序存储中，元素在内存中连续存放，便于快速访问；链式存储则允许元素不连续，更...
数据结构树之具体内知识点
zeochenyue的博客
01-28 596
树（Tree）： 是n(n>=0)个结点的有限集。n=0时称为空树。在任意一颗非空树中。 (1)有且仅有一个特定的称为根(ROOT)的结点； (2)当n>1时，其余结点可分为m(m>0)个互不相交的有限集T1，T2...Tm，其中每一个集合本身又是一棵树，并且称为根的子树(SubTree). 注意： 1. n>0时，根结点是唯一的，不可能存在多个根结点。 2. m>0时，子树的个数没有
数据结构--知识点总结--树
不行不至
07-04 1625
1.树 1.1 基本概念 1.2 树的性质 1.3 树的存储结构 1.4 树的存储表示 2.二叉树 2.1 基本概念 2.2 二叉树的性质 2.3 二叉树的存储结构 2.4 二叉树的存储表示 2.5 二叉树遍历 2.6 构造二叉树 2.7 线索化二叉树 3.树与森林 3.1 树的遍历 3.2 森林与二叉树的转换 3.3 森林的遍历 4.堆 5.Huffman树 5.1 概述 5....
《数据结构》——树相关知识点总结
JerryHoly13的博客
08-02 841
树 树定义： 专业定义: 1.有且仅有一个成为根的节点 2.有若干个互不相交的子树，这些子树本身也是一棵树 通俗定义： 树是由节点和边组成 每一个节点只有一个父节点，但可以有多个子节点 但有一个节点例外，该节点没有父节点，此节点称为根节点 专业术语： 节点 父节点 子节点 子孙节点 兄弟节点 堂兄弟节点 深度：从根节点到最底层节点的层数称之为深度，根节点在第一层 叶子节点：没有子节点的节点 非终端节点：实际非叶子节点 度：子节点的个数称为度 树分类 一般树 任意一个节点的子节点的个数都
数据结构之树的基础知识
m0_63932570的博客
04-11 1332
y今天我们翻开新的篇章，在结束了前面一对一的线性表后，我们来看看一对多的树。树这种数据结构其实在我们生活中也是很常见的，应用也是很广的。和线性表，图共同占据算法界的半壁江山（hhh，博主自己脑补的）所以博主也会花很多时间来给大家分享树的基础知识，不同种类和应用。好啦，废话不多说。直接上干货。 一、树的概念 树（Tree）是一种抽象数据类型（ADT）或是实现这种抽象数据类型的数据结构，用来模拟具有树状结构性质的数据集合。它是由n（n>=1）个有限节点组成一个具有层次关系的集合。之所以把它叫做树，是因为
【数据结构与算法分析】树的知识点介绍
baicoo的博客
07-10 578
1 树的的基础知识 一棵树是一些节点的集合。这个集合可以是空集；若非空，则一棵树由称做根(root)的节点r以及0个或多个非空子树T1,T2,...,TkT_1,T_2,...,T_kT1​,T2​,...,Tk​组成.这些子树中每一颗的根都被来自根r的一条有向的边所连接。 树的基础概念： 深度：任意节点nin_ini​的深度为从根到nin_ini​惟一路径的长。因此，根的深度为0。 高度：nin_ini​的高度是从nin_ini​到一片树叶的最长路径的长。因此所有的树叶的高都是0.一棵树的高等于它的根
数据结构——树的基本知识
m0_59200231的博客
08-27 623
数据结构中树的基本知识总结
数据结构树相关，知识点汇总一定要上岸啊（持续更新中）
m0_62479378的博客
05-11 376
数据结构中这一节对树的相关知识的总结
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值