平衡树

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <cmath>
#include <cctype>
#include <bitset>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<int, int> Pair;

const ull mod = 1e9 + 7;
const int INF = 0x7fffffff;

template <typename T> struct AVL_Node {
    AVL_Node(T value, AVL_Node<T>* Left, AVL_Node<T>* Right) : key(value), lson(Left), rson(Right) {
        repeat = height = size = 1;
    }
    T key;
    int height, size, repeat;

    AVL_Node<T>* lson;
    AVL_Node<T>* rson;
};

template <typename T> class AVL {
public:
    AVL() : root(nullptr) {};
    ~AVL();
    void insert(T key);
    void remove(T key);
    T find_by_order(int k);
    bool find(T key);
    T max();
    T min();
    int size();
    int height();
    void destory();
private:
    AVL_Node<T>* root;
    AVL_Node<T>* insert(AVL_Node<T>* &pnode, T key);
    AVL_Node<T>* remove(AVL_Node<T>* &pnode, T key);
    T find_by_order(AVL_Node<T>* pnode, int k);
    bool find(AVL_Node<T>* pnode, T key);
    AVL_Node<T>* max(AVL_Node<T>* pnode);
    AVL_Node<T>* min(AVL_Node<T>* pnode);
    int height(AVL_Node<T>* pnode);
    int size(AVL_Node<T>* pnode);
    int max(int a, int b);
    AVL_Node<T>* zag(AVL_Node<T>* pnode);
    AVL_Node<T>* zig(AVL_Node<T>* pnode);
    AVL_Node<T>* zag_zig(AVL_Node<T>* pnode);
    AVL_Node<T>* zig_zag(AVL_Node<T>* pnode);
    void destory(AVL_Node<T>* &pnode);
};

int N, M;
char cmd[10];
int cmd_num;

int main()
{
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
#endif // __AiR_H
    AVL<int> avl;
    scanf("%d %d", &N, &M);
    int num;
    while (N--) {
        scanf("%d", &num);
        avl.insert(num);
    }
    while (M--) {
        scanf("%s %d", cmd, &cmd_num);
        if (cmd[0] == 'i') {
            avl.insert(cmd_num);
        } else if (cmd[0] == 'd') {
            if (!avl.find(cmd_num)) {
                printf("invalid number!\n");
            } else {
                avl.remove(cmd_num);
            }
        } else {
            if (cmd_num > avl.size()) {
                printf("invalid K!\n");
            } else {
                printf("%d\n", avl.find_by_order(avl.size() + 1 - cmd_num));
            }
        }
    }
    return 0;
}

template <typename T> AVL<T>::~AVL(void)
{
    destory();
}

template <typename T> bool AVL<T>::find(T key)
{
    return find(root, key);
}

template <typename T> bool AVL<T>::find(AVL_Node<T>* pnode, T key)
{
    while (pnode != nullptr) {
        if (pnode->key == key) {
            return true;
        } else if (key < pnode->key) {
            pnode = pnode->lson;
        } else {
            pnode = pnode->rson;
        }
    }
    return false;
}

template <typename T> void AVL<T>::remove(T key)
{
    remove(root, key);
}

template <typename T> AVL_Node<T>* AVL<T>::remove(AVL_Node<T>* &pnode, T key)
{
    if (pnode == nullptr) {
        return nullptr;
    }
    if (key == pnode->key) {
        if (pnode->lson != nullptr && pnode->rson != nullptr) {
            if (height(pnode->lson) > height(pnode->rson)) {
                AVL_Node<T>* pmax = max(pnode->lson);
                pnode->key = pmax->key;
                pnode->lson = remove(pnode->lson, pmax->key);
            } else {
                AVL_Node<T>* pmin = min(pnode->rson);
                pnode->key = pmin->key;
                pnode->rson = remove(pnode->rson, pmin->key);
            }
        } else {
            AVL_Node<T>* pt = pnode;
            if (pnode->lson != nullptr) {
                pnode = pnode->lson;
            } else {
                pnode = pnode->rson;
            }
            delete pt;
            pt = nullptr;
        }
    } else if (key > pnode->key) {
        pnode->rson = remove(pnode->rson, key);
        if (height(pnode->lson) - height(pnode->rson) == 2) {
            if (height(pnode->lson->lson) > height(pnode->lson->rson)) {
                pnode = zig(pnode);
            } else {
                pnode = zag_zig(pnode);
            }
        }
    } else {
        pnode->lson = remove(pnode->lson, key);
        if (height(pnode->rson) - height(pnode->lson) == 2) {
            if (height(pnode->rson->rson) > height(pnode->rson->lson)) {
                pnode = zag(pnode);
            } else {
                pnode = zig_zag(pnode);
            }
        }
    }
    if (pnode == nullptr) {
        return nullptr;
    }
    pnode->height = max(height(pnode->lson), height(pnode->rson)) + 1;
    pnode->size = size(pnode->lson) + size(pnode->rson) + pnode->repeat;
    return pnode;
}

