二叉树的基本操作

最新推荐文章于 2022-10-15 16:22:21 发布
最新推荐文章于 2022-10-15 16:22:21 发布
阅读量1.1k 收藏 1
点赞数 3
分类专栏： 数据结构 文章标签： 二叉树 递归 非递归
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34992845/article/details/71305940
版权

1。二叉树的特点：

二叉树的特点：

1.每个节点最多有两棵子树，即二叉树中不存在度大于2的节点（分支数最大不超过2）
2.二叉树的子树有左右之分，也就是说二叉树是有序的。

2。二叉树的基本操作（递归）：

以下面的二叉树为例：

这里写图片描述

1.求二叉树的节点个数：
思路：
(1)root 为空（整个二叉树的根节点为空） return 0;
(2)root不为空 —>左子树的节点个数 + 右子树的节点个数 + 1（当前节点）

代码如下：

size_t _Size(Node* root)
    {
        if (root == NULL)
        {
            return 0;
        }
        return _Size(root->_left) + _Size(root->_right) + 1;
    }

这里写图片描述

代码如下：

size_t _LeafSize(Node* root)
    {
        if (root == 0)
        {
            return 0;
        }
        if (NULL == root->_left && NULL == root->_right)
        {
            return 1;
        }
        return _LeafSize(root->_left) + _LeafSize(root->_right);
    }

这里写图片描述

代码如下：

size_t _GetKLevel(Node* root, size_t k)
    {
        if (root == NULL)
        {
            return 0;
        }
        if (k == 1)
        {
            return 1;
        }
        return _GetKLevel(root->_left, k - 1) + _GetKLevel(root->_right, k - 1);
    }

这里写图片描述

代码如下：

size_t _Depth(Node* root)
    {
        if (NULL == root)
        {
            return 0;
        }
        if (NULL == root->_left && NULL == root->_right)
        {
            return 1;
        }
        size_t leftDepth = _Depth(root->_left);
        size_t rightDepth = _Depth(root->_right);
        return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
    }

这里写图片描述
代码如下：

Node* _Find(Node* root, const T& x)
    {
        if (NULL == root)
        {
            return NULL;
        }
        if (root->_data == x)
        {
            return root;
        }
        Node* ret = _Find(root->_left, x);
        if (ret)
        {
            return ret;
        }
        return _Find(root->_right, x);
    }

递归算法的前序遍历的图解：

这里写图片描述

注明：紫颜色标记左子树的路径、蓝颜色标记返回路径、红色标记右子树的路径。
这里只画出了前序遍历的调用过程，而中序和后序遍历是相似的过程。

全部代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include<queue>

//二叉树节点的定义
template<class T>
struct BinaryTreeNode
{
    BinaryTreeNode(const T& data)
    :_data(data)
    , _left(NULL)
    , _right(NULL)
    {}
    T _data;
    BinaryTreeNode<T>* _left;
    BinaryTreeNode<T>* _right;
};

//定义二叉树
template<class T>
class BinaryTree
{
    typedef BinaryTreeNode<T> Node;
public:
    //创建二叉树
    BinaryTree(T* arr, size_t n, const T& invalid)
    {
        size_t index = 0;
        _root = _CreatBinaryTree(arr, n, invalid, index);
    }

    BinaryTree()
        :_root(NULL)
    {}

    //拷贝构造函数
    BinaryTree(const BinaryTree<T>& bt)
    {
        _root = _CopyBinaryTree(bt._root);
    }

    //赋值运算符的重载
    BinaryTree<T>& operator=(const BinaryTree<T>& bt)
    {
        if (this != &bt)
        {
            this->~BinaryTree();//释放旧空间
            _root = _CopyBinaryTree(bt._root);
        }
        return *this;
    }

    //先序遍历
    void PreOrder()
    {
        _PreOrder(_root);
        cout << endl;
    }

    //中序遍历
    void InOrder()
    {
        _InOrder(_root);
        cout << endl;
    }
    //后序遍历
    void PostOrder()
    {
        _PostOrder(_root);
        cout << endl;
    }
    //层序遍历
    void LevelOrder()
    {
        queue<Node*> q;
        if (_root)
        {
            q.push(_root);
        }

        while (!q.empty())
        {
            Node* front = q.front();
            cout << front->_data << " ";
            if (front->_left)
            {
                q.push(front->_left);
            }
            if (front->_right)
            {
                q.push(front->_right);
            }
            q.pop();
        }
    }

    size_t Size()
    {
        return _Size(_root);
    }

    //求叶子节点的个数
    size_t LeafSize()
    {
        return _LeafSize(_root);
    }

