二叉树的遍历--递归+非递归(两种)

二叉树的非递归遍历

二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用非递归的方法，就要采用栈去模拟实现。在三种遍历中，前序和中序遍历的非递归算法都很容易实现，非递归后序遍历实现起来相对来说要难一点。

一.前序遍历

前序遍历按照“根结点-左孩子-右孩子”的顺序进行访问。

1.递归实现

void preOrder1(BinTree *root)     //递归前序遍历 
{
    if(root!=NULL)
    {
        cout<<root->data<<" ";
        preOrder1(root->lchild);
        preOrder1(root->rchild);
    }
}

2.非递归实现

根据前序遍历访问的顺序，优先访问根结点，然后再分别访问左孩子和右孩子。即对于任一结点，其可看做是根结点，因此可以直接访问，访问完之后，若其左孩子不为空，按相同规则访问它的左子树；当访问其左子树时，再访问它的右子树。因此其处理过程如下：

对于任一结点P：

1)访问结点P，并将结点P入栈;

2)判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);若不为空，则将P的左孩子置为当前的结点P;

3)直到P为NULL并且栈为空，则遍历结束。

void preOrder2(BinTree *root)     //非递归前序遍历 
{
    stack<BinTree*> s;
    BinTree *p=root;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)
        {
            cout<<p->data<<" ";
            s.push(p);
            p=p->lchild;
        }
        if(!s.empty())
        {
            p=s.top();
            s.pop();
            p=p->rchild;
        }
    }
}

- 另一种实现

class Solution {
public:
vector<int> preorderTraversal(TreeNode *root) {
    if (root==NULL) {
        return vector<int>();
    }
    vector<int> result;
    stack<TreeNode *> treeStack;
    treeStack.push(root);
    while (!treeStack.empty()) {
        TreeNode *temp = treeStack.top();
        result.push_back(temp->val);
        treeStack.pop();
        if (temp->right!=NULL) {  //或者先压右孩子，再压左孩子
            treeStack.push(temp->right);
        }
        if (temp->left!=NULL) {
            treeStack.push(temp->left);
        }
    }
    return result;
}
};

二.中序遍历

中序遍历按照“左孩子-根结点-右孩子”的顺序进行访问。

1.递归实现

void inOrder1(BinTree *root)      //递归中序遍历
{
    if(root!=NULL)
    {
        inOrder1(root->lchild);
        cout<<root->data<<" ";
        inOrder1(root->rchild);
    }
}

2.非递归实现

根据中序遍历的顺序，对于任一结点，优先访问其左孩子，而左孩子结点又可以看做一根结点，然后继续访问其左孩子结点，直到遇到左孩子结点为空的结点才进行访问，然后按相同的规则访问其右子树。因此其处理过程如下：

对于任一结点P，

1)若其左孩子不为空，则将P入栈并将P的左孩子置为当前的P，然后对当前结点P再进行相同的处理；

2)若其左孩子为空，则取栈顶元素并进行出栈操作，访问该栈顶结点，然后将当前的P置为栈顶结点的右孩子；

3)直到P为NULL并且栈为空则遍历结束

void inOrder2(BinTree *root)      //非递归中序遍历
{
    stack<BinTree*> s;
    BinTree *p=root;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)
        {
            s.push(p);
            p=p->lchild;
        }
        if(!s.empty())
        {
            p=s.top();
            cout<<p->data<<" ";
            s.pop();
            p=p->rchild;
        }
    }    
}

Morris Traversal方法遍历二叉树（非递归，不用栈，O(1)空间）

三.后序遍历

后序遍历按照“左孩子-右孩子-根结点”的顺序进行访问。

1.递归实现

void postOrder1(BinTree *root)    //递归后序遍历
{
    if(root!=NULL)
    {
        postOrder1(root->lchild);
        postOrder1(root->rchild);
        cout<<root->data<<" ";
    }    
}

2.非递归实现

后序遍历的非递归实现是三种遍历方式中最难的一种。因为在后序遍历中，要保证左孩子和右孩子都已被访问并且左孩子在右孩子前访问才能访问根结点，这就为流程的控制带来了难题。下面介绍两种思路。

