数据结构之二叉树

#include "stdio.h"
#include "stdlib.h"
#include <iostream>
#include <stack>
#include <queue>
using namespace std;

#define elemtype char

typedef struct binode{
    elemtype data;
    struct binode *lchild,*rchild;
    bool tag=false;
}binode,*bitree;

class hikaka_tree{
public:
    void visit(bitree T);                               //打印当前结点
    void bitree_createbycin(bitree *T);                 //输入数据创建二叉树
    void bitree_createbystr(bitree *T,elemtype *&str);  //通过数组创建二叉树
    void bitree_preorder_recursive(bitree T);           //前序递归遍历
    void bitree_inorder_recursive(bitree T);            //中序递归遍历
    void bitree_postorder_recursive(bitree T);          //后序递归遍历
    void bitree_preorder_non_recursive(bitree T);       //前序非递归遍历 
    void bitree_inorder_non_recursive(bitree T);        //中序非递归遍历
    void bitree_postorder_non_recursive(bitree T);      //后序非递归遍历
    void bitree_levelorder(bitree T);                   //层次遍历
    
};


void hikaka_tree::visit(bitree T)
{
    if(T!=nullptr)
        std::cout << T->data<<" ";
    else
        std::cout << "结点已空"<< std::endl;
}

//前序建立二叉树
void hikaka_tree::bitree_createbycin(bitree *T)
{
    char ch;
    cin>>ch;
    if(ch=='#')
    {
        *T=nullptr;
        return;
    }
    else
    {
        *T=new binode;
        (*T)->data=ch;
        bitree_createbycin(&(*T)->lchild);
        bitree_createbycin(&(*T)->rchild);
    }
}

//通过字符串前序建立二叉树
void hikaka_tree::bitree_createbystr(bitree *T,elemtype *&str)
{
    if(*str=='#')
    {
        *T=nullptr;
        return;
    }
    else
    {
        *T=new binode;
        (*T)->data=*str;
        cout<<"(*T)->data:"<<(*T)->data<<endl;

        bitree_createbystr(&(*T)->lchild,++str);
        bitree_createbystr(&(*T)->rchild,++str);

    }
}

//先序遍历
void hikaka_tree::bitree_preorder_recursive(bitree T)
{
    if(T!=nullptr)
    {
        visit(T);
        bitree_preorder_recursive(T->lchild);
        bitree_preorder_recursive(T->rchild);
    }
}

//中序遍历
void hikaka_tree::bitree_inorder_recursive(bitree T)
{
    if(T!=nullptr)
    {
        bitree_inorder_recursive(T->lchild);
        visit(T);
        bitree_inorder_recursive(T->rchild);
    }
}

//后序遍历
void hikaka_tree::bitree_postorder_recursive(bitree T)
{
    if(T!=nullptr)
    {
        bitree_postorder_recursive(T->lchild);
        bitree_postorder_recursive(T->rchild);
        visit(T);
    }
}

//前序非递归
void hikaka_tree::bitree_preorder_non_recursive(bitree T)
{
    stack<bitree> S;
    bitree p=T;
    while(p||!S.empty())
    {
        if(p)
        {
            S.push(p);
            visit(p);
            p=p->lchild;
        }
        else
        {
            p=S.top();
            S.pop();
            p=p->rchild;
        }
    }
}

//中序非递归
void hikaka_tree::bitree_inorder_non_recursive(bitree T)
{
    stack<bitree> S;
    bitree p=T,temp;
    while(p||!S.empty())
    {
        if(p)
        {
            S.push(p);
            p=p->lchild;
        }
        else
        {
            p=S.top();
            visit(p);
            S.pop();
            p=p->rchild;
        }
    }
}

//后序非递归遍历
void hikaka_tree::bitree_postorder_non_recursive(bitree T)
{
    stack<bitree> S;
    bitree p=T;
    while(p||!S.empty())
    {
        if(p)
        {
            S.push(p);
            p=p->lchild;
        }
        else
        {
            p=S.top();
            if(p->rchild && p->rchild->tag==false)
            {
                p=p->rchild;
                S.push(p);
                p=p->lchild;
            }
            else
            {
                visit(p);
                p->tag=true;
                p=nullptr;
                S.pop();                
            }
        }
    }

}      



//层次遍历
void hikaka_tree::bitree_levelorder(bitree T)
{
    queue<bitree> Q;
    bitree p;
    Q.push(T);
    while(!Q.empty())
    {
        p=Q.front();
        Q.pop();
        visit(p);
        if(p->lchild!=nullptr)
            Q.push(p->lchild);
        if(p->rchild!=nullptr)
            Q.push(p->rchild);        
    }

}

int main()
{
    hikaka_tree tree;
    bitree T;
    //abcd##e##f##
    // char *str=new char[100];
    // char str[12]={'a','b','c','d','#','#','e','#','#','f','#','#','#','#'};
    char *str="abcd##e##f####";
    cout<<"创建二叉树"<<endl;
   // tree.bitree_createbycin(&T);
    tree.bitree_createbystr(&T,str);
    cout<<"后序递归遍历"<<endl;
    tree.bitree_postorder_recursive(T);
    cout<<endl;
    cout<<"后序非递归遍历"<<endl;
    tree.bitree_postorder_non_recursive(T);
 //   tree.bitree_levelorder(T);
    return 0;
}