    //获取第K层节点的个数
    size_t GetKLevel(size_t k)
    {
        return _GetKLevel(_root, k);
    }

    //获取二叉树的深度
    size_t Depth()
    {
        return _Depth(_root);
    }
    //查找值为x的节点
    Node* Find(const T& x)
    {
        return _Find(_root, x);
    }

    ~BinaryTree()
    {
        _Destroy(_root);
    }

protected:
    Node* _CopyBinaryTree(Node* root)
    {
        if (NULL == root)
        {
            return NULL;
        }
        Node* newRoot = new Node(root->_data);//拷贝根节点
        newRoot->_left = _CopyBinaryTree(root->_left);
        newRoot->_right = _CopyBinaryTree(root->_right);
        return newRoot;
    }

    Node* _Find(Node* root, const T& x)
    {
        if (NULL == root)
        {
            return NULL;
        }
        if (root->_data == x)
        {
            return root;
        }
        Node* ret = _Find(root->_left, x);
        if (ret)
        {
            return ret;
        }
        return _Find(root->_right, x);
    }

    size_t _Depth(Node* root)
    {
        if (NULL == root)
        {
            return 0;
        }
        if (NULL == root->_left && NULL == root->_right)
        {
            return 1;
        }
        size_t leftDepth = _Depth(root->_left);
        size_t rightDepth = _Depth(root->_right);
        return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
    }

    size_t _GetKLevel(Node* root, size_t k)
    {
        if (root == NULL)
        {
            return 0;
        }
        if (k == 1)
        {
            return 1;
        }
        return _GetKLevel(root->_left, k - 1) + _GetKLevel(root->_right, k - 1);
    }

    size_t _LeafSize(Node* root)
    {
        if (root == 0)
        {
            return 0;
        }
        if (NULL == root->_left && NULL == root->_right)
        {
            return 1;
        }
        return _LeafSize(root->_left) + _LeafSize(root->_right);
    }

    Node* _CreatBinaryTree(T* arr, size_t n, const T& invalid, size_t& index)
    {
        Node* root = NULL;
        if (index < n && arr[index] != invalid)
        {
            root = new Node(arr[index]);
            root->_left = _CreatBinaryTree(arr, n, invalid, ++index);
            root->_right = _CreatBinaryTree(arr, n, invalid, ++index);
        }
        return root;
    }

    void _Destroy(Node* root)
    {
        if (root)
        {
            _Destroy(root->_left);
            _Destroy(root->_right);
            delete root;
            root = NULL;
        }
    }

    void _PreOrder(Node* root)
    {
        if (root)
        {
            cout << root->_data << " ";
            _PreOrder(root->_left);
            _PreOrder(root->_right);
        }
    }

    void _InOrder(Node* root)
    {
        if (root)
        {
            _InOrder(root->_left);
            cout << root->_data << " ";
            _InOrder(root->_right);
        }
    }

    void _PostOrder(Node* root)
    {
        if (root)
        {
            _PostOrder(root->_left);
            _PostOrder(root->_right);
            cout << root->_data << " ";
        }
    }

    size_t _Size(Node* root)
    {
        if (root == NULL)
        {
            return 0;
        }
        return _Size(root->_left) + _Size(root->_right) + 1;
    }
private:
    Node* _root;
};

测试代码如下：

void Test()
{
    int array[10] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 };
    BinaryTree<int> bt(array, sizeof(array) / sizeof(int), '#');
    /*bt.PreOrder();
    bt.InOrder();
    bt.PostOrder();
    bt.LevelOrder();*/
    cout << bt.Size() << endl;
    /*cout << bt.LeafSize() << endl;
    cout << bt.GetKLevel(3) << endl;
    cout << bt.GetKLevel(2) << endl;
    cout << bt.GetKLevel(1) << endl;
    cout << bt.GetKLevel(8) << endl;*/

    cout << bt.Depth() << endl;
    BinaryTreeNode<int>* ret = bt.Find(6);
    if (ret)
    {
        cout << ret->_data << endl;
    }
}

void Test2()
{
    int array[10] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 };
    BinaryTree<int> bt(array, sizeof(array) / sizeof(int), '#');
    bt.PreOrder();
    int array2[15] = { 1, 2, '#', 3, '#', '#', 4, 5, '#', 6, '#', 7, '#', '#', 8 };
    BinaryTree<int> bt2(array2, sizeof(array2) / sizeof(int), '#');
    bt2.PreOrder();
    bt2 = bt;
    bt2.PreOrder();
}

int main()
{
    Test2();
    return 0;
}

3。前序、中序及后序的非递归遍历：

