二叉树的基本操作

最新推荐文章于 2022-10-15 16:22:21 发布
最新推荐文章于 2022-10-15 16:22:21 发布
阅读量295 收藏 2
点赞数 2
分类专栏： C++入门及项目实战宝典 数据结构和算法实战宝典 文章标签： 二叉树
这篇博客详细介绍了二叉树的特点，包括每个节点最多有两个子树以及有序性。接着，文章重点讲解了二叉树的基本操作，特别是递归方式下如何求解二叉树的节点个数。此外，还提供了前序、中序和后序遍历的递归算法图解，并给出了完整的非递归遍历的代码实现。
摘要由CSDN通过智能技术生成

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;//循环的子问题
            }
        }
    }
二叉树基本操作
m0_55250791的博客
08-07 645
无摘要
二叉树的基本操作（总结）
ParadiseHeaven的博客
11-21 1142
二叉树的基本操作 二叉树的定义决定了其大多数操作都可以由递归去实现 本文通过递归和非递归两种方式实现二叉树的基本操作（加深对原理的理解） 1.二叉树的声明   typedef char ElementType; typedef struct TreeNode* BinTree; struct TreeNode{ ElementType Data; struct Tre...
二叉树的基本操作(简单易懂)
weixin_30802171的博客
11-13 2292
二叉树基本操作 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 1249
层序遍历相对于前三种遍历，需要用队列进行辅助操作，具体操作：定义一个队列，首先将二叉树的第一个结点入队，while循环判断该队列是否为空，不为空的话，则先进行出队，然后判断该树的左又子树是否为空，不为空则入队。在销毁时，不能先销毁根结点，因为其左子树和右子树是通过根结点访问的，如果根结点先被销毁，则其左子树和右子树在后序程序中无法被访问，会出现错误。满二叉树：一个二叉树，如果其每一层的结点都达到最大值，即结点个数为2^k-1，k为二叉树层数，则该树为满二叉树。（n0为度为0的结点，n2为度为2的结点）
实验四 二叉树基本操作的实现
12-18
在本实验中，我们将深入探讨数据结构中的一个重要概念——二叉树，并实现其基本操作。二叉树是一种非线性的数据结构，它由一个有限集合的节点构成，每个节点最多有两个子节点，通常称为左子节点和右子节点。这个实验...
二叉树基本操作的程序实现.zip_二叉树的基本操作
09-21
这篇文档“二叉树基本操作的程序实现”涵盖了二叉树的一些核心概念和基本操作，旨在帮助初学者理解并实现这些概念。 二叉树由节点构成，每个节点最多有两个子节点，通常分为左子节点和右子节点。二叉树的主要类型有...
二叉树-基于C语言实现的二叉树基本操作.zip
最新发布
04-26
本压缩包包含的是基于C语言实现的二叉树基本操作，是学习和理解二叉树概念以及其实现的一个宝贵资源。 在C语言中，实现二叉树通常涉及定义一个结构体来表示节点，这个结构体至少包含两个指针，分别指向左右子节点，...
c语言版本二叉树基本操作示例(先序递归非递归)共10页.p
10-29
本文将深入探讨C语言实现的二叉树基本操作，包括递归和非递归两种方法，以及先序遍历的概念。在标题和描述中提及的“c语言版本二叉树基本操作示例(先序递归非递归)共10页”很可能是一个详细的教程或代码示例集合，...
二叉树及其基本操作
adorable_的博客
03-29 486
二叉树及其基本操作 概念 二叉树特点： •每个结点最多有两个子树，即二叉树不存在度大于2的结点 •二叉树的子树有左右之分，其子树的次序不能颠倒
二叉树基本操作（一）
lxt-st
08-20 500
目录 一、二叉树的概念 二、二叉树的分类 满二叉树 && 完全二叉树 三、二叉树的基本操作 1、二叉树的创建 2、二叉树的销毁 3、求二叉树的高度 4、求二叉树叶子结点的个数 5、求二叉树结点的个数 6、求二叉树第 K 层结点的个数 7、判断一个节点是否在一棵二叉树中 注：完整代码请至 Github 查看：https://github.com/...
C语言实现二叉树基本操作教程及代码
以下是基于C语言实现的二叉树基本操作的详细知识点： 1. 二叉树的定义 在C语言中，二叉树通常是通过结构体（struct）来定义的。一个基本的二叉树节点结构体可能包含数据部分和两个指向其子节点的指针。例如： ```c ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值