第一种思路：对于任一结点P，将其入栈，然后沿其左子树一直往下搜索，直到搜索到没有左孩子的结点，此时该结点出现在栈顶，但是此时不能将其出栈并访问，因此其右孩子还为被访问。所以接下来按照相同的规则对其右子树进行相同的处理，当访问完其右孩子时，该结点又出现在栈顶，此时可以将其出栈并访问。这样就保证了正确的访问顺序。可以看出，在这个过程中，每个结点都两次出现在栈顶，只有在第二次出现在栈顶时，才能访问它。因此需要多设置一个变量标识该结点是否是第一次出现在栈顶。

void postOrder2(BinTree *root)    //非递归后序遍历
{
    stack<BTNode*> s;
    BinTree *p=root;
    BTNode *temp;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)              //沿左子树一直往下搜索，直至出现没有左子树的结点 
        {
            BTNode *btn=(BTNode *)malloc(sizeof(BTNode));
            btn->btnode=p;
            btn->isFirst=true;
            s.push(btn);
            p=p->lchild;
        }
        if(!s.empty())
        {
            temp=s.top();
            s.pop();
            if(temp->isFirst==true)     //表示是第一次出现在栈顶 
             {
                temp->isFirst=false;
                s.push(temp);
                p=temp->btnode->rchild;    
            }
            else                        //第二次出现在栈顶 
             {
                cout<<temp->btnode->data<<" ";
                p=NULL;
            }
        }
    }    
}

//postorder traversal
//* 核心思想是用栈做辅助空间，先从根往左一直入栈，直到为空，然后判断栈顶元素的右孩子，如果不为空且未被访问过，
//* 则从它开始重复左孩子入栈的过程；否则说明此时栈顶为要访问的节点（因为左右孩子都是要么为空要么已访问过了），
//* 出栈然后访问即可，接下来再判断栈顶元素的右孩子...直到栈空。

vector<int> postorderTraversal(TreeNode* root) {
    vector<int> nodes;
    stack<TreeNode*> toVisit;
    TreeNode* curNode = root;
    TreeNode* lastNode = NULL;
    while (curNode || !toVisit.empty()) {
        if (curNode) { //一直压左孩子
            toVisit.push(curNode);
            curNode = curNode -> left;
        }
        else {
            TreeNode* topNode = toVisit.top();
            if (topNode -> right && lastNode != topNode -> right) //右孩子非空且未被访问过
                curNode = topNode -> right;
            else {
                nodes.push_back(topNode -> val);
                lastNode = topNode;
                toVisit.pop();
            }
        }
    }
    return nodes;
}

第二种思路：要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。

void postOrder3(BinTree *root)     //非递归后序遍历
{
    stack<BinTree*> s;
    BinTree *cur;                      //当前结点 
    BinTree *pre=NULL;                 //前一次访问的结点 
    s.push(root);
    while(!s.empty())
    {
        cur=s.top();
        if((cur->lchild==NULL&&cur->rchild==NULL)||
           (pre!=NULL&&(pre==cur->lchild||pre==cur->rchild)))
        {
            cout<<cur->data<<" ";  //如果当前结点没有孩子结点或者孩子节点都已被访问过 
              s.pop();
            pre=cur; 
        }
        else
        {
            if(cur->rchild!=NULL)
                s.push(cur->rchild);
            if(cur->lchild!=NULL)    
                s.push(cur->lchild);
        }
    }    
}

四.整个程序完整的代码

/*!
* \file 二叉树的遍历.cpp
*
* \author ranjiewen
* \date 2017/03/26 18:38
*
*
*/

#include <stdio.h>
#include <stdlib.h>

typedef struct TNode *position;
typedef position BinTree;
typedef int ElementType;

typedef struct TNode
{
    ElementType Data;
    BinTree Left;
    BinTree Right;
}BinTreeNode;

typedef struct Node 
{
    BinTree bin;
    bool isfirst;
}BTNode;
//先序、中序和后序遍历过程：遍历过程中经过结点的路线一样，只是访问各结点的时机不同;同一节点有三次遇到的机会，三种遍历对应三个时机访问节点

#include <iostream>
#include <stack>
using namespace std;

//先序遍历
void PreOrderTraversal(BinTree BT)
{
    if (BT)
    {
        printf("%5d", BT->Data);
        PreOrderTraversal(BT->Left);
        PreOrderTraversal(BT->Right);
    }
    return;
}

//先序非递归实现
void PreOrderTraversal_(BinTree BT)
{
    BinTree T = BT;
    stack<BinTree> s; //创建并初始化堆栈
    while (T || !s.empty()) //树不为空或者栈不为空，继续循环
    {
        while (T) //一直向左并将沿途节点压入堆栈中
        {
            s.push(T);
            printf("%5d", T->Data);//第一次遇见节点的时候访问
            T = T->Left;
        }
        if (!s.empty())
        {
            T = s.top(); //先记录，在出栈
            //printf("%d", T->Data);
            s.pop();
            T = T->Right; //转向右子树
        }
    }
    return;
}