这里写图片描述
前序遍历的代码如下：


     //先序遍历（非递归）
    void PreOrderR()
    {
        Node* cur = _root;
        stack<Node*> s;
        while (cur || !s.empty())
        {
            //将左支路的节点均压栈
            while (cur)
            {
                cout << cur->_data << " ";
                s.push(cur);
                cur = cur->_left;       
            }
            //栈中保存的节点的左子树都已访问过
            //只剩下栈中节点的右子树没有访问
            Node* top = s.top();
            s.pop();
            cur = top->_right;//循环的子问题
        }
    }

中序遍历的代码如下：

//中序遍历的非递归
    void InOrderR()
    {
        Node* cur = _root;
        stack<Node*> s;
        while (cur || !s.empty())
        {
            while (cur)
            {
                s.push(cur);
                cur = cur->_left;
            }

            //栈中节点的左子树已经遍历完
            //栈中节点自身和右子树还没有遍历
            Node* top = s.top();
            cout << top->_data << " ";
            s.pop();
            cur = top->_right;
        }
        cout << endl;
    }

后序遍历的两种方法：
第一种方法：

后序遍历的非递归算法
    使用一个栈index来标记栈s的栈顶元素出现的次数，并且栈index与栈s同入栈和同出栈
    void PostOrderR()
    {
        Node* cur = _root;
        stack<Node*> s;
        stack<int> index;
        while (cur || !s.empty())
        {
            while (cur)
            {
                s.push(cur);
                index.push(0);//第一次出现在栈顶时标记为0
                cur = cur->_left;
            }

            if (index.top() == 1)
            {
                Node* top = s.top();
                cout << top->_data << " ";
                s.pop();
                index.pop();
            }
            else
            {
                Node* top = s.top();//第二次出现
                index.top() = 1;//将其设置为1
                cur = top->_right;//循环的子问题
            }
        }
    }

第二种方法：

//后序遍历的非递归算法
    //使用一个标记位：每次访问一个节点，则更新标记位
    void PostOrderR()
    {
        Node* cur = _root;
        stack<Node*> s;
        Node* prev = NULL;
        while (cur || !s.empty())
        {
            while (cur)
            {
                s.push(cur);
                cur = cur->_left;
            }
            Node* top = s.top();
            if (NULL == top->_right || top->_right == prev)
            {
                cout << top->_data << " ";
                s.pop();
                prev = top;
            }
            else
            {
                cur = top->_right;//循环的子问题
            }
        }
    }
