二叉树的建立与四种遍历方式以及中序线索二叉树

最新推荐文章于 2022-05-24 22:49:19 发布

yiqzq

最新推荐文章于 2022-05-24 22:49:19 发布

阅读量440

点赞数 2

分类专栏：大学知识

本文链接：https://blog.csdn.net/yiqzq/article/details/80184516

版权

大学知识专栏收录该内容

29 篇文章 0 订阅

订阅专栏

2018年5月24日更新
————————————————————————————————————————————————————
根据二叉树的前序和中序遍历进行后序遍历

#include <bits/stdc++.h>
using namespace std;
string pre, in;
typedef struct node {
    char data;
    node* left;
    node* right;
}*Bitree;
Bitree createTree(string pre, string in) {
    Bitree t = NULL;
    if (pre.length() > 0) {
        t = new node;
        t->data = pre[0];
        int index = in.find(pre[0]);
        t->left = createTree(pre.substr(1, index), in.substr(0, index));
        t->right = createTree(pre.substr(index + 1), in.substr(index + 1));
    }
    return t;
}
void postOrder(Bitree T) {
    if (T) {
        postOrder(T->left);
        postOrder(T->right);
        cout << T->data << " ";
    } else return;
}
void destroyTree(Bitree T) {
    if (T) {
        destroyTree(T->left);
        destroyTree(T->right);
        delete T;
    } else return;
}
int main() {
    cout << "请分两行分别输入前序和中序遍历" << endl;
    cin >> pre >> in;
    Bitree T = createTree(pre, in);
    cout << "后序遍历为：";
    postOrder(T);
    destroyTree(T);
    return 0;
}

2018年5月17日更新
————————————————————————————————————————————————
二叉树的非递归遍历

#include <bits/stdc++.h>
using namespace std;
typedef struct node {
    char data;
    struct node *lchild;
    struct node *rchild;
} Node, *Bitree;
char ch;
Bitree T;
Node *CreateBitree() {
    cin >> ch;
    Bitree T;
    if(ch == '#') T = NULL;//注意：二叉树的输入需要严格遵守以#结尾的规则，并且输入顺序按照前序遍历的方式
    else {
        T = new node;
        T->data = ch;
        T->lchild = CreateBitree();
        T->rchild = CreateBitree();
    }
    return T;
}
void PreOrder(Bitree T) {//前序遍历
    stack<Bitree>s;
    if(T) {
        s.push(T);
        while(!s.empty()) {
            T = s.top();
            s.pop();
            printf("%c ", T->data);
            if(T->rchild) s.push(T->rchild);//记得要先将右孩子入栈
            if(T->lchild) s.push(T->lchild);

        }
    }
}
void InOrder(Bitree T) {//非递归中序遍历
    stack<Bitree>s;
    if(T) {
        while(!s.empty() || T  ) {
            if(T) {
                s.push(T);
                T = T->lchild;
            } else {
                T = s.top();
                s.pop();
                printf("%c ", T->data);
                T = T->rchild;
            }
        }
    }
}
void PostOrder(Bitree T) {//非递归后序遍历
    stack<Bitree>s1;
    stack<Bitree>s2;
    if(T) {
        s1.push(T);
        while(!s1.empty()) {
            T = s1.top();
            s2.push(T);
            s1.pop();
            if(T->lchild) s1.push(T->lchild);
            if(T->rchild) s1.push(T->rchild);
        }
    }
    while(!s2.empty()) {
        T = s2.top();
        s2.pop();
        printf("%c ", T->data);

    }
}

void Remove(Bitree T) {//回收内存
    if(T == NULL) return;
    Remove(T->lchild);
    Remove(T->rchild);
    delete T;
}
int main() {
    Bitree T;
    T = CreateBitree();
    cout << "前序遍历为 ";
    PreOrder(T);
    cout << endl << "中序遍历为 ";
    InOrder(T);
    cout << endl << "后序遍历为 ";
    PostOrder(T);
    Remove(T);
    return 0;
}

2018年5月8日更新
——————————————————————————————————————————————————
在原来的功能上加入了中序线索二叉树的功能

