c++实现二叉树的4种遍历（递归和非递归）

二叉树的遍历（traversing bianry tree）是指从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。

1）前序遍历：规则是若二叉树为空，则空操作返回，否则先访问根结点，然后前序遍历左子树，再前序遍历右子树----------------------递归思想

2）中序遍历：规则是若树为空，则空操作返回，否则从根结点开始（仅仅是开始，先不访问该结点），中序遍历根结点的左子树，然后是访问根结点（访问），最后中序遍历右子树--------------------递归思想

3）后序遍历：规则是若树为空，则空操作返回，否则从左到右先叶子后结点的方式遍历访问左右子树，最后是访问根结点。

4）层序遍历：规则是若树为空，则空操作返回，否则从树的第一层，也就是根结点开始访问，从上而下逐层遍历，在同一层中，按从左到右的顺序对结点逐个访问。

前序遍历的实现

using namespace std;

typedef struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
}BiTNode;

//前序遍历（递归）
void PreOrderTraverse(BiTNode *T)
{
    if(T == nullptr)
    {
        return;
    }
    //打印节点的值
    cout << T->val;
    //递归左子树
    PreOrderTraverse(T->left);
    //递归右子树
    PreOrderTraverse(T->right);
}

//前序遍历（非递归）
void PreOrderTraverse1(BiTNode *T)
{
    if(T == nullptr)
    {
        return;
    }

    //栈
    stack<BiTNode*> myStack;
    //指向根节点
    BiTNode* p = T;
    //p不为空或者栈不为空
    while(p!= nullptr || !myStack.empty())
    {
        if(p != nullptr)
        {
            //输入节点的值
            cout << p->val;
            //压栈
            myStack.push(p);
            //指向左子树的根节点
            p = p->left;
        }
        else
        {
            //出栈
            p = myStack.top();
            myStack.pop();
            //访问右子树
            p = p->right;
        }
    }
}

中序遍历的实现

//中序遍历（递归）
void InOrderTraverse(BiTNode *T)
{
    if(T == nullptr)
    {
        return;
    }
    //递归左子树
    InOrderTraverse(T->left);
    //打印节点的值
    cout << T->val;
    //递归右子树
    InOrderTraverse(T->right);
}

//中序遍历（非递归）
void InOrderTraverse1(BiTNode *T)
{
    if(T == nullptr)
    {
        return;
    }

    //栈
    stack<BiTNode*> myStack;
    //指向根节点
    BiTNode* p = T;
    //p不为空或者栈不为空
    while(p!= nullptr || !myStack.empty())
    {
        if(p != nullptr)
        {
            //压栈
            myStack.push(p);
            //指向左子树的根节点
            p = p->left;
        }
        else
        {
            //出栈
            p = myStack.top();
            myStack.pop();
            //输入节点的值
            cout << p->val;
            //访问右子树
            p = p->right;
        }
    }
}

后序遍历的实现

//后序遍历（递归）
void PostOrderTraverse(BiTNode *T)
{
    if(T == nullptr)
    {
        return;
    }
    //递归左子树
    PostOrderTraverse(T->left);
    //递归右子树
    PostOrderTraverse(T->right);
    //打印节点的值
    cout << T->val;
}
//后序遍历（非递归）

void PostOrderTraverse1(BiTNode *T)
{
    if(T==NULL)  
        return;  
    BiTNode* cur;       /*当前结点*/  
    BiTNode* pre = NULL;        /*前一次输出的结点*/  
    std::stack<BiTNode*> stk;  
    stk.push(T);  
    while(!stk.empty())  
    {  
        cur = stk.top();  
         /*如果当前结点没有孩子结点或者孩子节点都已被访问过*/ 
        if((cur->left == NULL && cur->right==NULL) ||  
            (pre!=NULL && (cur->left==pre || cur->right==pre)))      
        {                               
            cout<<cur->val;  
            stk.pop();  
            pre = cur;  
        }  
        else  
        {  
            if(cur->right!=NULL)  
                stk.push(cur->right);  
            if(cur->left!=NULL)  
                stk.push(cur->left);  
        }  
    } 
}

层次遍历

//层次遍历
void LevelTraversal(BiTNode *T)
{
    if(T == nullptr)
    {
        return;
    }
    
    TreeNode* pNode = nullptr;
    queue<TreeNode*> myQueue;
    myQueue.push(T);
    while (!myQueue.empty())
    {
        pNode = myQueue.front();
        cout << pNode->val;
        myQueue.pop();
        if(pNode->left != nullptr)
        {
            myQueue.push(pNode->left);
        }

        if(pNode->right != nullptr)
        {
            myQueue.push(pNode->right);
        }
    }
}