Vj数据结构实验十一

描述

创建带索引的二叉搜索树类。存储结构使用链表，提供操作:插入、删除、按名次删除、查找、按名次查找、升序输出所有元素。

格式

输入格式

输入第一行一个数字m (m<=1000000)，表示有m个操作。
接下来m行，每一行有两个数字a，b：

• 当输入的第一个数字 a 为 0 时，输入的第二个数字 b 表示向搜索树中插入 b
• 当输入的第一个数字 a 为 1 时，输入的第二个数字 b 表示向搜索树中查找 b
• 当输入的第一个数字 a 为 2 时，输入的第二个数字 b 表示向搜索树中删除 b
• 当输入的第一个数字 a 为 3 时，输入的第二个数字 b 表示查找搜索树中名次为 b 的元素
• 当输入的第一个数字 a 为 4 时，输入的第二个数字 b 表示删除搜索树中名次为 b 的元素

输出格式

对于输入中的每一种操作，输出执行操作的过程中依次比较的元素值的异或值。

注意

• 查询与删除操作中，待查询的元素也需要异或入答案中
• 查找（删除）操作中，如果未找到，或者插入操作，已存在，输出 0（不插入），不需要输出异或和
• 查找（删除）第b大，如果不存在，输出 0
• 删除操作中，如果当前元素有两个孩子，替换的为 右子树中最小的，如果只有一个孩子，直接用该孩子替换当前元素，如果没有孩子，直接删除
• 删除操作的替换过程中所有比较操作不计入答案

样例1

输入

13
0 6
0 7
0 4
0 5
0 1
1 5
0 7
3 3
2 4
1 5
3 4
4 3
0 4

输出

0
6
6
2
2
7
0
7
2
3
1
6
3

样例2

输入

14
0 43
0 17
0 55
0 62
0 57
0 66
0 67
4 5
0 67
0 70
3 6
4 7
0 20
2 43

输出

0
43
43
28
34
34
96
34
0
29
29
91
58
43

限制

1s, 10240KiB for each test case.

提示

• 查找和删除第k大的元素时，可以先把第k的元素找到，再按照该元素查找和删除

#include <iostream>
using namespace std;
// 节点
template <class T>
struct Node
{
    T element;      // 节点的值
    Node<T> *left;  // 左孩子
    Node<T> *right; // 右孩子
    int noteSize;   // 左孩子节点个数

    Node(const T &theElement)
    {
        element = theElement;
        left = NULL;
        right = NULL;
        noteSize = 0;
    }
    Node(const T &theElement, Node<T> *theLeft, Node<T> *theRight, int LeftTreeSize)
    {
        element = theElement;
        left = theLeft;
        right = theRight;
        noteSize = LeftTreeSize;
    }
};
// 平衡二叉树
template <class T>
class binarySearchTree
{
public:
    binarySearchTree() // 构造函数
    {
        root = NULL;
        size = 0;
    }
    int insert(const T &theElement); // 插入
    int erase(const T &theElement);  // 删除
    int find(const T &theElement);   // 查找
    Node<T> *search(int a);          // 寻找名次为a的节点
private:
    Node<T> *root; // 树的根
    int size;      // 数的大小
};

// 查找名次为a的节点
template <class T>
Node<T> *binarySearchTree<T>::search(int a)
{
    Node<T> *p = root;
    Node<T> *pp = NULL;
    while (p != NULL && p->noteSize != a) // 寻找对应的节点
    {
        pp = p;
        if (p->noteSize > a) // 如果节点对应的左孩子的节点数量大于a，则继续判断他的左孩子
        {
            p = p->left;
        }
        else if (p->noteSize < a) // 如果对应的左孩子节点数量小于a，则判断他的右孩子节点
        {
            a = a - p->noteSize - 1; // a减去以p为根的树左边的节点数与根，变换为对应的以p为根的右边的树应该对应的a的值
            p = p->right;
        }
    }
    return p;
}

