Tree(3)--二叉树的实现及四种遍历（递归/非递归）

最新推荐文章于 2021-01-23 19:32:44 发布

Nicholem

最新推荐文章于 2021-01-23 19:32:44 发布

阅读量1.7k

点赞数 1

分类专栏： Data Structure 文章标签：二叉树递归遍历

本文链接：https://blog.csdn.net/Nicholem/article/details/73412021

版权

Data Structure 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1.二叉树的实现

按前序遍历进行输入，#表示空树

struct node{
    char data;
    struct node *left, *right;
};

class tree{
public:
    tree();
    ~tree();
    node *getRoot(){return root;}

    int Depth(node *);

    void PreOrder(node * );
    void InOrder(node *);
    void PostOrder(node *);
    void LayerTravel(node *);
    void PrintLevel(node *, int);

    void NonrePreOrder(node *);
    void NonreInOrder(node *);
    void NonrePostOrder(node *);
    void NonreLayerTravel(node *);

private:
    node* root;
    node* creat();
};

构造函数

tree::tree(){
    this->root = creat();
}

creat()方法

node* tree::creat(){
    node* root;
    char ch;
    cout<<"Input:"<<endl;
    cin>>ch;
    if(ch == '#')root = NULL;
    else{
        root = new node;
        root->data = ch;
        root->left = creat();
        root ->right = creat();
    }
    return root;
}

2.二叉树的遍历

1.递归前序遍历

void tree::PreOrder(node* root){
     if(root!=NULL){
        cout<<root->data<<" ";
        PreOrder(root->left);
        PreOrder(root->right);
     }
}

2.递归中序遍历

void tree::InOrder(node* root){
     if(root!=NULL){
        InOrder(root->left);
        cout<<root->data<<" ";
        InOrder(root->right);
     }
}

3.递归后序遍历

void tree::PostOrder(node* root){
     if(root!=NULL){
        PostOrder(root->left);
        PostOrder(root->right);
        cout<<root->data<<" ";
     }
}

4.递归层次遍历

递归求树的高度

int tree::Depth(node *root){
    if(root==NULL)return 0;
    return 1 + max(Depth(root->left),Depth(root->right));
}

void tree::LayerTravel(node* root){
     if(root!=NULL){
        int depth = Depth(root);
        int i;
        for(i=1;i<=depth;i++){
         PrintLevel(root,i);
         cout<<endl;
        }
     }
}

void tree::PrintLevel(node* root,int level){
    if(root == NULL || level < 1) return;
    if(1==level){
        cout<<root->data<<" ";
        return;
    }
    PrintLevel(root->left,level-1);
    PrintLevel(root->right,level-1);
}

5.非递归前序遍历

void tree::NonrePreOrder(node* root){
    stack<node*> s;
    node* p = root;
    do{
        while(p){
            cout<<p->data<<" ";
            s.push(p);
            p = p->left;
        }
        if(!s.empty()){
            p = s.top();
            s.pop();
            p = p->right;
        }
    }while(p||!s.empty());
}

6.非递归中序遍历

void tree::NonreInOrder(node* root){
    stack<node*> s;
    node* p = root;
    do{
        while(p){s.push(p); p = p->left;}
        if(!s.empty()){
            p=s.top();
            s.pop();
            cout<<p->data<<" ";
            p = p->right;
        }
    }while(p||!s.empty());
}

7.非递归后序遍历

这里写图片描述

void tree::NonrePostOrder(node* root){
   if (root == NULL) return;
    stack<node*> s;
    s.push(root);
    node* head = root;
    while (!s.empty()){
        node* t = s.top();
        if (!t->left&&!t->right || t->left == head || t->right == head){
            cout<<t->data<<" ";
            s.pop();
            head = t;
        }
        else{
            if (t->right)s.push(t->right);
            if (t->left)s.push(t->left);
        }

    }
}

8.非递归层次遍历

void tree::NonreLayerTravel(node* root){

    if (root == NULL)return;
    queue<node*> q;
    q.push(root);
    while (!q.empty()){
        //计算当前队列中含有多少元素
        int size = q.size();
        //从头部依次取出size个元素
        for (int i = 0; i < size; i++){
            root = q.front();
            q.pop();
            cout<<root->data<<" ";
            //将下一层的元素塞入队列
            if (root->left)q.push(root->left);
            if (root->right)q.push(root->right);
        }
    }
}

3.完整代码

头文件a.h

#ifndef A_H_INCLUDED
#define A_H_INCLUDED
#include <iostream>
#include <stack>
#include <queue>
using namespace std;
/
struct node{
    char data;
    struct node *left, *right;
};

class tree{
public:
    tree();
    ~tree();
    node *getRoot(){return root;}

    int Depth(node *);

    void PreOrder(node * );
    void InOrder(node *);
    void PostOrder(node *);
    void LayerTravel(node *);
    void PrintLevel(node *, int);