//中序遍历
void InOrderTraversal(BinTree BT)
{
    if (BT)
    {
        InOrderTraversal(BT->Left);
        printf("%5d", BT->Data);
        InOrderTraversal(BT->Right);
    }
    return;
}

//中序非递归实现
void InOrderTraversal_(BinTree BT)
{
    BinTree T = BT;
    stack<BinTree> s; //创建并初始化堆栈
    while (T || !s.empty()) //树不为空或者栈不为空，继续循环
    {
        while (T) //一直向左并将沿途节点压入堆栈中
        {
            s.push(T);
            T = T->Left;
        }
        if (!s.empty())
        {
            T = s.top(); //先记录，在出栈
            printf("%5d", T->Data);  //第二次遇见节点的时候访问 //第三次呢？？？
            s.pop();
            T = T->Right; //转向右子树
        }
    }
    return;
}


//后序遍历
void PostOrderTraversal(BinTree BT)
{
    if (BT)
    {
        PostOrderTraversal(BT->Left);
        PostOrderTraversal(BT->Right);
        printf("%5d", BT->Data);
    }
    return;
}

//后序遍历的非递归实现
//每个结点都两次出现在栈顶，只有在第二次出现在栈顶时，才能访问它

void PostOrderTraversal_1(BinTree BT)
{
    stack<BTNode*> S;
    BinTree p = BT;
    BTNode *temp;
    while (p!=NULL||!S.empty())
    {
        while (p!=NULL) //沿左子树一直往下搜索，直至出现没有左子树的节点
        {
            BTNode* btn = (BTNode*)malloc(sizeof(BTNode)); //把每经过的节点都标记一遍 //感觉有点浪费空间
            btn->bin = p;
            btn->isfirst = true;
            S.push(btn);       
            p = p->Left;
        }
        if (!S.empty())
        {
            temp = S.top();
            S.pop();
            if (temp->isfirst == true) //第一次在栈顶位置
            {
                temp->isfirst = false;
                S.push(temp);
                p = temp->bin->Right; //不出栈，对其右子树进行相同的操作
            }
            else
            {
                printf("%5d", temp->bin->Data);  //第二次出现在栈顶；出栈
                p = NULL;
            }
        }
    }
}

//要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，
//则可以直接访问它；或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。
//若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，
//左孩子和右孩子都在根结点前面被访问。

void PostOrderTraversal_2(BinTree BT)
{
    stack<BinTree> S;
    BinTree cur;
    BinTree pre = NULL; 
    S.push(BT);
    while (!S.empty())
    {
        cur = S.top();
        if ((cur->Left == NULL&&cur->Right == NULL) || (pre != NULL && (pre == cur->Left||pre==cur->Right)))
        {
            printf("%5d", cur->Data); //如果当前结点没有孩子结点或者孩子节点都已被访问过 
            S.pop();
            pre = cur;
        }
        else
        {
            if (cur->Right != NULL) //将P的右孩子和左孩子依次入栈
            {
                S.push(cur->Right);
            }
            if (cur->Left!=NULL)
            {
                S.push(cur->Left);
            }
        }
    }
}

#include <queue>
//层次遍历

//二叉树遍历的核心问题： 二维结构的线性化
// 从结点访问其左、右儿子结点
// 访问左儿子后，右儿子结点怎么办？
// 需要一个存储结构保存暂时不访问的结点
// 存储结构：堆栈、队列  (用堆实现就是存储其父节点)

//队列实现： 遍历从根结点开始，首先将根结点入队，然后开始执行循环：结点出队、访问该结点、其左右儿子入队

//层序基本过程：先根结点入队，然后
//     从队列中取出一个元素；
//       访问该元素所指结点；
//       若该元素所指结点的左、右孩子结点非空，则将其左、右孩子的指针顺序入队。

void LevelOrderTraversal(BinTree BT)  //层次输出叶子节点可借助此思路
{
    queue<BinTree> Q;
    BinTree T;
    if (!BT)
    {
        return;
    }
    Q.push(BT);
    while (!Q.empty())
    {
        T = Q.front();
        Q.pop();
        printf("%5d", T->Data);
        if (T->Left)
        {
            Q.push(T->Left);
        }
        if (T->Right)
        {
            Q.push(T->Right);
        }
    }
}

