数据结构综合性实验：多种功能的平衡二叉排序树

　　数据结构的期末作业是关于平衡二叉排序树的综合性实验，其中需要完成的功能有：

（1） 插入新结点 

（2） 前序、中序、后序遍历二叉树 （递归）

（3） 前序、中序、后序遍历的非递归算法 

（4） 层次遍历二叉树 

（5） 在二叉树中查找给定关键字(函数返回值为成功1,失败0) 

（6） 交换各结点的左右子树 

（7） 求二叉树的深度 

（8） 叶子结点数

（9） 删除某结点

　　搞了两三天，上面的功能都实现了。而且我弄的是模板，兼容性也就相对强了一些。

　　其实这对我只是一个锻炼而已，目测代码方面还有很多的地方可以改进，欢迎读者提出或指正。

　　弄这个的时候发现一个比较矛盾的地方，就是其中会有树交换子树的操作。交换后，原来升序将会变成降序，反之亦然。所以，我在做的时候就不是单纯的给出交换子树的算法，而是在这个处理过后修改一个标记。初始化排序是按非降排序的，如果进行过一次倒置操作，树将以非升方式排序。这样就保持了二叉排序树的特性了。

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <cassert>
#include <ctime>

using namespace std;

/********** simple stack template by Lyon   2012.11.24 **********/
template <class T>
class Stack {
    int maxSize, curSize;
    T *elem;
public:
    void init() { // initialize stack
        maxSize = 16;
        curSize = 0;
        elem = (T *) malloc(maxSize * sizeof(T));
    }
    bool empty() { // whether the stack is empty
        return curSize == 0;
    }
    int size() { // get the size
        return curSize;
    }
    void push(T e) { // push e into stack
        while (curSize >= maxSize) {
            maxSize <<= 1;
            elem = (T *) realloc(elem, maxSize * sizeof(T));
        }
        elem[curSize++] = e;
    }
    void pop() { // pop out the top element
        assert(curSize > 0);
        curSize--;
    }
    T top() { // get the top element
        assert(curSize > 0);
        return elem[curSize - 1];
    }
} ;
/****************************************************************/

/********** simple queue template by Lyon   2012.11.24 **********/
template <class T>
class Queue {
    struct Node {
        T elem;
        Node *next;
        Node (T &x) {
            elem = x;
            next = NULL;
        }
    } *head, *tail;
    int curSize;
public:
    void init() { // initialize queue
        head = tail = NULL;
        curSize = 0;
    }
    bool empty() { // whether the queue is empty
        return curSize == 0;
    }
    int size() { // get the size
        return curSize;
    }
    void push(T &e) { // push e into queue
        if (head == NULL) {
            head = tail = new Node(e);
        } else {
            tail->next = new Node(e);
            tail = tail->next;
        }
        curSize++;
    }
    void pop() { // pop out the front element
        assert(head != NULL);
        Node *tmp = head;
        head = head->next;
        if (tail == tmp) tail = NULL;
        delete tmp;
        curSize--;
    }
    T front() { // get the front element
        assert(head != NULL);
        return head->elem;
    }
    T back() { // get the back element
        assert(tail != NULL);
        return tail->elem;
    }
} ;
/****************************************************************/

