二叉树的创建和基本操作（递归和非递归）

最新推荐文章于 2018-02-12 18:39:37 发布
最新推荐文章于 2018-02-12 18:39:37 发布
阅读量633 收藏 3
点赞数
分类专栏： 学习 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LordWingF/article/details/72037518
版权

二叉树的定义在这里不做陈述，我们直接来看看如何实现一个二叉树的创建（c++）

首先定义结点，这里我们呢用结构体来创建

template<typename T>
struct BinaryTreeNode   //创建孩子二叉树的结点
{
    BinaryTreeNode(const T& data = T())
    :_data(data)
    , _pLeft(NULL)
    , _pRight(NULL)
    {}

    T _data;
    BinaryTreeNode* _pLeft;
    BinaryTreeNode* _pRight;
};

定义好结点之后我们就可以来想办法创建一个二叉树类，其中包含二叉树的创建和基本操作

template<typename T>
class BinaryTree
{
    typedef BinaryTreeNode<T> Node;
public:
    BinaryTree()
        : _pRoot()
    {}

    /***********用函数封装来做************/
    BinaryTree(const T* array, size_t size, const T& invalid)  //构造函数构造二叉树
    {
        size_t index = 0;
        _pRoot = CreatTree(array, size, index, invalid);
    }

    BinaryTree(const BinaryTree<T>& b)  //拷贝构造一个相同的二叉树
    {
        _pRoot = Copy(b._pRoot);
    }

    BinaryTree& operator=(BinaryTree<T>& b)  //重载=
    {
        if (this != &b)  //防止自己给自己赋值
        {
            BinaryTree<T> tem(b);
            std::swap(_pRoot, tem._pRoot);
        }
        return *this;
    }

    ~BinaryTree()  //析构函数释放树
    {
        Destory(_pRoot);
    }

    size_t _Leaf()  //求叶子结点个数
    {
        return Leaf(_pRoot);
    }

    size_t _Size()  //求结点个数
    {
        return Size(_pRoot);
    }

    size_t _Depth()  //求树的深度
    {
        return Depth(_pRoot);
    }

    void _PreOder()  //先序遍历
    {
        PreOder(_pRoot);
        cout << endl;
    }

    void _InOder()  //中序遍历
    {
        InOder(_pRoot);
        cout << endl;
    }

    void _BackOder()  //后序遍历
    {
        BackOder(_pRoot);
        cout << endl;
    }
protected:
    Node* _pRoot;
}

创建好这个二叉树类之后我们来将其中的功能进行相应的实现（这里我将所有的函数实现都已private的形式写在了类内部）

··········创建二叉树
/*先序递归创建二叉树*/
        Node* CreatTree(const T* array, size_t size, size_t& index, const T& invalid)
    {
        assert(array);

        Node* pRoot = NULL;
        if (index < size&&array[index] != invalid)
        {
            pRoot = new Node(array[index]);
            pRoot->_pLeft = CreatTree(array, size, ++index, invalid);
            pRoot->_pRight = CreatTree(array, size, ++index, invalid);
        }

        return pRoot;
    }

/*非递归创建二叉树*/
    Node *CreatTree(const T* a, size_t size, size_t index, const T& invalid)
    {
        stack<Node*> s;
        Node* pRoot = new Node(a[index++]);
        int flag = 1;         //flag  =1创建左孩子，=2创建右孩子，=3出栈  
        s.push(pRoot);
        Node *pPre = NULL;
        Node *pCur = NULL;

        while (index<size)
        {
            if (flag == 1)      //创建左孩子  
            {
                if (a[index] == invalid)     //如果左孩子为空，则flag=2创建右孩子  
                {
                    flag = 2;
                }
                else
                {
                    pCur = new Node(a[index]);
                    pPre = s.top();
                    pPre->_pLeft = pCur;          //链接到左指针上  
                    s.push(pCur);               //将新节点压入栈中  
                }
            }
            else if (flag == 2)              //flag=2,创建右孩子  
            {
                if (a[index] == invalid)        //如果右孩子为空，则flag=3准备出栈  
                {
                    flag = 3;
                }
                else
                {
                    pCur = new Node(a[index]);
                    pPre = s.top();
                    pPre->_pRight = pCur;          //链接到左指针上  
                    s.push(pCur);               //将新节点压入栈中  
                    flag = 1;                  //再创建新结点的左孩子  
                }
            }
            else
            {
                if (!s.empty())
                {
                    pPre = s.top();
                    s.pop();
                }
                //如果已经出栈的元素是当前栈顶的右孩子，则表示这个结点的左右子树已经创建完毕，则一直出栈  
                while (!s.empty() && s.top()->_pRight == pPre)
                {
                    pPre = s.top();
                    s.pop();
                }

                flag = 2;
                index--;
            }
            index++;
        }
        return pRoot;
    }