//遍历二叉树的应用
//输出二叉树中的叶子节点,前中后序遍历改编都可以
void PreOrderPrintLeaves(BinTree BT)
{
    if (BT)
    {
        if (!BT->Left&&!BT->Right)
        {
            printf("%5d", BT->Data);
        }
        PreOrderPrintLeaves(BT->Left);
        PreOrderPrintLeaves(BT->Right);
    }
}

//二叉树的高度，要知道左右子树高度才行，所以有后序遍历方法
int PostOrderGetHeight(BinTree BT)
{
    int LH, RH, MaxH;
    if (BT)
    {
        LH = PostOrderGetHeight(BT->Left);
        RH = PostOrderGetHeight(BT->Right);
        MaxH = (LH > RH) ? LH + 1 : RH + 1;
        return MaxH;
    }
    else
    {
        return 0;
    }
}

//二元运算表达式树及其遍历
//中缀表达式会受到运算优先级的影响；要正确得到：需要遍历操作符前后加上括号

//有中序遍历的两种遍历序列才能确定一个二叉树

//先序和中序遍历序列来确定一棵二叉树
//〖 分析〗
// 根据先序遍历序列第一个结点确定根结点；
// 根据根结点在中序遍历序列中分割出左右两个子序列
// 对左子树和右子树分别递归使用相同的方法继续分解

void CreateBinTree(char* s, BinTree& root)
{
    int i;
    bool isRight = false;
    stack<BinTree> s1; //存放节点
    stack<char> s2;  //存放分隔符
    BinTree p, temp;
    root->Data = s[0];
    root->Left = NULL;
    root->Right = NULL;
    s1.push(root);
    i = 1;
    while (i<strlen(s))
    {
        if (s[i]=='(')
        {
            s2.push(s[i]);
            isRight = false;
        }
        else if (s[i]==',')
        {
            isRight = true;
        }else if (s[i]==')')
        {
            s1.pop();
            s2.pop();
        }
        else if (isalpha(s[i]))
        {
            p = (BinTree)malloc(sizeof(struct TNode));
            p->Data = s[i];
            p->Left = p->Right = NULL;
            temp = s1.top();
            if (isRight==true)
            {
                temp->Right = p;
                printf("%c的右孩子是%c\n", temp->Data, s[i]);
            }
            else
            {
                temp->Left = p;
                printf("%c的左孩子是%c\n", temp->Data, s[i]);
            }
            if (s[i+1]=='(')
            {
                s1.push(p);
            }
        }
        i++;
    }
}

void display(BinTree root)        //显示树形结构 
{
    if (root != NULL)
    {
        cout << root->Data;
        if (root->Left != NULL)
        {
            cout << '(';
            display(root->Left);
        }
        if (root->Right != NULL)
        {
            cout << ',';
            display(root->Right);
            cout << ')';
        }
    }
}


int main()
{
    char s[100];
    while (scanf("%s",s)==1)
    {
        BinTree root = (BinTree)malloc(sizeof(BinTreeNode));
        CreateBinTree(s,root);
        display(root);

        cout << endl;
        PreOrderTraversal(root);
        cout << endl;
        PreOrderTraversal_(root);
        cout << endl;
        InOrderTraversal(root);
        cout << endl;
        InOrderTraversal_(root);
        cout << endl;
        PostOrderTraversal(root);
        cout << endl;
        PostOrderTraversal_1(root);
        cout << endl;
        PostOrderTraversal_2(root);
        cout << endl;
        LevelOrderTraversal(root);
        cout << endl;
    }
    return 0;
}

测试结果：

另外感觉C/C++分类也总结了很多东西：http://www.cnblogs.com/dolphin0520/category/291771.html

posted @ 2016-03-04 17:16 ranjiewen 阅读(1311) 评论(0) 编辑收藏举报

刷新页面返回顶部

小河沟大河沟

----------- 梦想还是要有的，万一实现了呢！纸上得来终觉浅绝知此事要躬行！

二叉树的遍历--递归+非递归(两种)

公告

小河沟大河沟

----------- 梦想还是要有的，万一实现了呢！纸上得来终觉浅 绝知此事要躬行！

二叉树的遍历--递归+非递归(两种)

公告

----------- 梦想还是要有的，万一实现了呢！纸上得来终觉浅绝知此事要躬行！