C++二叉树之构造拷贝赋值，递归和非递归的前序遍历，中序遍历和后序遍历，以及层序遍历

最新推荐文章于 2024-04-23 22:54:49 发布

o_bvious

最新推荐文章于 2024-04-23 22:54:49 发布

阅读量635

点赞数 1

CC 4.0 BY-SA版权

分类专栏：数据结构文章标签：前序遍历中序遍历后续遍历递归层序遍历

本文链接：https://blog.youkuaiyun.com/o_bvious/article/details/52034342

数据结构专栏收录该内容

10 篇文章

订阅专栏

这篇博客详细探讨了C++中二叉树的前序、中序、后序遍历，包括递归和非递归两种方法，以及层序遍历的实现技巧。通过实例代码解析，帮助读者深入理解各种遍历策略。

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

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

template<typename T>
struct BinaryTreeNode
{
    BinaryTreeNode(T data)
    : _data(data)
    , _pLeft(NULL)
    , _pRight(NULL)
    {}
    T _data;
    BinaryTreeNode<T>* _pLeft;
    BinaryTreeNode<T>* _pRight;
};

template<typename T>
class BinaryTree
{
public:

    BinaryTree() :_proot(NULL){}

    BinaryTree(BinaryTreeNode<T>* _root, size_t size, T *arr)
    {
        size_t index = 0;
        _CreateTree(_root, arr, size, index);
        _proot = _root;
    }

    BinaryTree(const BinaryTree<T> &TREE)
    {
        _proot=copycons(TREE._proot);

    }

    BinaryTree<T>& operator=(BinaryTree<T>&tree)
    {
        destroy(_proot);
        _proot = copycons(tree._proot);
        return *this;
    }

    ~BinaryTree()
    {
        destroy(_proot);
    }
public:
    //递归先序遍历
    void TREEPreOrder(BinaryTreeNode<T>* proot)
    {
        if (proot != NULL)
        {
            cout << proot->_data;
            TREEPreOrder(proot->_pLeft);
            TREEPreOrder(proot->_pRight);
        }
    }
    //递归先序遍历
    void PreOrder()
    {
        TREEPreOrder(_proot);
    }

    //递归中序遍历
    void TreeMidOrder(BinaryTreeNode<T>* proot)
    {
        if (proot != NULL)
        {
            TreeMidOrder(proot->_pLeft);
            cout << proot->_data;
            TreeMidOrder(proot->_pRight);
        }
    }
    //递归中序遍历
    void MidOrder()
    {
        TreeMidOrder(_proot);
    }

    //递归后序遍历
    void TreeLastOrder(BinaryTreeNode<T>* proot)
    {
        if (proot != NULL)
        {
            TreeLastOrder(proot->_pLeft);
            TreeLastOrder(proot->_pRight);
            cout << proot->_data;

        }
    }
    //递归后序遍历
    void LastOrder()
    {
        TreeLastOrder(_proot);
    }

    //层序遍历
    void FloorOrder()
    {
        if (_proot!=NULL)
        {
            queue<BinaryTreeNode<T>* > QU;
            QU.push(_proot);
            while (!QU.empty())
            {
                cout << QU.front()->_data;

                if (QU.front()->_pLeft != NULL)
                    QU.push(QU.front()->_pLeft);
                if (QU.front()->_pRight != NULL)
                    QU.push(QU.front()->_pRight);
                QU.pop();
            }
        }
    }


    //循环实现先序遍历方法一：
    void PreOrderNor()
    {
        if (_proot)
        {
            stack< BinaryTreeNode<T>* > STK;
            STK.push(_proot);
            while (!STK.empty())
            {
                cout << STK.top()->_data;
                BinaryTreeNode<T>*tmpleft = STK.top()->_pLeft;
                BinaryTreeNode<T>*tmpringht = STK.top()->_pRight;
                STK.pop();

                if (tmpringht != NULL)
                    STK.push(tmpringht);

                if (tmpleft != NULL)
                    STK.push(tmpleft);
            }
        }
    }

    //循环实现先根遍历方法二
    void BinaryTree<T>::PreOrderWithoutRecursion()  {     // 使用STL栈
        stack<BinaryTreeNode<T>* > aStack;
        BinaryTreeNode<T> *pointer = _proot;
        aStack.push(pointer);
        while (!aStack.empty()) {
            pointer = aStack.top();                     // 获栈顶元素
            aStack.pop();           // 栈顶元素退栈
            cout<<(pointer->_data);           // 访问前结点
            if (pointer->_pRight != NULL)        // 非空右孩入栈
                aStack.push(pointer->_pRight);
            if (pointer->_pLeft != NULL)            // 非空左孩入栈
                aStack.push(pointer->_pLeft);
        }
    }

