数据结构大实习——二叉树与数

#include <iostream>
#include <cstring>
#include <string>
#include <cstdlib>
#include <queue>
#include <cstdio>
#include <stack>

using namespace std;

typedef struct node
{
    char data[100];
    node *lt,*rt;
    bool ltag,rtag;
} tree;

bool flag,root;
char in[100];

void TreeNodeSet(tree *&t)//初始化指针
{
    t=(tree*)malloc(sizeof(tree));
    t->lt=NULL;
    t->rt=NULL;
    t->ltag=true;
    t->rtag=true;
    return ;
}

void DfsTagSet(tree *&t)//初始化节点标记
{
    if(t==NULL)return ;
    t->ltag=true;
    t->rtag=true;
    DfsTagSet(t->lt);
    DfsTagSet(t->rt);
    return ;
}

void ClearQue(queue<tree**> &q)//清空队列
{
    while(!q.empty())
    {
        q.pop();
    }
    return ;
}

void CreatBsTree(tree *&t)//按层次建立二叉树
{
    queue<tree**> q;
    int n;
    cout<<"tree's level:";
    cin>>n;
    TreeNodeSet(t);
    q.push(&t);
    for(int lev=0; lev<n; lev++)
    {
        int len=q.size();
        for(int i=0; i<len; i++)
        {
            tree **tmp=q.front();
            q.pop();
            cout<<"level "<<lev+1<<" no "<<i+1<<":";
            scanf("%s",in);
            if(strcmp(in,"NULL")==0)
            {
                free(*tmp);
                (*tmp)=NULL;
            }
            else
            {
                strcpy((*tmp)->data,in);
                if(lev!=n-1)
                {
                    TreeNodeSet((*tmp)->lt);
                    q.push(&((*tmp)->lt));
                    TreeNodeSet((*tmp)->rt);
                    q.push(&((*tmp)->rt));
                }
            }
        }
    }
    ClearQue(q);
}

void PreOrderDfs(tree *&t)//递归先序遍历
{
    if(t==NULL)return ;
    flag?cout<<t->data:cout<<" "<<t->data;
    flag=false;
    PreOrderDfs(t->lt);
    PreOrderDfs(t->rt);
    return ;
}

void MidOrderDfs(tree *&t)//递归中序遍历
{
    if(t==NULL)return ;
    MidOrderDfs(t->lt);
    flag?cout<<t->data:cout<<" "<<t->data;
    flag=false;
    MidOrderDfs(t->rt);
    return ;
}

void LastOrderDfs(tree *&t)//递归后序遍历
{
    if(t==NULL)return ;
    LastOrderDfs(t->lt);
    LastOrderDfs(t->rt);
    flag?cout<<t->data:cout<<" "<<t->data;
    flag=false;
    return ;
}

void PreOrderStack(tree *&t)//非递归先序遍历
{
    stack<tree*> s;
    s.push(t);
    while(!s.empty())
    {
        tree *tmp=s.top();
        s.pop();
        flag?cout<<tmp->data:cout<<" "<<tmp->data;
        flag=false;
        if(tmp->rt!=NULL)
            s.push(tmp->rt);
        if(tmp->lt!=NULL)
            s.push(tmp->lt);
    }
    return ;
}

void MidOrderStack(tree *&t)//非递归中序遍历
{
    stack<tree *> s;
    s.push(t);
    while(!s.empty())
    {
        tree *tmp=s.top();
        if(tmp->ltag&&tmp->lt!=NULL)
            s.push(tmp->lt),tmp->ltag=false;
        else
        {
            s.pop();
            flag?cout<<tmp->data:cout<<" "<<tmp->data;
            flag=false;
            if(tmp->rtag&&tmp->rt!=NULL)
                s.push(tmp->rt),tmp->rtag=false;
        }
    }
    return ;
}