/*
         1
        /\
       2  3
      /
     4


比如说上面这棵树，那么输入应该为124###3##






*/
#include <bits/stdc++.h>
using namespace std;
typedef struct node {
    char data;
    struct node *lchild;
    struct node *rchild;
    bool ltag, rtag;
//    node() {
//        data = 0;
//        lchild = rchild = NULL;
//        ltag = rtag = 0;
//    }
} Node, *Bitree;
char ch;
Bitree T;
Node *CreateBitree() {
    cin >> ch;
    Bitree T;
    if(ch == '#') T = NULL;//注意：二叉树的输入需要严格遵守以#结尾的规则，并且输入顺序按照前序遍历的方式
    else {
        T = new node;
        T->data = ch;
        T->ltag = 0;
        T->rtag = 0;
        T->lchild = CreateBitree();
        T->rchild = CreateBitree();
    }
    return T;
}
void PreOrder(Bitree T) {//前序遍历

    if(T) {
        cout << T->data << " ";
        if(T->ltag == 0)PreOrder(T->lchild);
        if(T->rtag == 0)PreOrder(T->rchild);
    }
}
void InOrder(Bitree T) {//中序遍历
    if(T) {
        if(T->ltag == 0)InOrder(T->lchild);
        cout << T->data << " ";
        if(T->rtag == 0) InOrder(T->rchild);
    }
}
void PostOrder(Bitree T) {//后序遍历
    if(T) {
        if(T->ltag == 0) PostOrder(T->lchild);
        if(T->rtag == 0)  PostOrder(T->rchild);
        cout << T->data << " ";
    }
}
void bfs(vector<char>& ans, Bitree T) {//层序遍历
    queue<Bitree>q;
    ans.clear();
    q.push(T);
    while(!q.empty()) {
        Bitree u = q.front();
        q.pop();
        if(u->data != 0)ans.push_back(u->data);
        if(u->ltag ==0) q.push(u->lchild);
        if(u->rtag==0) q.push(u->rchild);
    }
}
//void Remove(Bitree T) {//回收内存
//    if(T == NULL) return;
//    Remove(T->lchild);
//    Remove(T->rchild);
//    delete T;
//}
Bitree pre;
Bitree inthreading(Bitree root) {//中序线索二叉树
    Bitree T = root;
    if(T) {
        inthreading(T->lchild);
        if(T->lchild == NULL) {
            T->ltag = 1;
            T->lchild = pre;
        }
        if(pre->rchild == NULL) {
            pre->rtag = 1;
            pre->rchild = T;
        }
        pre = T;
        inthreading(T->rchild);
    }
    return root;
}
Bitree inorderthrtree(Bitree T) {
    Bitree thre;//对头节点和pre的预处理
    thre = new node;
    thre->lchild = T;
//    thre->rchild = thre;
    pre = thre;
    inthreading(T);
    pre->rtag = 1;//当前pre位于中序遍历的最后一个数
    pre->rchild = thre;//更新后继节点为头节点
//    thre->rchild = pre;//头节点的右孩子为最后一个节点，可以不要
    return thre;
}
void InThrTravel(Bitree Thre) {  //中序遍历二叉树
    Bitree p;
    p = Thre->lchild;
    while(p != Thre) {              //指针回指向头结点时结束
        while(p->ltag == 0)
            p = p->lchild;
        printf("%2c", p->data);
        while(p->rtag == 1 && p->rchild != Thre) {//返回打印
            p = p->rchild;
            printf("%2c", p->data);
        }
        p = p->rchild;//存在右节点了
    }
}

int main() {
    Bitree T;
    T = CreateBitree();
    Bitree root = T;
    cout << endl << "中序线索搜索";
    Bitree Thre = inorderthrtree(T);//thre 是头节点
    InThrTravel(Thre);
    cout << endl << "前序遍历为 ";
    PreOrder(root);
    cout << endl << "中序遍历为 ";
    InOrder(root);
    cout << endl << "后序遍历为 ";
    PostOrder(root);
    cout << endl << "层序遍历为 ";
    vector<char>v;
    vector<char>::iterator it;
    bfs(v, root);
    for(it = v.begin(); it != v.end(); it++) cout << *it << " ";


//    Remove(root);
    return 0;
}

原答案：二叉树的建立与4种遍历方式

#include <bits/stdc++.h>
using namespace std;
typedef struct node {
    char data;
    struct node *lchild;
    struct node *rchild;
} Node, *Bitree;
char ch;
Bitree T;
Node *CreateBitree() {
    cin >> ch;
    Bitree T;
    if(ch == '#') T = NULL;//注意：二叉树的输入需要严格遵守以#结尾的规则，并且输入顺序按照前序遍历的方式
    else {
        T = new node;
        T->data = ch;
        T->lchild = CreateBitree();
        T->rchild = CreateBitree();
    }
    return T;
}
void PreOrder(Bitree T) {//前序遍历
    if(T) {
        cout << T->data << " ";
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }
}
void InOrder(Bitree T) {//中序遍历
    if(T) {
        InOrder(T->lchild);
        cout << T->data << " ";
        InOrder(T->rchild);
    }
}
void PostOrder(Bitree T) {//后序遍历
    if(T) {
        PostOrder(T->lchild);
        PostOrder(T->rchild);
        cout << T->data << " ";
    }
}
void bfs(vector<char>& ans, Bitree T) {//层序遍历
    queue<Bitree>q;
    ans.clear();
    q.push(T);
    while(!q.empty()) {
        Bitree u = q.front();
        q.pop();
        if(u->data != 0)ans.push_back(u->data);
        if(u->lchild != NULL) q.push(u->lchild);
        if(u->rchild != NULL) q.push(u->rchild);
    }
}
void Remove(Bitree T) {//回收内存
    if(T == NULL) return;
    Remove(T->lchild);
    Remove(T->rchild);
    delete T;
}
int main() {
    Bitree T;
    T = CreateBitree();
    cout << "前序遍历为 ";
    PreOrder(T);
    cout << endl << "中序遍历为 ";
    InOrder(T);
    cout << endl << "后序遍历为 ";
    PostOrder(T);
    cout << endl << "层序遍历为 ";
    vector<char>v;
    vector<char>::iterator it;
    bfs(v, T);
    for(it = v.begin(); it != v.end(); it++) cout << *it << " ";
    Remove(T);
    return 0;
}