    //循环实现中序遍历一
    void MidOrderNor()
    {
        if (!_proot)
            return;
        BinaryTreeNode<T>* Pcur = _proot;
        stack<BinaryTreeNode<T>* > STK;
        while (Pcur != NULL)
        {
            STK.push(Pcur);
            Pcur = Pcur->_pLeft;
        }
        while (!STK.empty())
        {
            Pcur = STK.top();
            cout << Pcur->_data;
            STK.pop();
            if (Pcur->_pRight)
            {
                Pcur = Pcur->_pRight;
                while (Pcur != NULL)
                {
                    STK.push(Pcur);
                    Pcur = Pcur->_pLeft;
                }
            }
        }       
    }


    //循环实现中序遍历二
    void MidOrderNor1()
    {
        if (!_proot)
            return;
        BinaryTreeNode<T>* Pcur = _proot;
        stack<BinaryTreeNode<T>* > STK;
        while (!STK.empty() || Pcur != NULL)
        {
            while (Pcur != NULL)
            {
                STK.push(Pcur);
                Pcur = Pcur->_pLeft;
            }
            if (!STK.empty())
            {
                Pcur = STK.top();
                cout << Pcur->_data;
                STK.pop();
                Pcur = Pcur->_pRight;
            }
        }
    }

    //循环实现后序遍历
    void LastOrderNor()
    {
        if (!_proot)
            return;
        BinaryTreeNode<T>* Pcur = _proot;
        BinaryTreeNode<T>* LastVist = _proot;
        stack<BinaryTreeNode<T>* > STK;

        while (Pcur != NULL)
        {
            STK.push(Pcur);
            Pcur = Pcur->_pLeft;
        }

        while (!STK.empty())
        {
            LastVist = Pcur;
            Pcur = STK.top();
            STK.pop();
            if (Pcur->_pRight == NULL || Pcur->_pRight==LastVist)
            {
                cout << Pcur->_data;
            }
            else if (Pcur ->_pLeft==LastVist)
            {
                STK.push(Pcur);
                Pcur = Pcur->_pRight;
                STK.push(Pcur);
                while (Pcur != NULL)
                {
                    if (Pcur->_pLeft)
                    {
                        STK.push(Pcur->_pLeft);
                    }
                    Pcur = Pcur->_pLeft;
                }
            }
        }
    }
private:
    //拷贝节点
    BinaryTreeNode<T>* copycons(BinaryTreeNode<T>* proot)
    {
        if (proot != NULL)
        {
            BinaryTreeNode<T>* pRoot=NULL;
            pRoot = new BinaryTreeNode<T>(proot->_data);
            pRoot->_pLeft = copycons(proot->_pLeft);
            pRoot->_pRight = copycons(proot->_pRight);
            return pRoot;
        }
        return NULL;
    }

    //清理节点
    void destroy(BinaryTreeNode<T>* proot)
    {
        if (proot != NULL)
        {
            destroy(proot->_pLeft);
            destroy(proot->_pRight);
            delete proot;
            proot = NULL;
        }
    }
    //创建树
    void _CreateTree(BinaryTreeNode<T>*& pRoot, const T *arr, size_t size, size_t& index)
    {
        if (index < size&&arr[index]!='#')
        {
            pRoot = new BinaryTreeNode<T>(arr[index]);
            _CreateTree(pRoot->_pLeft, arr, size, ++index);
            _CreateTree(pRoot->_pRight, arr, size, ++index);
        }
    }

private:
    BinaryTreeNode<T>* _proot;
};


void test()
{
    char arr[] = "013##4##25#";
    BinaryTreeNode<char>* proot=NULL;
    BinaryTree<char> tree(proot, 11, arr);
    BinaryTree<char> tree1(tree);
    BinaryTree<char> tree12;
    tree12 = tree1;
    tree.PreOrder();
    cout << endl;
    tree.MidOrder();
    cout << endl;
    tree.LastOrder();
    cout << endl;
    tree.FloorOrder();
    cout << endl;
    tree.PreOrderNor();

    cout << endl;
    tree.PreOrderWithoutRecursion();
    cout << endl;

    tree.MidOrderNor();
    cout << endl;
    tree.MidOrderNor1();
    cout << endl;

    tree.LastOrderNor();
    cout << endl;

}

int main()
{
    test();
    system("pause");
    return 0;
}