··········先序遍历
/*递归先序遍历*/
    void PreOder(Node* pRoot)
    {
        Node* pCur = pRoot;

        if (pCur)
        {
            cout << pCur->_data << " ";
            PreOder(pCur->_pLeft);
            PreOder(pCur->_pRight);
        }
    }

/*非递归先序遍历*/
    void PreOder(Node* _pRoot)
    {
        assert(_pRoot);

        Node *pRoot = _pRoot;
        stack<Node*> s;
        s.push(pRoot);
        int flag = 1;
        Node *pCur = NULL;

        while (!s.empty())
        {
            pCur = s.top();
            if (flag == 1)                  //遍历左子树  
            {
                if (pCur->_pLeft == NULL)    //如果左子树为空，则flag=2  
                {
                    flag = 2;
                }
                else
                {
                    cout << pCur->_Data << " ";    //先序输出，先输出根结点  
                    s.push(pCur->_pLeft);
                }
            }
            else if (flag == 2)
            {
                if (pCur->_pRight == NULL)
                {
                    flag = 3;
                }
                else
                {
                    s.push(pCur->_pRight);
                    flag = 1;
                }
            }
            else
            {
                Node *pPre = NULL;
                if (!s.empty())
                {
                    pPre = s.top();
                    s.pop();
                }
                pCur = pPre;
                while (!s.empty() && s.top()->_pRight == pPre)  //将输出过的结点出栈  
                {
                    pPre = s.top();
                    s.pop();
                }
                if (!s.empty())         //输出右子树的叶子节点  
                {
                    cout << pCur->_Data << " ";
                }
                flag = 2;
            }
        }
        cout << endl;
    }



·········中序遍历
/*递归中序遍历*/
    void InOder(Node* pRoot)
    {
        Node* pCur = pRoot;

        if (pCur)
        {
            InOder(pCur->_pLeft);
            cout << pCur->_data << " ";
            InOder(pCur->_pRight);
        }
    }

/*非递归中序遍历*/
    void InOder(Node* _pRoot)
    {
        assert(_pRoot);

        Node *pRoot = _pRoot;
        stack<Node*> s;
        s.push(pRoot);
        int flag = 1;

        while (!s.empty())
        {
            Node *pCur = s.top();
            if (flag == 1)                  //先遍历左子树  
            {
                if (pCur->_pLeft == NULL)
                {
                    flag = 2;
                }
                else
                {
                    s.push(pCur->_pLeft);
                }
            }
            else if (flag == 2)        //遍历右子树  
            {
                if (pCur->_pRight == NULL)
                {
                    flag = 3;
                }
                else
                {
                    cout << pCur->_Data << " ";        //输出右子树的跟结点  
                    s.push(pCur->_pRight);
                    flag = 1;
                }
            }
            else
            {
                Node* pPre = NULL;
                if (!s.empty())
                {
                    pPre = s.top();
                    s.pop();
                }
                cout << pPre->_Data << " ";          //输出左子树结点和左子树的根结点  

                while (!s.empty() && s.top()->_pRight == pPre)
                {
                    pPre = s.top();
                    s.pop();
                }
                flag = 2;
            }
        }
        cout << endl;
    }



