二叉树

binaryTree.h

#ifndef BINARYTREE_H
#define BINARYTREE_H

#include<iostream>
using namespace std;

#include<cstdlib>
#include<stack>
#include<queue>

enum Status{ERROR,OK};//定义状态枚举时还得注意实际的值，不能搞错了

template<class T>
Status PrintElement(T e)
{
    cout<<e<<" ";
    return OK;
}

template<class T>
class BiNode//树节点
{
public:
    BiNode();
    T data;
    BiNode *left;
    BiNode *right;
};

template<class T>
BiNode<T>::BiNode()
{
    data = (T)0;
    left = NULL;
    right = NULL;//有时候你初始化指针值为NULL,你也没有在后面的语句中刻意去改变该指针值，但指针的值还是可能因为传递到函数作为参数而发生改变，因此如果你要再重新用指针的NULL值，最好在用之前显示地再重新赋值一下才行
}

template<class T>
class BiTree
{
public:
    BiTree();
    Status CreateBiTree(BiNode<T> *&root);
    Status PreOrderTraverse(BiNode<T> *r,Status (*visit)(T element));//前序遍历，递归方法
    Status NPreOrderTraverse(BiNode<T> *r,Status (*visit)(T element));//前序遍历，非递归方法
    Status InOrderTraverse(BiNode<T> *r,Status (*visit)(T element));//中序遍历，递归方法
    Status NInOrderTraverse(BiNode<T> *r,Status (*visit)(T element));//中序遍历，非递归方法
    Status PostOrderTraverse(BiNode<T> *r,Status (*visit)(T element));//后序遍历，递归方法
    Status NPostOrderTraverse(BiNode<T> *r,Status (*visit)(T element));//后序遍历，非递归方法
    Status LevelTraverse(BiNode<T> *r,Status (*visit)(T element));//层次遍历
    Status BiTraverse();
    ~BiTree();

private:
    BiNode<T> *root;//树根节点
};

template<class T>
BiTree<T>::BiTree()
{
    CreateBiTree(root);
}

template<class T>
Status BiTree<T>::CreateBiTree(BiNode<T> *&r)//这里即使是指针也得加&符号，这样才能真正修改root，不然修改不了（还认为是值传递）
{
    r = NULL;
    T ch;
    cin>>ch;
    if(ch != (T)0)
    {
        r = new BiNode<T>();
        if(r != NULL)
        {
            r->data = ch;
            CreateBiTree(r->left);
            CreateBiTree(r->right);
        }
    }
    else
    {
        r = NULL;
        //r = new BiNode<T>();
        //r->data = (T)0;//这里的左右孩子不存在的节点我们规定其data值为0，方便后面遍历时进行判断，不为0则输出并继续递归，为0则直接返回
    }
    return OK;
}

template<class T>
Status BiTree<T>::PreOrderTraverse(BiNode<T> *r,Status (*visit)(T element))//前序遍历递归方法
{
    if(r != NULL)
    {
        if((*visit)(r->data))
        {
            if(PreOrderTraverse(r->left,visit))
            {
                if(PreOrderTraverse(r->right,visit))
                {
                    return OK;
                }
            }
        }
        return ERROR;
    }
    else
    {
        return OK;
    }
}

template<class T>
Status BiTree<T>::NPreOrderTraverse(BiNode<T> *r,Status (*visit)(T element))//前序遍历非递归方法(栈)
{
    stack<BiNode<T> *>s;
    BiNode<T> *temp = r;

    while(true)
    {
        while(temp != NULL)
        {
            if(temp->right != NULL)
            {
                s.push(temp->right);
            }
            visit(temp->data);
            temp = temp->left;
        }
        if(!s.empty())
        {
            temp = s.top();
            s.pop();
        }
        else
        {
            break;
        }
    }
    return OK;
}

template<class T>
Status BiTree<T>::InOrderTraverse(BiNode<T> *r,Status (*visit)(T element))//中序遍历，递归方法
{
    if(r != NULL)
    {
        if(InOrderTraverse(r->left,visit))
        {
            if((*visit)(r->data))
            {
                if(InOrderTraverse(r->right,visit))
                {
                    return OK;
                }
            }
        }
        return ERROR;
    }
    else
    {
        return OK;
    }

    return OK;
}

