清華2019計算機專業碩士編程題解答實測

//後序遍歷情況下的第k個節點 
BiNode* BiTree::rank(BiNode *t,int k)

 

#ifndef BITREE_H_INCLUDED
#define BITREE_H_INCLUDED
#include<iostream>
#include <string>
#include "queue"
#include "stack"
#include "vector"

using namespace std;
class BiNode {
    public:
        char data;
        struct BiNode *lchild,*rchild;
        int size;
};

class BiTree {
    public:
        BiNode * root;
        int height;
        void pre_Order(BiNode * t);
        void in_Order(BiNode * t);
        void post_Order(BiNode * t);
        BiNode* create(string &s ,int&pos);
        void get_Height(BiNode *t,int h);
        int updatesize(BiNode *t);
        BiNode* rank(BiNode *t,int k);
    public:
        BiTree() {
            root=NULL;
            height=0;
        }
        ///按照前序遍歷序列創建二叉樹
        void createBiTree(string s);
        ///前序遍歷二叉樹
        void preOrder();
        ///中序遍歷二叉樹
        void inOrder();
        ///後序遍歷二叉樹(遞歸方法)
        void postOrder();
        ///後序遍歷二叉樹(使用棧的非遞歸方法)
        void postOrder1();
        ///層序遍歷二叉樹
        void levelOrder();
        ///求樹的高度
        int getHeight();
        ///求兩個節點的最大公共祖先
        void ancestor(char A,char B);
};



#endif // BITREE_H_INCLUDED
BiNode * BiTree::create(string &s,int &pos) {
    ++pos;
    BiNode * t;
    if((unsigned)pos>=s.size())
        return NULL;
    else {
        if(s[pos]=='#')
            t=NULL;
        else {
            t=new BiNode;
            t->data=s[pos];
            t->lchild=create(s,pos);
            t->rchild=create(s,pos);
        }
        return t;
    }
}
///按照前序遍歷序列創建二叉樹
void BiTree::createBiTree(string s) {
    int pos = -1;
    root=create(s,pos);
}
///前序遍歷二叉樹
void BiTree::preOrder() {
    pre_Order(root);
    cout<<endl;
}
void BiTree::pre_Order(BiNode * t) {
    if(t!=NULL) {
        cout<<t->data<<' ';
        pre_Order(t->lchild);
        pre_Order(t->rchild);
    }
}
///中序遍歷二叉樹
void BiTree::inOrder() {
    in_Order(root);
    cout<<endl;
}
void BiTree::in_Order(BiNode *t) {
    if(t!=NULL) {
        in_Order(t->lchild);
        cout<<t->data<<' ';
        in_Order(t->rchild);
    }
}
///後序遍歷二叉樹(遞歸方法)
void BiTree::postOrder() {
    post_Order(root);
    cout<<endl;
}
void BiTree::post_Order(BiNode *t) {
    if(t!=NULL) {
        post_Order(t->lchild);
        post_Order(t->rchild);
        cout<<t->data<<' ';
    }
}
///後序遍歷二叉樹(使用棧的非遞歸方法)
///後續遍歷先遍歷左子樹，再遍歷右子樹，最後遍歷根節點
///對於一個節點而言，先一直遍歷到最左節點
///然後用r記錄右子樹是否遍歷，如果沒有遍歷，則遍歷右子樹
void BiTree::postOrder1() {
    ///p表示當前樹節點指針，
    ///r表示最近訪問的樹節點指針
    BiNode *p,*r;
    r = NULL;
    p = root;
    stack<BiNode*> my_stack;
    while(p!=NULL || !my_stack.empty()) {
        if(p) {
            ///一直走到樹的最左邊
            my_stack.push(p);
            p=p->lchild;
        }
        else {
            p=my_stack.top();
            ///如果右子樹沒有遍歷，遍歷右子樹
            if(p->rchild!=NULL && p->rchild!=r) {
                p=p->rchild;
                my_stack.push(p);
                ///注意這裏需要向左轉，因爲如果不向左轉，
                ///將會遍歷右子樹節點兩邊
                p=p->lchild;

            }
            ///否則遍歷根節點
            else {
                p=my_stack.top();
                my_stack.pop();
                cout<<p->data<<' ';
                ///更新最近遍歷的節點
                r=p;
                ///將遍歷後的節點設爲NULL，進行下一個節點的遍歷
                p=NULL;
            }
        }
    }
    cout<<endl;
}
///使用隊列進行層序遍歷二叉樹
void BiTree::levelOrder() {
    if(root==NULL)
        return;
    queue<BiNode*> q;
    q.push(root);
    while(!q.empty()) {
        BiNode * t;
        t=q.front();
        q.pop();
        cout<<t->data<<"("<<t->size<<") ";
        if(t->lchild!=NULL)
            q.push(t->lchild);
        if(t->rchild!=NULL)
            q.push(t->rchild);
    }
    cout<<endl;
}
///求樹的高度
int BiTree::getHeight() {
    get_Height(root,0);
    return height;
}

int BiTree::updatesize(BiNode *t) {
    if(t==NULL) return 0;
    if(t->lchild==NULL&&t->rchild==NULL)
        return t->size=1;
    return t->size=updatesize(t->lchild)+updatesize(t->rchild)+1;
}

void BiTree::get_Height(BiNode *t,int h) {
    if(t!=NULL) {
        ++h;
        if(h>height)
            height=h;
        get_Height(t->lchild,h);
        get_Height(t->rchild,h);
    }
}
//後序遍歷情況下的第k個節點 
BiNode* BiTree::rank(BiNode *t,int k)
{
    if(t==NULL||t->size<k) return NULL;
    while(true)
    {
        if(t->size==k)
        {
            return t;
        } v
        if(t->lchild!=NULL && t->lchild->size<k ||t->lchild==NULL )
        {
            if(t->lchild!=NULL) k=k-t->lchild->size;
            t=t->rchild;
        }
        else
        {
            t=t->lchild;
        }
    }

}
int main()
{
    BiTree a;
    string s;
    s="ABD##E#F##C##";
    a.createBiTree(s);
    cout<<"前序遍歷："<<endl;
    a.preOrder();
    cout<<"中序遍歷："<<endl;
    a.inOrder();
    cout<<"後序遍歷1："<<endl;
    a.postOrder();
    cout<<"後序遍歷2："<<endl;
    a.postOrder1();
    cout<<"層序遍歷："<<endl;

    cout<<"樹高："<<endl;
    cout<<a.getHeight()<<endl;
    cout<<"jiediannom"<<endl;
    cout<<a.updatesize(a.root)<<endl;
    a.levelOrder();
    cout<<a.rank(a.root,6)->data<<endl;
    return 0;
}