    void NonrePreOrder(node *);
    void NonreInOrder(node *);
    void NonrePostOrder(node *);
    void NonreLayerTravel(node *);

private:
    node* root;
    node* creat();
};

tree::tree(){
    this->root = creat();
}


node* tree::creat(){
    node* root;
    char ch;
    cout<<"Input:"<<endl;
    cin>>ch;
    if(ch == '#')root = NULL;
    else{
        root = new node;
        root->data = ch;
        root->left = creat();
        root ->right = creat();
    }
    return root;
}
int tree::Depth(node *root){
    if(root==NULL)return 0;
    return 1 + max(Depth(root->left),Depth(root->right));
}

void tree::PreOrder(node* root){
     if(root!=NULL){
        cout<<root->data<<" ";
        PreOrder(root->left);
        PreOrder(root->right);
     }
}

void tree::InOrder(node* root){
     if(root!=NULL){
        InOrder(root->left);
        cout<<root->data<<" ";
        InOrder(root->right);
     }
}

void tree::PostOrder(node* root){
     if(root!=NULL){
        PostOrder(root->left);
        PostOrder(root->right);
        cout<<root->data<<" ";
     }
}

void tree::LayerTravel(node* root){
     if(root!=NULL){
        int depth = Depth(root);
        int i;
        for(i=1;i<=depth;i++){
         PrintLevel(root,i);
         cout<<endl;
        }
     }
}

void tree::PrintLevel(node* root,int level){
    if(root == NULL || level < 1) return;
    if(1==level){
        cout<<root->data<<" ";
        return;
    }
    PrintLevel(root->left,level-1);
    PrintLevel(root->right,level-1);

}


void tree::NonrePreOrder(node* root){
    stack<node*> s;
    node* p = root;
    do{
        while(p){
            cout<<p->data<<" ";
            s.push(p);
            p = p->left;
        }
        if(!s.empty()){
            p = s.top();
            s.pop();
            p = p->right;
        }
    }while(p||!s.empty());
}

void tree::NonreInOrder(node* root){
    stack<node*> s;
    node* p = root;
    do{
        while(p){s.push(p); p = p->left;}
        if(!s.empty()){
            p=s.top();
            s.pop();
            cout<<p->data<<" ";
            p = p->right;
        }
    }while(p||!s.empty());
}

void tree::NonrePostOrder(node* root){
   if (root == NULL) return;
    stack<node*> s;
    s.push(root);
    node* head = root;
    while (!s.empty()){
        node* t = s.top();
        if (!t->left&&!t->right || t->left == head || t->right == head){
            cout<<t->data<<" ";
            s.pop();
            head = t;
        }
        else{
            if (t->right)s.push(t->right);
            if (t->left)s.push(t->left);
        }

    }
}

void tree::NonreLayerTravel(node* root){

    if (root == NULL)return;
    queue<node*> q;
    q.push(root);
    while (!q.empty()){
        //计算当前队列中含有多少元素
        int size = q.size();
        //从头部依次取出size个元素
        for (int i = 0; i < size; i++){
            root = q.front();
            q.pop();
            cout<<root->data<<" ";
            //将下一层的元素塞入队列
            if (root->left)q.push(root->left);
            if (root->right)q.push(root->right);
        }
    }
}
/
#endif // A_H_INCLUDED

测试代码main.cpp

#include "a.h"
#include <iostream>
using namespace std;
int main(){

    tree *mytree = new tree();
    cout<<"Creat sucessfully!!"<<endl;
    node* myroot = mytree->getRoot();
    cout<<"-------------------------------------"<<endl;
    cout<<"The depth is:"<<mytree->Depth(myroot)<<endl;
    cout<<"-------------------------------------"<<endl;
    cout<<"Recursive Traversal"<<endl;
    cout<<" Preorder Traversal:  ";
    mytree->PreOrder(myroot);
    cout<<endl;
    cout<<"  Inorder Traversal:  ";
    mytree->InOrder(myroot);
    cout<<endl;
    cout<<"Postorder Traversal:  ";
    mytree->PostOrder(myroot);
    cout<<endl;
    cout<<"    Layer Traversal:  ";
    cout<<endl;
    mytree->LayerTravel(myroot);
    cout<<endl;
    cout<<"-------------------------------------"<<endl;
    cout<<"Nonrecursive Traversal"<<endl;
    cout<<" Preorder Traversal:  ";
    mytree->NonrePreOrder(myroot);
    cout<<endl;
    cout<<"  Inorder Traversal:  ";
    mytree->NonreInOrder(myroot);
    cout<<endl;
    cout<<"Postorder Traversal:  ";
    mytree->NonrePostOrder(myroot);
    cout<<endl;
    cout<<"    Layer Traversal:  ";
    mytree->NonreLayerTravel(myroot);
    cout<<endl;
    cout<<"-------------------------------------"<<endl;
    return 0;
};