template <typename T> T AVL<T>::max()
{
    AVL_Node<T>* pret = max(root);
    if (pret != nullptr) {
        return pret->key;
    }
}

template <typename T> AVL_Node<T>* AVL<T>::max(AVL_Node<T>* pnode)
{
    if (pnode == nullptr) {
        return nullptr;
    }
    while (pnode->rson != nullptr) {
        pnode = pnode->rson;
    }
    return pnode;
}

template <typename T> T AVL<T>::min()
{
    AVL_Node<T>* pret = min(root);
    if (pret != nullptr) {
        return pret->key;
    }
}

template <typename T> AVL_Node<T>* AVL<T>::min(AVL_Node<T>* pnode)
{
    if (pnode == nullptr) {
        return nullptr;
    }
    while (pnode->lson != nullptr) {
        pnode = pnode->lson;
    }
    return pnode;
}

template <typename T> T AVL<T>::find_by_order(int k)
{
    return find_by_order(root, k);
}

template <typename T> int AVL<T>::max(int a, int b)
{
    return a > b ? a : b;
}

template <typename T> T AVL<T>::find_by_order(AVL_Node<T>* pnode, int k)
{
    int lsize = size(pnode->lson);
    if (k <= lsize) {
        return find_by_order(pnode->lson, k);
    } else if (k > lsize+pnode->repeat) {
        return find_by_order(pnode->rson, k-lsize-pnode->repeat);
    }
    return pnode->key;
}

template <typename T> void AVL<T>::insert(T key)
{
    insert(root, key);
}

template <typename T> AVL_Node<T>* AVL<T>::insert(AVL_Node<T>* &pnode, T key)
{
    if (pnode == nullptr) {
        pnode = new AVL_Node<T>(key, nullptr, nullptr);
    } else if (key > pnode->key) {
        pnode->rson = insert(pnode->rson, key);
        if (height(pnode->rson) - height(pnode->lson) == 2) {
            if (key > pnode->rson->key) {
                pnode = zag(pnode);
            } else {
                pnode = zig_zag(pnode);
            }
        }
    } else if (key < pnode->key) {
        pnode->lson = insert(pnode->lson, key);
        if (height(pnode->lson) - height(pnode->rson) == 2) {
            if (key < pnode->lson->key) {
                pnode = zig(pnode);
            } else {
                pnode = zag_zig(pnode);
            }
        }
    } else {
        ++pnode->repeat;
    }
    pnode->height = max(height(pnode->lson), height(pnode->rson)) + 1;
    pnode->size = size(pnode->lson) + size(pnode->rson) + pnode->repeat;
    return pnode;
}

template <typename T> AVL_Node<T>* AVL<T>::zag(AVL_Node<T>* pnode)
{
    AVL_Node<T>* prson = pnode->rson;
    pnode->rson = prson->lson;
    prson->lson = pnode;
    pnode->height = max(height(pnode->lson), height(pnode->rson)) + 1;
    pnode->size = size(pnode->lson) + size(pnode->rson) + pnode->repeat;
    prson->height = max(height(prson->lson), height(prson->rson)) + 1;
    prson->size = size(prson->lson) + size(prson->rson) + prson->repeat;
    return prson;
}


template <typename T> AVL_Node<T>* AVL<T>::zig(AVL_Node<T>* pnode)
{
    AVL_Node<T>* plson = pnode->lson;
    pnode->lson = plson->rson;
    plson->rson = pnode;

    pnode->height = max(height(pnode->lson), height(pnode->rson)) + 1;
    pnode->size = size(pnode->lson) + size(pnode->rson) + pnode->repeat;
    plson->height = max(height(plson->lson), height(plson->rson)) + 1;
    plson->size = size(plson->lson) + size(plson->rson) + plson->repeat;
    return plson;
}

template <typename T> AVL_Node<T>* AVL<T>::zag_zig(AVL_Node<T>* pnode)
{
    pnode->lson = zag(pnode->lson);
    return zig(pnode);
}

template <typename T> AVL_Node<T>* AVL<T>::zig_zag(AVL_Node<T>* pnode)
{
    pnode->rson = zig(pnode->rson);
    return zag(pnode);
}

template <typename T> int AVL<T>::size()
{
    return size(root);
}

template <typename T> int AVL<T>::size(AVL_Node<T>* pnode)
{
    if (pnode == nullptr) {
        return 0;
    }
    return pnode->size;
}

template <typename T> int AVL<T>::height(void)
{
    return height(root);
}

template <typename T> int AVL<T>::height(AVL_Node<T>* pnode)
{
    if (pnode != nullptr) {
        return pnode->height;
    }
    return 0;
}

template <typename T> void AVL<T>::destory(void)
{
    destory(root);
}

template <typename T> void AVL<T>::destory(AVL_Node<T>* &pnode)
{
    if (pnode != nullptr) {
        destory(pnode->lson);
        destory(pnode->rson);
        delete pnode;
        pnode = nullptr;
    }
}