Data structures AVL树的删除与重构

我已经看到，当一个节点从AVL树中删除时，它可能需要多次重构，而插入只需要一次。有谁能给我举一个删除的例子吗。 我还实现了一个AVL树，我想检查delete（）函数是否正常工作。那么，你能给出一个插入和删除的序列吗？它能帮助我判断我的delete（）是否正确，并解决所有这些问题吗

---

假设您有一个AVL树，每个节点存储一个名称（字符串），并且您有函数insertAVL（元素）和deleteAVL（元素）。

好的，insert和delete都可以有多个旋转，因为您必须沿着树向上移动

例如，添加数据集{5,2,4,3,7,8,10,9}，然后删除{5}，添加{9}，最后删除{2}。你会得到以下结果

addValue. id=5
└── (1) 5

addValue. id=2
└── (2) 5
    └── (1) 2

addValue. id=4
└── (3) 5 *unbalanced left 2 - right 0*
    └── (2) 2
        └── (1) 4
After left rotation:
└── (3) 5 *unbalanced left 2 - right 0*
    └── (2) 4
        └── (1) 2
After right rotation:
└── (2) 4
    ├── (1) 2
    └── (1) 5

addValue. id=3
└── (3) 4
    ├── (2) 2
    │   └── (1) 3
    └── (1) 5

addValue. id=7
└── (3) 4
    ├── (2) 2
    │   └── (1) 3
    └── (2) 5
        └── (1) 7

addValue. id=8
└── (3) 4
    ├── (2) 2
    │   └── (1) 3
    └── (3) 5 *unbalanced right 2 - left 0*
        └── (2) 7
            └── (1) 8
After left rotation:
└── (3) 4
    ├── (2) 2
    │   └── (1) 3
    └── (2) 7
        ├── (1) 5
        └── (1) 8

addValue. id=10
└── (4) 4
    ├── (2) 2
    │   └── (1) 3
    └── (3) 7
        ├── (1) 5
        └── (2) 8
            └── (1) 10

addValue. id=9
└── (4) 4
    ├── (2) 2
    │   └── (1) 3
    └── (3) 7
        ├── (1) 5
        └── (3) 8 *unbalanced left 0 - right 2*
            └── (2) 10
                └── (1) 9
After right rotation:
└── (5) 4
    ├── (2) 2
    │   └── (1) 3
    └── (4) 7
        ├── (1) 5
        └── (3) 8 *unbalanced right 2 - left 0*
            └── (2) 9
                └── (1) 10
After left rotation:
└── (4) 4
    ├── (2) 2
    │   └── (1) 3
    └── (3) 7
        ├── (1) 5
        └── (2) 9
            ├── (1) 8
            └── (1) 10

removeValue. value=5
└── (4) 4
    ├── (2) 2
    │   └── (1) 3
    └── (3) 7 *unbalanced right 2 - left 0*
        └── (2) 9
            ├── (1) 8
            └── (1) 10
After left rotation:
└── (4) 4
    ├── (2) 2
    │   └── (1) 3
    └── (3) 9
        ├── (2) 7
        │   └── (1) 8
        └── (1) 10

addValue. id=9
└── (5) 4
    ├── (2) 2
    │   └── (1) 3
    └── (4) 9
        ├── (3) 7 *unbalanced right 2 - left 0*
        │   └── (2) 8
        │       └── (1) 9
        └── (1) 10
After left:
└── (4) 4
    ├── (2) 2
    │   └── (1) 3
    └── (3) 9
        ├── (2) 8
        │   ├── (1) 7
        │   └── (1) 9
        └── (1) 10

removeValue. value=2
└── (4) 4 *unbalanced right 3 - left 1*
    ├── (1) 3
    └── (3) 9
        ├── (2) 8
        │   ├── (1) 7
        │   └── (1) 9
        └── (1) 10
After right rotation:
└── (4) 4 *unbalanced right 3 - left 1*
    ├── (1) 3
    └── (3) 8
        ├── (1) 7
        └── (2) 9
            ├── (1) 9
            └── (1) 10
After left rotation:
└── (3) 8
    ├── (2) 4
    │   ├── (1) 3
    │   └── (1) 7
    └── (2) 9
        ├── (1) 9
        └── (1) 10

---

如果你想仔细看看，我有一个AVL树。

我说的是多重重组，而不是轮换；我所说的重组，是指一次完成一整套左右旋转location@zed111除了旋转之外，AVL树中没有重构。在上面的例子中，双（左/右）旋转是在同一个位置完成的。我从来没有说过除了旋转之外还有任何重构，我只是说我的意思是1个重构=1个左旋转+1个右旋转在一个位置。insert和delete之间的区别在于，在insert中，树的平衡在最多一次重组后得到保证，而在delete中，您可能需要在多个位置进行重组，因此需要进行多次重组