小葱1024
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树基本操作
04-30
1、根据输入的数据建立一个二叉树； 2、分别采用前序、中序、后序的遍历方式显示输出二叉树的遍历结果 3、采用非递归的编程方法，分别统计二叉树的节点个数、度为1、度为2和叶子节点的个数，以及数据值的最大值和...
【数据结构】详解二叉树及其操作
最新发布
Become Mad的博客
07-23 1297
二叉树要比以往其他的数据结构要来的更加抽象，当然努力功课这有挑战的一章也能够让你颇有成就感。
二叉树基本操作（一）
lxt-st
08-20 411
目录 一、二叉树的概念 二、二叉树的分类 满二叉树 && 完全二叉树 三、二叉树的基本操作 1、二叉树的创建 2、二叉树的销毁 3、求二叉树的高度 4、求二叉树叶子结点的个数 5、求二叉树结点的个数 6、求二叉树第 K 层结点的个数 7、判断一个节点是否在一棵二叉树中 注：完整代码请至 Github 查看：https://github.com/...
二叉树-基于C语言实现的二叉树基本操作.zip
04-26
本压缩包包含的是基于C语言实现的二叉树基本操作，是学习和理解二叉树概念以及其实现的一个宝贵资源。 在C语言中，实现二叉树通常涉及定义一个结构体来表示节点，这个结构体至少包含两个指针，分别指向左右子节点，...
二叉树基本操作_二叉树基本操作_
10-02
二叉树的基本操作主要包括创建、查找、插入和删除节点，这些操作对于理解和掌握二叉树至关重要。接下来，我们将详细讨论这些操作。 1. **创建二叉树** 创建一个二叉树首先需要定义二叉树节点的数据结构。在链表...
二叉树基本操作的程序实现.zip_二叉树的基本操作
09-21
这篇文档“二叉树基本操作的程序实现”涵盖了二叉树的一些核心概念和基本操作，旨在帮助初学者理解并实现这些概念。 二叉树由节点构成，每个节点最多有两个子节点，通常分为左子节点和右子节点。二叉树的主要类型有...
实验四 二叉树基本操作的实现
12-18
在本实验中，我们将深入探讨数据结构中的一个重要概念——二叉树，并实现其基本操作。二叉树是一种非线性的数据结构，它由一个有限集合的节点构成，每个节点最多有两个子节点，通常称为左子节点和右子节点。这个实验...
二叉树的基本特性和二叉树的几种基本操作的机制_算法基础：二叉树的遍历
weixin_39595164的博客
11-23 170
二叉树是平时最常见的数据结构之一。它属于树的一种，其中每个节点都不能有多余两个的儿子。二叉树在面试或者平常做算法题时，如果遇到二叉树类的题目，基本都要借助到二叉树的遍历，下面就来介绍一下二叉树的几种常见遍历方式。二叉树的遍历主要分为：深度优先遍历和广度优先遍历。深度优先遍历英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止。...
二叉树_基础操作
RuanMeng的博客
03-27 168
1.二叉树前中后序遍历(递归) 2.二叉树层次遍历 3.计算所有节点个数 4.计算叶子节点个数 5.计算第K层节点个数 6.在二叉树中查找指定元素
二叉树的基本操作（总结）
ParadiseHeaven的博客
11-21 1098
二叉树的基本操作 二叉树的定义决定了其大多数操作都可以由递归去实现 本文通过递归和非递归两种方式实现二叉树的基本操作（加深对原理的理解） 1.二叉树的声明   typedef char ElementType; typedef struct TreeNode* BinTree; struct TreeNode{ ElementType Data; struct Tre...
二叉树的基本操作(简单易懂)
weixin_30802171的博客
11-13 2275
二叉树基本操作 1.初始化 2.建树 3.销毁树 4.插入操作 5.查找元素值为e的节点的指针 6.查找元素值为e的节点左节点的值 7.查找元素值为e的节点右节点的值 8.删除左子树 9.删除右子树 10.先序遍历 11.中序遍历 12.后序遍历 计算叶子节点数 14.计算非叶子节点数 15.计算树的深度 我输入的树按先序输入 ABC##D##EF#G##HI### 代码 #include&...
二叉树基础操作
weixin_63178060的博客
10-15 1149
层序遍历相对于前三种遍历，需要用队列进行辅助操作，具体操作：定义一个队列，首先将二叉树的第一个结点入队，while循环判断该队列是否为空，不为空的话，则先进行出队，然后判断该树的左又子树是否为空，不为空则入队。在销毁时，不能先销毁根结点，因为其左子树和右子树是通过根结点访问的，如果根结点先被销毁，则其左子树和右子树在后序程序中无法被访问，会出现错误。满二叉树：一个二叉树，如果其每一层的结点都达到最大值，即结点个数为2^k-1，k为二叉树层数，则该树为满二叉树。（n0为度为0的结点，n2为度为2的结点）
二叉树的基础操作
q496958148的博客
04-29 169
二叉树是基于递归思想建立的，所以我们对其做的操作大部分都得用递归思想。 二叉树的遍历 根据遍历来创建二叉树 二叉树的拷贝，销毁 二叉树的节点个数，层数，深度，第K层节点数… 二叉树查找元素，双亲，左右孩子
二叉树基本操作的实现
10-25
二叉树是一种非常重要的数据结构，它的基本操作包括创建、销毁、遍历、查找等。下面是二叉树基本操作的实现方法： 1. 创建二叉树：通过前序遍历的数组构建二叉树，其中 '#' 表示空节点。具体实现方法可以参考引用中的 BinaryTreeCreate 函数。 2. 销毁二叉树：遍历二叉树，依次释放每个节点的内存空间。具体实现方法可以参考引用中的 BinaryTreeDestory 函数。 3. 遍历二叉树：二叉树的遍历包括前序遍历、中序遍历、后序遍历和层序遍历。具体实现方法可以参考引用中的 BinaryTreePrevOrder、BinaryTreeInOrder、BinaryTreePostOrder 和 BinaryTreeLevelOrder 函数。 4. 查找二叉树节点：在二叉树中查找值为 x 的节点，具体实现方法可以参考引用中的 BinaryTreeFind 函数。 5. 计算二叉树节点个数：计算二叉树中节点的个数，具体实现方法可以参考引用[2]中的 BinaryTreeSize 函数。 6. 计算二叉树叶子节点个数：计算二叉树中叶子节点的个数，具体实现方法可以参考引用中的 BinaryTreeLeafSize 函数。 7. 计算二叉树第 k 层节点个数：计算二叉树中第 k 层节点的个数，具体实现方法可以参考引用中的 BinaryTreeLevelKSize 函数。 8. 判断二叉树是否是完全二叉树：判断二叉树是否是完全二叉树，具体实现方法可以参考引用中的 BinaryTreeComplete 函数。 9. 计算二叉树的深度：计算二叉树的深度，具体实现方法可以参考引用中的 BinaryTreeDeep 函数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值