template<class T>
Status BiTree<T>::NInOrderTraverse(BiNode<T> *r,Status (*visit)(T element))//中序遍历，非递归方法(栈)
{
    stack<BiNode<T> *> s;
    BiNode<T> *temp;
    s.push(r);
    while(!s.empty())
    {
        while((temp = (BiNode<T> *)s.top()) && temp != NULL)
        {
            s.push(temp->left);
        }
        s.pop();
        if(!s.empty())
        {
            temp = s.top();
            visit(temp->data);
            s.pop();
            s.push(temp->right);
        }
    }

    return OK;
}

template<class T>
Status BiTree<T>::PostOrderTraverse(BiNode<T> *r,Status (*visit)(T element))//后序遍历递归算法
{
    if(r != NULL)
    {
        if(PostOrderTraverse(r->left,visit))
        {
            if(PostOrderTraverse(r->right,visit))
            {
                if((*visit)(r->data))
                {
                    return OK;
                }
            }
        }
        return ERROR;
    }
    else
    {
        return OK;
    }

    return OK;
}

template<class T>
Status BiTree<T>::NPostOrderTraverse(BiNode<T> *r,Status (*visit)(T element))//后序遍历非递归算法(栈)
{
    stack<BiNode<T> *> s;
    BiNode<T> *temp = r;//这里要赋初值不能忘了
    s.push(temp);
    while(!s.empty())//任何时候都必须要判定是否为空
    {
        while((temp = s.top())&&temp)
        {
            s.push(temp->left);
        }
        s.pop();
        if(!s.empty())
        {
            while(temp == (s.top())->right || (temp == (s.top())->left) && ((s.top())->right == NULL))
            {
                temp = s.top();
                visit(temp->data);
                s.pop();
                if(s.empty())//这里是条件一定要判断准确了，是empty()而不是!empty()
                {
                    break;
                }
            }
            if(!s.empty())
            {
                temp = s.top();
                s.push(temp->right);
            }
        }
        else
        {
            break;
        }
    }

    return OK;
}

template<class T>
Status BiTree<T>::LevelTraverse(BiNode<T> *r,Status (*visit)(T element))
{
    queue<BiNode<T> *> qu;
    BiNode<T> *temp;
    if(!r)
    {
        qu.push(r);
        while(!qu.empty())
        {
            temp = qu.front();
            visit(temp->data);
            if(temp->left)
            {
                qu.push(temp->left);
            }
            if(temp->right)
            {
                qu.push(temp->right);
            }
            qu.pop();
        }
    }

    return OK;
}

template<class T>
Status BiTree<T>::BiTraverse()
{
    cout<<"Recursive traverse:"<<endl;

    cout<<"preorder traverse :"<<endl;
    PreOrderTraverse(root,PrintElement);

    cout<<endl<<"inorder traverse :"<<endl;
    InOrderTraverse(root,PrintElement);

    cout<<endl<<"postorder traverse :"<<endl;
    PostOrderTraverse(root,PrintElement);

    cout<<endl<<"Non-recursive traverse:"<<endl;

    cout<<endl<<"NPreorder traverse:"<<endl;
    NPreOrderTraverse(root,PrintElement);
    
    cout<<endl<<"NInorder treaverse:"<<endl;
    NInOrderTraverse(root,PrintElement);

    cout<<endl<<"NPostorder traverse:"<<endl;
    NPostOrderTraverse(root,PrintElement);
    
    cout<<endl<<"Level traverse:"<<endl;
    LevelTraverse(root,PrintElement);

    return OK;
}

template<class T>
BiTree<T>::~BiTree()//最后在析构函数里使用中序非递归遍历算法进行树节点遍历进而释放内存空间
{
    stack<BiNode<T> *> s;
    BiNode<T> *temp;
    s.push(r);
    while(!s.empty())
    {
        while((temp = (BiNode<T> *)s.top()) && temp != NULL)
        {
            s.push(temp->left);
        }
        s.pop();
        if(!s.empty())
        {
            temp = s.top();
            delete temp;
            s.pop();
            s.push(temp->right);
        }
    }
}

#endif

main.cpp

#include<iostream>

using namespace std;
#include<stdlib.h>
#include"binaryTree.h"

int main()
{
    cout<<"please input a series number to create a binarytree :"<<endl;
    BiTree<int> *t1 = new BiTree<int>();//new永远是返回指针

    t1->BiTraverse();


    system("pause");
    return 0;
}