分别用递归和非递归方式实现二叉树先序、中序和后序遍历

【说明】：

　　本文是左程云老师所著的《程序员面试代码指南》第三章中“分别用递归和非递归方式实现二叉树先序、中序和后序遍历”这一题目的C++复现。

　　本文只包含问题描述、C++代码的实现以及简单的思路，不包含解析说明，具体的问题解析请参考原书。

　　感谢左程云老师的支持。

【题目】：

　　用递归和非递归的方式，分别按照二叉树先序、中序和后序打印所有的节点。我们约定：先序遍历顺序为根、左、右；中序遍历顺序为左、根、右；后序遍历顺序为左、右、根。

 【思路】：

　　解法：堆归的方式大家肯定都比较熟悉了。但是非递归的方式逻辑上还是蛮复杂的，从代码推敲推敲吧.........（去买本左老师的书也可以啊）^_^ ^_^ ^_^

【编译环境】：

　　CentOS6.7（x86_64）

　　gcc 4.4.7

 【实现及测试】：

　　声明代码：

/*
 *文件名：bt_traversing.h
 *作者：
 *摘要：分别用递归和非递归的方式实现二叉树的先序、中序和后序遍历
 */
 
#ifndef _BT_TRAVERSING
#define _BT_TRAVERSING
#include <iostream>
using namespace std;

class Node
{
public:
    Node(int data)
    {
        value = data;
        left = NULL;
        right = NULL;
    }
public:
    int value;
    Node *left;
    Node *right;
};

//递归版
void preOrderRecur(Node *head);
void inOrderRecur(Node *head);
void posOrderRecur(Node *head);

//非递归版
void preOrderUnRecur(Node *head);
void inOrderUnRecur(Node *head);
void posOrderUnRecur1(Node *head);
void posOrderUnRecur2(Node *head);

#endif

　　实现代码：

/*
 *文件名：bt_traversing.cpp
 *作者：
 *摘要：分别用递归和非递归的方式实现二叉树的先序、中序和后序遍历
 */
 
#include "bt_traversing.h"
#include <iostream>
#include <stack>

using namespace std;

void preOrderRecur(Node *head)
{
    if(NULL == head)
        return ;
    cout << head->value << " ";
    preOrderRecur(head->left);
    preOrderRecur(head->right);
}

void inOrderRecur(Node *head)
{
    if(NULL == head)
        return ;
    inOrderRecur(head->left);
    cout << head->value << " ";
    inOrderRecur(head->right);
}

void posOrderRecur(Node *head)
{
    if(NULL == head)
        return ;
    posOrderRecur(head->left);
    posOrderRecur(head->right);
    cout << head->value << " ";
}

void preOrderUnRecur(Node *head)
{
    if(NULL != head)
    {
        stack<Node*> s;
        s.push(head);
        while(!s.empty())
        {
            head = s.top();
            s.pop();
            cout << head->value << " ";
            if(NULL != head->right)
                s.push(head->right);
            if(NULL != head->left)
                s.push(head->left);
        }
    }
    cout << endl;
    return ;
}

void inOrderUnRecur(Node *head)
{
    if(NULL != head)
    {
        stack<Node*> s;
        while(!s.empty() || NULL != head)
        {
            if(NULL != head)
            {
                s.push(head);
                head = head->left;
            }
            else
            {
                head = s.top();
                s.pop();
                cout << head->value << " ";
                head = head->right;
            }
        }
    }
    cout << endl;
    return ;
}

void posOrderUnRecur1(Node *head)
{
    if(NULL != head)
    {
        stack<Node*> s1;
        stack<Node*> s2;
        s1.push(head);
        while(!s1.empty())
        {
            head = s1.top();
            s1.pop();
            s2.push(head);
            if(NULL != head->left)
                s1.push(head->left);
            if(NULL != head->right)
                s1.push(head->right);
        }
        while(!s2.empty())
        {
            cout << s2.top()->value << " ";
            s2.pop();
        }
    }
    cout << endl;
    return ;
}

void posOrderUnRecur2(Node *head)
{
    if(NULL != head)
    {
        stack<Node*> s;
        s.push(head);
        Node *cur = NULL;
        while(!s.empty())
        {
            cur = s.top();
            if(NULL != cur->left && head != cur->left && head != cur->right)
                s.push(cur->left);
            else if(NULL != cur->right && head != cur->right)
                s.push(cur->right);
            else
            {
                cout << s.top()->value << " ";
                s.pop();
                head = cur;
            }
        }
    }
    cout << endl;
    return ;    

}

　　测试代码：

/*
 *文件名：main.cpp
 *作者：
 *摘要：测试代码
 */

#include "bt_traversing.h"
#include <iostream>
using namespace std;

//由数组创建完全二叉树
void createBT(Node **head,int arr[],int len,int index=0)
{
    if(index > len-1)
        return;
    (*head) = new Node(arr[index]);
    createBT(&((*head)->left),arr,len,2*index+1);
    createBT(&((*head)->right),arr,len,2*index+2);
}

int main()
{
    int arr[] = {1,2,3,4,5,6,7,8,9};
    Node *head = NULL;
    createBT(&head,arr,9);

    cout << "Using recursive method to achieve pre-order traversal:" << endl;
    preOrderRecur(head);
    cout << endl;
    cout << "Using recursive method to achieve in-order traversal:" << endl;
    inOrderRecur(head);
    cout << endl;
    cout << "Using recursive method to achieve pos-order traversal:" << endl;
    posOrderRecur(head);
    cout << endl;
    
    cout << "Without using recursive way to achieve the pre-order traversal:"<< endl;
    preOrderUnRecur(head);
    cout << "Without using recursive way to achieve the in-order traversal:"<< endl;
    inOrderUnRecur(head);
    cout << "The first method achieve the pos-order traversal without using recursive:"<< endl;
    posOrderUnRecur1(head);
    cout << "The second method achieve the pos-order traversal without using recursive:"<< endl;
    posOrderUnRecur2(head);
    return 0;
}

注：

　　转载请注明出处；

　　转载请注明源思路来自于左程云老师的《程序员代码面试指南》。