········后序遍历
/*递归后序遍历*/
    void BackOder(Node* pRoot)
    {
        Node* pCur = pRoot;

        if (pCur)
        {
            BackOder(pCur->_pLeft);
            BackOder(pCur->_pRight);
            cout << pCur->_data << " ";
        }
    }

/*非递归后序遍历*/
    void BackOder(Node* _pRoot)
    {
        assert(_pRoot);

        Node *pRoot = _pRoot;
        stack<Node*> s;
        int flag = 1;       //=1遍历左子树，=2 遍历右子树，=3 输出结点  
        s.push(pRoot);       //根节点入栈  
        Node *pCur = NULL;

        while (!s.empty())
        {
            pCur = s.top();
            if (flag == 1)              //遍历左子树  
            {
                if (pCur->_pLeft == NULL)   //如果左子树为空，则flag=2,准备遍历右子树  
                {
                    flag = 2;
                }
                else
                {
                    s.push(pCur->_pLeft);
                }
            }
            else if (flag == 2)             //遍历右子树  
            {
                if (pCur->_pRight == NULL)       //右子树为空，准备输出结点  
                {
                    flag = 3;
                }
                else
                {
                    s.push(pCur->_pRight);
                    flag = 1;                //遍历当前结点的左子树  
                }
            }
            else
            {
                Node *pPre = NULL;
                if (!s.empty())
                {
                    pPre = s.top();    //保存当前栈顶元素  
                    s.pop();          //抛出栈顶元素  
                }
                cout << pPre->_Data << " ";    //输出结点的信息  

                //如果当前栈顶元素的右子树是pPre，则抛出pPre之后按照后序也要抛出栈顶元素  
                while (!s.empty() && s.top()->_pRight == pPre)
                {
                    pPre = s.top();    //保存当前栈顶元素  
                    s.pop();          //抛出栈顶元素  
                    cout << pPre->_Data << " ";    //输出结点的信息  
                }
                flag = 2;
            }
        }
        cout << endl;
    }



········求叶子结点个数
/*递归*/
        size_t Leaf(Node* pRoot)
    {
        Node* pCur = pRoot;

        if (NULL == pCur)
            return 0;

        if (pCur->_pLeft == NULL&&pCur->_pRight == NULL)      //如果左右子树都为空，则返回1  
            return 1;

        return Leaf(pCur->_pLeft) + Leaf(pCur->_pRight);
    }

/*非递归*/ 
    size_t Leaf(Node* pRoot)
    {
        size_t index = 0;
        Node* pCur = pRoot;
        stack<Node*> s;

        while (pCur || !s.empty())
        {
            while (pCur)
            {
                //如果左右子树都为空，则为叶子结点  
                if (pCur->_pLeft == NULL&&pCur->_pRight == NULL)
                    index++;
                s.push(pCur);
                pCur = pCur->_pLeft;
            }
            Node* pPre = s.top();
            s.pop();
            pCur = pPre ->_pRight;
        }
        return index;
    }



·········求结点个数
/*递归*/
    size_t Size(Node* pRoot)
    {
        if (pRoot == NULL)
            return 0;

        return 1 + Size(pRoot->_pLeft) + Size(pRoot->_pRight);
    }

/*非递归*/
       size_t Size(Node* pRoot)
    {
        size_t index = 0;
        Node* pCur = pRoot;
        stack<Node*> s;

        while (pCur || !s.empty())
        {
            while (pCur)
            {
                index++;        //遍历一个结点就让count++  
                s.push(pCur);
                pCur = pCur->_pLeft;
            }
            Node * top = s.top();
            s.pop();
            pCur = top->_pRight;
        }
        return index;
    }



········树的深度
/*递归*/
        size_t Depth(Node* pRoot)
    {
        Node* pCur = pRoot;

        if (NULL == pCur)
            return 0;

        return 1 + (Depth(pCur->_pLeft) > Depth(pCur->_pRight)
            ? Depth(pCur->_pLeft) : Depth(pCur->_pRight));
    }