/********** SBTree(short for Size-Balanced Tree) template by Lyon  2012.11.24 **********/
template <class T>
struct SBTNode { // size-balanced tree's node
    int size, depth, leaf; // size - subtree's size, depth - subtree's depth, leaf - the number of leaf in subtree
    T key;
    SBTNode<T> *c[2]; // two child
    SBTNode<T> (T k) {
        key = k;
        size = 1;
        depth = 1;
        leaf = 1;
        c[0] = c[1] = NULL;
    }
} ;
template <class T>
class SBTree { // size-balanced tree
    SBTNode<T> *Root;
    bool less; // the way of sort
    void delTree(SBTNode<T> *&rt) { // delete the tree
        if (!rt) return ;
        delTree(rt->c[0]);
        delTree(rt->c[1]);
        delete rt;
        rt = NULL;
        less = false;
    }
    void rotate(SBTNode<T> *&x, bool left) { // rotate subtree x
        bool right = !left;
        SBTNode<T> *y = x->c[left];
        x->c[left] = y->c[right];
        y->c[right] = x;
        y->size = x->size;
        x->size = (x->c[0] ? x->c[0]->size : 0) + (x->c[1] ? x->c[1]->size : 0) + 1;
        x->depth = max(x->c[0] ? x->c[0]->depth : 0, x->c[1] ? x->c[1]->depth : 0) + 1;
        y->depth = max(y->c[0] ? y->c[0]->depth : 0, y->c[1] ? y->c[1]->depth : 0) + 1;
        x->leaf = x->c[0] == NULL && x->c[1] == NULL ? 1 : (x->c[0] ? x->c[0]->leaf : 0) + (x->c[1] ? x->c[1]->leaf : 0);
        x = y;
    }
    void maintain(SBTNode<T> *&rt, bool right) { // maintain subtree rt, if the right side of subtree is deeper
        if (!rt->c[right] || !rt) return ;
        bool left = !right;
        int ls = rt->c[left] ? rt->c[left]->size : 0;
        if (rt->c[right]->c[right] && rt->c[right]->c[right]->size > ls) rotate(rt, right);
        else if (rt->c[right]->c[left] && rt->c[right]->c[left]->size > ls) rotate(rt->c[right], left), rotate(rt, right);
        else return ;
        maintain(rt->c[0], false);
        maintain(rt->c[1], true);
        maintain(rt, false);
        maintain(rt, true);
    }
    void insert(SBTNode<T> *&rt, SBTNode<T> *x) { // insert x into subtree rt
        if (!rt) {
            rt = x;
            return ;
        }
        rt->size++;
        insert(rt->c[(x->key >= rt->key) ^ less], x);
        maintain(rt, (x->key >= rt->key) ^ less);
        rt->depth = max(rt->c[0] ? rt->c[0]->depth : 0, rt->c[1] ? rt->c[1]->depth : 0) + 1;
        rt->leaf = rt->c[0] == NULL && rt->c[1] == NULL ? 1 : (rt->c[0] ? rt->c[0]->leaf : 0) + (rt->c[1] ? rt->c[1]->leaf : 0);
    }
    bool erase(SBTNode<T> *&rt, T k) { // erase key k in subtree rt
        if (!rt) return false;
        rt->size--;
        if (k == rt->key) {
            SBTNode<T> *t;
            if (!rt->c[0] && !rt->c[1]) {
                delete rt;
                rt = NULL;
            } else if (!rt->c[1]) {
                t = rt, rt = rt->c[0];
                delete t;
            } else if (!rt->c[0]) {
                t = rt, rt = rt->c[1];
                delete t;
            } else {
                t = rt->c[1];
                while (t->c[0]) t = t->c[0];
                rt->key = t->key;
                return erase(rt->c[1], t->key);
            }
        } else return erase(rt->c[(k > rt->key) ^ less], k);
        if (rt) {
            rt->depth = max(rt->c[0] ? rt->c[0]->depth : 0, rt->c[1] ? rt->c[1]->depth : 0) + 1;
            rt->leaf = rt->c[0] == NULL && rt->c[1] == NULL ? 1 : (rt->c[0] ? rt->c[0]->leaf : 0) + (rt->c[1] ? rt->c[1]->leaf : 0);
        }
        return true;
    }
    void Traverse(SBTNode<T> *rt, int kind) { // recursive traverse : 1.pre 2.in 3.post
        if (!rt) return ;
        if (kind == 1) cout << rt->key << ends;
        Traverse(rt->c[0], kind);
        if (kind == 2) cout << rt->key << ends;
        Traverse(rt->c[1], kind);
        if (kind == 3) cout << rt->key << ends;
    }
    void nonRecursiveTraverse(int kind) { // non-recursive traverse : 1.pre 2.in 3.post
        Stack<pair<SBTNode<T> *, int> > rec;
        SBTNode<T> *cur;
        int t;
        rec.init();
        rec.push(make_pair(Root, 1));
        while (rec.size()) {
            cur = rec.top().first;
            t = rec.top().second;
            rec.pop();
            if (cur && t == kind) cout << cur->key << ends;
            if (!cur || t >= 3 || t <= 0) continue;
//            cout << cur->key << '-' << t << ends;
            rec.push(make_pair(cur, t + 1));
            rec.push(make_pair(cur->c[t - 1], 1));
        }
    }
    void reverse(SBTNode<T> *rt) { // reverse subtree rt
        if (!rt) return ;
        swap(rt->c[0], rt->c[1]);
        reverse(rt->c[0]);
        reverse(rt->c[1]);
    }
public:
    void init(bool cmp = false) { // initialize SBTree
        Root = NULL;
        less = cmp;
    }
    bool empty() {
        return Root == NULL;
    }
    void delTree() { // delete SBTree
        delTree(Root);
        cout << "The Size-balanced Tree is deleted!" << endl;
    }
    void insert(T x) { // insert x into SBTree
        SBTNode<T> *tmp = new SBTNode<T>(x);
        insert(Root, tmp);
        cout << "Element " << x << " Insert Successfully!" << endl;
    }
    bool erase(T k) { // erase k in SBTree
        if (erase(Root, k)) {
            cout << "Element " << k << " Erase Successfully!" << endl;
            return true;
        } else {
            cout << "Element " << k << " not found!" << endl;
            return false;
        }
    }
    void preTraverse() { // output the pre-traverse array
        cout << "The pre-Traverse array is:" << endl;
        Traverse(Root, 1);
        cout << endl;
    }
    void inTraverse() { // output the in-traverse array
        cout << "The in-Traverse array is:" << endl;
        Traverse(Root, 2);
        cout << endl;
    }
    void postTraverse() { // output the post-traverse array
        cout << "The post-Traverse array is:" << endl;
        Traverse(Root, 3);
        cout << endl;
    }
    void nonRecursivePreTraverse() { // in non-recursive way
        cout << "The pre-Traverse array is (non-recursive):" << endl;
        nonRecursiveTraverse(1);
        cout << endl;
    }
    void nonRecursiveInTraverse() { // in non-recursive way
        cout << "The in-Traverse array is (non-recursive):" << endl;
        nonRecursiveTraverse(2);
        cout << endl;
    }
    void nonRecursivePostTraverse() { // in non-recursive way
        cout << "The post-Traverse array is (non-recursive):" << endl;
        nonRecursiveTraverse(3);
        cout << endl;
    }
    bool find(T key) { // find key value in SBTree
        SBTNode<T> *p = Root;
        while (true) {
            if (!p) return false;
            if (key == p->key) return true;
            if ((key < p->key) ^ less) p = p->c[0];
            else p = p->c[1];
        }
    }
    int depth() {
        return Root->depth;    // the depth of SBTree
    }
    int leaves() {
        return Root->leaf;    // the number of leaf in SBTree
    }
    void reverse() { // reverse SBTree
        less = !less;
        reverse(Root);
        cout << "Tree is reversed!" << endl;
    }
    void nonRecursiveReverseDFS() { // in non-recursive way
        less = !less;
        Stack<pair<SBTNode<T> *, int> > rec;
        SBTNode<T> *cur;
        int t;
        rec.init();
        rec.push(make_pair(Root, 1));
        while (rec.size()) {
            cur = rec.top().first;
            t = rec.top().second;
            rec.pop();
            if (!cur || t >= 3 || t <= 0) continue;
            if (t == 1) swap(cur->c[0], cur->c[1]);
//            cout << cur->key << '-' << t << ends;
            rec.push(make_pair(cur, t + 1));
            rec.push(make_pair(cur->c[t - 1], 1));
        }
    }
    void nonRecursiveReverseBFS() {
        less = !less;
        Queue<SBTNode<T> *> tmp;
        SBTNode<T> *cur;
        tmp.init();
        tmp.push(Root);
        while (tmp.size()) {
            cur = tmp.front();
            swap(cur->c[0], cur->c[1]);
            if (cur->c[0]) tmp.push(cur->c[0]);
            if (cur->c[1]) tmp.push(cur->c[1]);
        }
        cout << "Tree is reversed!" << endl;
    }
    void levelTraverse() { // level traverse
        Queue<SBTNode<T> *> q;
        cout << "The level traverse array is:" << endl;
        q.init();
        q.push(Root);
        SBTNode<T> *cur;
        while (q.size()) {
            cur = q.front();
            q.pop();
            cout << cur->key << ends;
            if (cur->c[0]) q.push(cur->c[0]);
            if (cur->c[1]) q.push(cur->c[1]);
        }
        cout << endl;
    }
} ;
/*************************************************************************************/



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

