二叉树遍历

最新推荐文章于 2024-10-21 08:57:50 发布

HelloCooper

最新推荐文章于 2024-10-21 08:57:50 发布

阅读量476

点赞数

CC 4.0 BY-SA版权

分类专栏：算法文章标签： C++ 二叉树遍历非递归

本文链接：https://blog.youkuaiyun.com/hellocooper/article/details/47978367

算法专栏收录该内容

36 篇文章

订阅专栏

本文详细介绍了二叉树的前序、中序和后序遍历方法，并提供了递归和非递归实现的C++代码示例。通过本文的学习，读者可以深入理解二叉树遍历的基本原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

二叉树遍历分为前序遍历、中序遍历、后序遍历，三种遍历都分递归遍历和非递归遍历。

前序遍历（PreOrderTraverse）：

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

        //非递归前序遍历C++
        void preOrder2(BinTree *root)
        {
            //使用栈s和一个遍历指针p
            stack<BinTree*> s;
            BinTree *p=root;
            while(p!=NULL||!s.empty())  //遍历指针p或者栈s不空
            {
                while(p!=NULL)  //p不空，压栈，然后往左跑
                {
                    cout<<p->data<<" ";
                    s.push(p);
                    p=p->lchild;
                }
                if(!s.empty())  //p遇到NULL，从栈s顶部取一个节点给p，p往右跑一次
                {
                    p=s.top();
                    s.pop();
                    p=p->rchild;
                }
            }
        }</span>

中序遍历（InOrderTraverse）

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

        //非递归中序遍历
        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;
                }
            }   
        }</span>

后序遍历（PostOrderTraverse）

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

        //非递归后续遍历2
        void postOrder2(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);
                }
            }
        }

        //非递归后序遍历3
        class BTNode{
        public:
            BinTree *btnode;
            bool isFirst;
            BTNode():btnode(NULL),isFirst(false){ }
        };
        
        void postOrder3(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;
                    }
                }
            }
        }