/*非递归*/
        size_t Depth(Node* pRoot)
    {
        if (pRoot == NULL)
            return 0;

        queue<Node*> q;
        size_t deep = 0;
        size_t  NodeNum = 1;      //统计有多少数据入过队  
        size_t  LeveLast = 1;      //标记正在访问的这层的最后一个数据的序号  
        size_t  VisitNum = 0;       //统计已经出队的数据的个数  
        q.push(pRoot);

        while (!q.empty())
        {
            Node* pCur = q.front();
            q.pop();
            VisitNum++;
            if (NULL != pCur->_pLeft)
            {
                q.push(pCur->_pLeft);
                NodeNum++;
            }
            if (NULL != pCur->_pRight)
            {
                q.push(pCur->_pRight);
                NodeNum++;
            }
            //如果以出队的个数等于这一层的最后一个数据的序号  
            if (LeveLast == VisitNum)
            {
                deep++;                //访问完一层就让深度加一  
                LeveLast = NodeNum;    //更新到下一层的最后一个数据的位置  
            }
        }
        return deep;
    }

创建好之后让我么来测试一下，首先测试递归版本的二叉树
测试代码如下

void FunTest()
{
    int array[] = { 1, 2, 3, '#', 4, '#', '#', 5, 6, '#', '#', 7 };
    BinaryTree<int> t(array, sizeof(array) / sizeof(array[0]), '#');

    cout << t._Leaf() << endl;
    cout << t._Size() << endl;
    cout << t._Depth() << endl;
    t._PreOder();
    t._InOder();
    t._BackOder();
}

int main()
{
    FunTest();

    return 0;
}

输出结果为
这里写图片描述

接下来是非递归版本的二叉树
测试代码如下

void FunTest()
{
    int arr[] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 };
    BinaryTree<int> t(arr, sizeof(arr) / sizeof(arr[0]), '#');
    t._PrevOder();
    t._InOder();
    t._BackOder();
    cout << t._Leaf() << endl;
    cout << t._Size() << endl;
    cout << t._Depth() << endl;

}

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

输出结果为
这里写图片描述

以上就是二叉树的创建及基本操作