int main() {
    int n, e, op;
    char buf[100];

    SBT.init();
    cout << "请输入树的节点个数：";
    cin >> n;
    cout << "请输入" << n << "个整数：";
    REP(i, n) {
        cin >> e;
        SBT.insert(e);
    }
    system("pause > nul");
    system("cls");
    while (true) {
        while (true) {
            cout << "━━━━━━━━━━━━━━━━━┓\n";
            cout << "  1.查看树的前中后序及层次遍历    ┃\n";
            cout << "  2.查看树的前中后序遍历（非递归）┃\n";
            cout << "  3.查找树的结点                  ┃\n";
            cout << "  4.查看树的深度和叶子结点个数    ┃\n";
            cout << "  5.交换树的左右子树              ┃\n";
            cout << "  6.插入新的结点                  ┃\n";
            cout << "  7.删除结点                      ┃\n";
            cout << "  8.退出程序                      ┃\n";
            cout << "━━━━━━━━━━━━━━━━━┛\n";
            cout << "请输入操作编号：";
            cin >> op;
            if (0 <= op && op <= 8) break;
            cout << "输入错误，请重新输入!" << endl;
            system("pause > nul");
            system("cls");
        }
        switch (op) {
        case 1:
            if (SBT.empty()) cout << "当前树为空树" << endl;
            else {
                SBT.preTraverse();
                SBT.inTraverse();
                SBT.postTraverse();
                SBT.levelTraverse();
            }
            break;
        case 2:
            if (SBT.empty()) cout << "当前树为空树" << endl;
            else {
                SBT.nonRecursivePreTraverse();
                SBT.nonRecursiveInTraverse();
                SBT.nonRecursivePostTraverse();
            }
            break;
        case 3:
            cout << "请输入需要查找结点的值：";
            cin >> e;
            if (SBT.find(e)) cout << "查找成功，该结点存在！" << endl;
            else cout << "查找失败，该结点不存在！" << endl;;
            break;
        case 4:
            cout << "树的深度为：" << SBT.depth() << endl;
            cout << "树的叶子结点个数为：" << SBT.leaves() << endl;
            break;
        case 5:
            cout << "确定要交换树的左右结点吗？（交换以后，元素升降序将改变）" << endl << "按'Y'键后回车继续：";
            cin >> buf;
            strlwr(buf);
            if (buf[0] == 'y') {
                SBT.reverse();
                cout << "操作成功" << endl;
            } else cout << "已放弃操作" << endl;
            break;
        case 6:
            cout << "请输入新结点的值：";
            cin >> e;
            SBT.insert(e);
            cout << "结点已成功插入" << endl;
            break;
        case 7:
            if (SBT.empty()) cout << "当前树为空树，不能进行删除操作" << endl;
            else {
                SBT.nonRecursiveInTraverse();
                cout << "请输入要删除的结点的值: ";
                cin >> e;
                if (!SBT.erase(e)) cout << "操作失败，该结点不存在" << endl;
                else cout << "操作成功" << endl;
            }
            break;
        case 8:
            SBT.delTree();
            cout << "操作成功，可以安全退出！" << endl;
            system("pause > nul");
            return 0;
        default:
            cout << "出现异常！" << endl;
            return -1;
        }
        system("pause > nul");
        system("cls");
    }
}

 

——written by Lyon