// 插入
template <class T>
int binarySearchTree<T>::insert(const T &theElement)
{
    Node<T> *p = root;
    Node<T> *pp = NULL;
    int sum = 0;      // 异或值最后的和
    while (p != NULL) // 进行对插入位置的查找
    {
        if (p->element < theElement) // 如果插入的值大于当前节点的值，则进行右孩子的判断
        {
            sum ^= p->element; // 进行异或求值
            pp = p;
            p = p->right;
        }
        else if (p->element > theElement) // 对于左孩子节点的判断
        {
            sum ^= p->element;
            pp = p;
            p = p->left;
        }
        else if (p->element == theElement) // 如果要插入的值存在于树中，则返回0，输出0
        {
            return 0;
        }
    }
    Node<T> *newNode = new Node<T>(theElement); // 定义一个新节点，进行插入
    if (pp != NULL)                             // pp为最后节点需要插入的父节点
    {
        if (theElement > pp->element) // 对于左边插入还是右边插入的判断
            pp->right = newNode;
        else if (theElement < pp->element)
            pp->left = newNode;
    }
    else // 如果树不存在则插入在根
    {
        root = newNode;
    }
    size++;   // 树的大小增加
    p = root; // 对节点的左边孩子个数进行更新
    while (p->element != theElement)
    {
        if (p->element < theElement) // 右孩子则不变
        {
            p = p->right;
        }
        else if (p->element > theElement) // 左孩子的话进行加一操作
        {
            p->noteSize++;
            p = p->left;
        }
    }
    return sum;
}

// 删除
template <class T>
int binarySearchTree<T>::erase(const T &theElement)
{
    Node<T> *p = root;
    Node<T> *pp = NULL;
    int sum = 0;
    // 对需要删除的节点进行查找,同时进行异或值的计算
    while (p != NULL && p->element != theElement)
    {
        sum ^= p->element;
        pp = p;
        if (p->element < theElement)
        {
            p = p->right;
        }
        else if (p->element > theElement)
        {
            p = p->left;
        }
    }
    if (p == NULL) // 没找到就返回0，不存在树中
    {
        return 0;
    }
    sum ^= p->element;
    p = root;
    // 对左边孩子的个数进行更新
    while (p != NULL && p->element != theElement)
    {
        if (p->element < theElement)
        {
            p = p->right;
        }
        else if (p->element > theElement)
        {
            p->noteSize--;
            p = p->left;
        }
    }
    // 分情况讨论
    // 1.有左右节点的节点进行删除(将两个节点的转化为一个节点的进行删除)
    if (p->left != NULL && p->right != NULL)
    {
        Node<T> *ps = p->right;
        Node<T> *s = p;
        // 寻找右孩子中的最小值，同时各个节点的左边孩子个数减一
        while (ps->left != NULL)
        {
            ps->noteSize--;
            s = ps;
            ps = ps->left;
        }
        // 定义一个新节点，赋值右孩子最小，左边孩子个数等于p
        Node<T> *newNode = new Node<T>(ps->element, p->left, p->right, p->noteSize);
        if (pp == NULL) // 判断是否为空树
            root = newNode;
        else if (p == pp->left) // 将新节点插入到树中
            pp->left = newNode;
        else
            pp->right = newNode;

        if (s == p) // 将pp指针移到s指针处
            pp = newNode;
        else
            pp = s;
        delete p;
        p = ps;
    }
    // 2.只有一个节点
    Node<T> *c;
    // p补上一个空节点
    if (p->left != NULL)
        c = p->left;
    else
        c = p->right;
    if (p == root)
        root = c;
    else
    {
        if (p == pp->left) // 进行对空节点的连接，删除p
            pp->left = c;
        else
            pp->right = c;
    }
    size--;
    delete p;
    return sum;
}

// 查找函数
template <class T>
int binarySearchTree<T>::find(const T &theElement)
{
    Node<T> *p = root;
    int sum = 0;
    while (p != NULL && p->element != theElement) // 对树进行查找，并进行异或值的计算
    {
        sum ^= p->element;
        if (p->element > theElement)
        {
            p = p->left;
        }
        else if (p->element < theElement)
        {
            p = p->right;
        }
    }
    if (p == NULL) // 未找到就输出0
        return 0;
    else
    {
        sum ^= p->element;
        return sum;
    }
}

int main()
{
    binarySearchTree<int> B;
    int m, a, b;
    cin >> m;
    for (int i = 0; i < m; i++)
    {
        cin >> a >> b;
        switch (a)
        {
        case 0:
            cout << B.insert(b) << endl;
            break;
        case 1:
            cout << B.find(b) << endl;
            break;
        case 2:
            cout << B.erase(b) << endl;
            break;
        case 3:
        {
            Node<int> *h = B.search(b - 1);
            cout << B.find(h->element) << endl;
        }
        break;
        case 4:
        {
            Node<int> *g = B.search(b - 1);
            cout << B.erase(g->element) << endl;
        }
        break;
        }
    }
    
    return 0;
}