void LastOrderStack(tree *&t)//非递归后序遍历
{
    DfsTagSet(t);
    stack<tree*> s;
    s.push(t);
    while(!s.empty())
    {
        tree *tmp=s.top();
        if((!tmp->ltag)&&(!tmp->rtag))
        {
            flag?cout<<tmp->data:cout<<" "<<tmp->data;
            flag=false;
            s.pop();
        }
        if(tmp->rtag&&tmp->rt!=NULL)
            s.push(tmp->rt);
        tmp->rtag=false;
        if(tmp->ltag&&tmp->lt!=NULL)
            s.push(tmp->lt);
        tmp->ltag=false;
    }
    return ;
}

void BsTree(tree *&t)//二叉树建立以及输出
{
    CreatBsTree(t);
    cout<<"DFS:"<<endl;
    cout<<"The PreOrderDfsTraversal:"<<endl<<"{ ";
    flag=true;
    PreOrderDfs(t);
    cout<<" }"<<endl;
    cout<<"The MidOrderDfsTraversal:"<<endl<<"{ ";
    flag=true;
    MidOrderDfs(t);
    cout<<" }"<<endl;
    cout<<"The LastOrderDfsTraversal:"<<endl<<"{ ";
    flag=true;
    LastOrderDfs(t);
    cout<<" }"<<endl;
    cout<<"STACK:"<<endl;
    cout<<"The PreOrderStackTraversal:"<<endl<<"{ ";
    flag=true;
    PreOrderStack(t);
    cout<<" }"<<endl;
    cout<<"The MidOrderStackTraversal:"<<endl<<"{ ";
    flag=true;
    MidOrderStack(t);
    cout<<" }"<<endl;
    cout<<"The LastOrderStackTraversal:"<<endl<<"{ ";
    flag=true;
    LastOrderStack(t);
    cout<<" }"<<endl;
    return ;
}

void CreatTree(tree *pre,tree *&t)//兄弟表示法建造树
{
    in[0]='n';
    TreeNodeSet(t);
    if(pre==NULL)
        cout<<"The tree's root:"<<endl,root=false;
    else
        cout<<"Father's Node:"<<pre->data<<endl;
    cout<<"Node's Data:";
    scanf("%s",t->data);
    if(pre!=NULL)
    {
        cout<<"Current Node:"<<t->data<<endl;
        cout<<"Have brother?[No or Yes]";
        scanf("%s",in);
    }
    if(in[0]=='y'||in[0]=='Y')
    {
        cout<<endl;
        CreatTree(t,t->rt);
    }
    cout<<"Current Node:"<<t->data<<endl;
    cout<<"Have child?[No or Yes]";
    scanf("%s",in);
    if(in[0]=='y'||in[0]=='Y')
    {
        cout<<endl;
        CreatTree(t,t->lt);
    }
    cout<<endl;
    return ;
}

void Tree_PreOrderDfs(tree *&t)//先序遍历普通树
{
    if(t==NULL)return ;
    flag?cout<<t->data:cout<<"　"<<t->data;
    flag=false;
    Tree_PreOrderDfs(t->lt);
    Tree_PreOrderDfs(t->rt);
    return ;
}

void Tree_LastOrderDfs(tree *&t)//后序遍历普通树
{
    if(t==NULL)return ;
    Tree_LastOrderDfs(t->lt);
    flag?cout<<t->data:cout<<"　"<<t->data;
    flag=false;
    Tree_LastOrderDfs(t->rt);
    return ;
}

void Tree(tree *&t)
{
    CreatTree(NULL,t);
    cout<<"\n";
    flag=true;
    cout<<"Tree's PreOrderIntraversal:";
    Tree_PreOrderDfs(t);
    cout<<endl;
    flag=true;
    cout<<"Tree's LastOrderIntraversal:";
    Tree_LastOrderDfs(t);
    cout<<endl;
    return ;
}

int main()
{
    string type;
    while(cout<<"tree's type[bstree or tree]:"&&cin>>type)
    {
        tree *bst,*t;
        switch(type[0])
        {
            case 'b':case 'B':
            {
                BsTree(bst);
                break;
            }
            case 't':case 'T':
            {
                Tree(t);
                break;
            }
        }
    }
    return 0;
}

　　

转载于:https://www.cnblogs.com/wyhbadly/p/10138580.html