非递归创建二叉树
杨龙飞的博客
03-13 2154
虽然我们能用递归创建二叉树，但是我们是否真正的理解真正的递归过程呢,其实，递归函数的内部还是挺复杂的，想真正弄明白递归也是要下一番功夫的，虽然说，递归算法有效的减少了某些问题的编程，但是它只能简化程序编码，却不能降低程序的时间和空间复杂度，相反，由于执行过程依赖函数或过程的重复调用,会增加函数的时间复杂度.而且返回函数的地址保存需要占用系统栈，从而增加的空间的复杂度。下面是我用栈实现了二叉树的非递
非递归建立二叉树
weixin_30708329的博客
05-08 739
前言 　　使用递归（Recursion）建立二叉树（Binary Tree）的非顺序存储结构（即二叉链表），可以简化算法编写的复杂程度，但是递归效率低，而且容易导致堆栈溢出，因而很有必要使用非递归算法。 引入 　　无论是单链表还是二叉树，创建时要解决问题就是关系的建立，即单链表中前驱节点与当前节点的关系和二叉树中父节点与子节点的关系。 　　首先，思考一下建立单链表的过程，为了使链表各个节点...
递归与非递归创建二叉树
aige0727的博客
12-16 365
二叉树中又有二叉树，也就是递归。因此使用递归创建二叉树是最简单的。思路很简单：我们申明一个结构体TREENODE，该结构体有三个成员，分别是Value，LeftChild和RightChild。 代码如下： typedef struct _struct_tree_node { char m_cData; _struct_tree_node* m_pLeftC...
递归与非递归实现二叉树
weixin_33968104的博客
04-21 118
二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”和“右子树”。二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2^（i - 1）个结点；深度为k的二叉树至多有2^k - 1个结点。由于树的定义是递归实现的，所以在进行二叉树的前序、中序和后序遍历可通过递归实现，但也可通过非递归的栈来实现...
非递归方式创建二叉树
Legend(谭海燕)的专栏
08-09 7000
非递归方式创建二叉树
c语言版本二叉树基本操作示例(先序 递归 非递归)
09-04
在本文中，我们将探讨如何在C语言中实现二叉树的基本操作，包括创建、先序、中序、后序以及层序遍历。这些遍历方法既可以通过递归方式，也可以通过非递归方式实现。 首先，我们定义一个二叉树节点结构体`BTNode`，...
C++二叉树非递归以及递归算法
11-29
包含一下方法: 1.通过一个数组来构造一颗...6.使用非递归 先序遍历一棵二叉树 7.使用非递归 中序遍历一棵二叉树 8.使用非递归 后序遍历一棵二叉树 PS:代码为C++代码 可以直接下载使用！！！ PS2:每句代码都有详细注释
c语言版本二叉树基本操作示例(先序递归非递归)共10页.p
10-29
在“c语言版本二叉树基本操作示例(先序递归非递归)共10页”的资料中，可能包含了如何创建二叉树节点、插入新节点、删除节点以及执行先序遍历（递归和非递归）的示例代码和详细解释。这样的教程对于初学者来说极具...
深入遍历二叉树的各种操作详解（非递归遍历）
01-01
先使用先序的方法建立一棵二叉树，然后分别使用递归与非递归的方法实现前序、中序、后序遍历二叉树，并使用了两种方法来进行层次遍历二叉树，一种方法就是使用STL中的queue，另外一种方法就是定义了一个数组队列，...
C++基于递归和非递归算法判定两个二叉树结构是否完全相同(结构和数据都相同)
08-30
本文主要介绍了C++基于递归和非递归算法判定两个二叉树结构是否完全相同，主要涉及C++二叉树的创建、遍历、比较等相关操作技巧。 一、递归方式判定两个二叉树是否相等 在递归方式中，我们可以通过比较两个二叉树的...
C++ 非递归二叉树创建
07-09
非递归实现C++二叉树 Node* creatTree(struct Node *head) void preOrderUnrec(struct Node *head) void inOrderUnrec(struct Node *head) void postOrderUnrec(struct Node *head)
二叉树创建及遍历算法(递归及非递归)
软件开发资料汇总
01-03 334
//二叉树处理头文件//包括二叉树的结构定义,二叉树的创建,遍历算法(递归及非递归),/* 作者：成晓旭 时间：2001年10月7日(18:49:38-20:00:00) 内容：完成二叉树创建,二叉树的前,中,后序遍历(递归) 时间：2001年10月7日(21:09:38-22:09:00) 内容：完成二叉树的前,中序遍历(非递归) 时间：2001年10月8日(10:09:38-11:29:00)
二叉树的非递归创建
u013798344的专栏
11-27 479
新手一枚，希望记下自己写的代码，希望各位亲能够给我提出意见和建议 #include #include #define MAX 999                 //MAX表示结点是否置为空 #define MAX_SIZE 100      //栈的最大容量 typedef int ElemType; typedef struct TreeNode{    //定
树 二叉树的建立和基本操作
大芝士球的博客
02-12 1034
二叉树是应用非常广泛的结构，其基本实现如下：结点结构：也就是使用二叉链表实现typedef struct Node //树结点结构 { char data; struct Node *lchild; struct Node *rchild; }BitreeNode,*Bitree; //先序建立二叉树 Bitree create() { Bitree T; char ch;...
非递归建立二叉树 c
summersunboy的专栏
01-20 2859
非递归建立二叉树 c
二叉树的创建及基本操作。
LoveofQingCheng的专栏
10-06 448
#include #include using namespace std; typedef struct node { int data; struct node *lchild;     struct node *rchild; }binode,*bitree; bitree initree(binode *root) { bitree tree=root; retur
C语言二叉树创建与遍历示例(先序、递归与非递归)
总结来说，本资源提供了C语言实现二叉树创建、递归和非递归遍历的关键代码示例，帮助读者理解如何在C语言环境中处理二叉树数据结构，这对于理解和应用二叉树算法非常有帮助。对于学习者而言，这是深入理解数据结构和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值