【数据结构】二叉树的实现（如：默认成员函数、（叶子）节点数、深度、四种遍历）

最新推荐文章于 2020-09-04 22:10:20 发布
最新推荐文章于 2020-09-04 22:10:20 发布
阅读量591 收藏 2
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hanjing_1995/article/details/51539584
版权

二叉树：树的每个节点最多有两个子节点。

我们看下它的结构，有二叉链表结构与三叉链表结构，具体结果如我摘自《C++Primer》中的图。

wKiom1cWG5WALqfAAABZJr6iA2I345.png

相比之下，三叉链表的优势在于当我们知道父亲节点要找他的子女节点比较方便和便捷，反之当我们知道子女节点找它的父亲节点时也方便。

下面，我实现下二叉链表的结构。

template <class T>
struct BinaryTreeNode
{
    BinaryTreeNode<T>* _left;    //左子树
    BinaryTreeNode<T>* _right;    //右子树
    T _data;
    
    BinaryTreeNode(const T& x)   
        :_left(NULL)
        , _right(NULL)
        , _data(x)
    {}
};


（1）求二叉树的叶子节点数leafsize:

叶子节点指的是，节点无子女节点。我们有两种思路：

1）设置一下全局变量或者静态变量的size，遍历二叉树，每次遇到一个节点就加加一次size

2)总叶子节点数就等于左子树叶子节点个数+右子树叶子节点个数


//思路1：
size_t _LeafSize(Node* root)
    {
        static int size = 0;
        if (root == NULL)
        { 
            return size;
        }
        if (root->_left == NULL && root->_right == NULL)
        {
            size++;
            return size;
        }    
        _LeafSize(root->_left);
        _LeafSize(root->_right);
    }
//思路2：
size_t _LeafSize(Node* root)
    {
        if (root == NULL)
        {
            return 0;
        }
        if (root->_left == NULL &&root->_right == NULL)
        {
            return 1;
        }
        return _LeafSize(root->_left) + _LeafSize(root->_right);
    }


（2）求二叉树的深度depth:

深度也称作为高度，就是左子树和右子树深度的较大值。

size_t _Depth(Node* root)
    {
        if (root == NULL)
        {
            return 0;
        }
        int LeftDepth = _Depth(root->_left);
        int RightDepth = _Depth(root->_right);
        return LeftDepth > RightDepth ? LeftDepth +1: RightDepth+1;
    }


（3）求二叉树的节点个数size:

总节点数就等于左子树节点个数+右子树节点个数+根节点个数1

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


（4）求第k层节点数：

默认根节点为第一层1。

思路与求叶子节点类似。

size_t _kLevelSize(Node* root, int k)//默认根节点为第1层
{
    assert(k > 0);
    if (root == NULL)
    {
        return 0;
    }
    if (k == 1)
    {
        return 1;
    }
    //不可以传参数k--,不然只能是执行完这一句代码后k才会发生变化，k一直为3
    //不可以传参数--k,执行root->_left时，k变为2，执行root->_right时为同一层k变为1
    //传参数k-1
    return _kLevelSize(root->_left, k - 1) + _kLevelSize(root->_right, k - 1);
}


（5）遍历二叉树：

注意：前中后序遍历要不要漏掉递归出口。

1）前序遍历：访问根节点->左子树->右子树

void _PrevOrder(Node* root)
    {
        if (root == NULL)
        {
            return;
        }
        cout << root->_data << "  ";
        _PrevOrder(root->_left);
        _PrevOrder(root->_right);
    }

2）中序遍历：访问左子树->根节点->右子树

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

3）后序遍历：访问左子树->右子树->根节点

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

4）层次遍历：

即一层一层地遍历结束，再遍历下一层节点，如int a1[10] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 }（注意：#表示空。）则层次遍历就应为：1，2，5，3，4，6。

wKiom1cWJczgZrjJAAAFiqFGDaU448.png

我们用队列解决该问题：首先先给队列无条件入队根节点，下面在出队根节点之前先入队它的子女节点2、5。此时，出队1后队头元素为2，在出队它之前入队它的根节点3，4……

void _LevelOrder(Node* root)
    {
        queue<Node*> q;
        if (root == NULL)
        {
            return;
        }
        q.push(root);
        while (!q.empty())
        {
            if (q.front()->_left != NULL)
            {
                q.push(q.front()->_left);

            }
            if (q.front()->_right != NULL)
            {
                q.push(q.front()->_right);

            }
            cout << q.front()->_data<< "  ";
            q.pop();
        }        
    }



我给出完整程序代码（测试用例我就不要在此处多加阐述了，你们可以自己实现）。

#define _CRT_SECURE_NO_WARNINGS 1
#ifndef __TREE_H__    //防止多次包含
#define __TREE_H__

#include<iostream>
using namespace std;
#include<assert.h>
#include<queue>
#include<stack>

template <class T>
struct BinaryTreeNode
{
    BinaryTreeNode<T>* _left;    //左子树
    BinaryTreeNode<T>* _right;    //右子树
    T _data;
    BinaryTreeNode(const T& x)
        :_left(NULL)
        , _right(NULL)
        , _data(x)
    {}
};

template<class T>
class BinaryTree
{
    typedef BinaryTreeNode<T> Node;    //重命名在于想简化代码，避免过长。
public:
    BinaryTree()
        :_root(NULL)
    {}

    BinaryTree(const T* a, size_t size, const T& invalid)
        :_root(NULL)
    {
        size_t index = 0;
        _root = _CreateTree(a, size, invalid, index);
    }
    
    BinaryTree<T>(const BinaryTree<T>& t)
        : _root(NULL)
    {
        _root = _Copy(t._root);
    }

    BinaryTree<T>& operator=(const BinaryTree<T>& t)
    {
        if (&t != this)
        {
            _Copy(t._root);
            _Destroy(_root);
        }
        return *this;
    }

    ~BinaryTree()
    {
        if (_root)
        {
            _Destroy(_root);
        }
    }

    //前序遍历
    void PreOrder()
    {
        _PrevOrder(_root);
        cout << endl;
    }
    
    //前序遍历非递归写法
    void PreOrderNon_R()
    {
        _PreOrderNon_R(_root);
        cout << endl;
    }

    //中序遍历
    void InOrder()
    {
        _InOrder(_root);
        cout << endl;
    }

    //中序遍历非递归写法
    void InOrderNon_R()
    {
        _InOrderNon_R(_root);
        cout << endl;
    }
    
    //后序遍历
    void PostOrder()
    {
        _PostOrder(_root);
        cout << endl;
    }
    
    //后序遍历非递归写法
    void PostOrderNon_R()
    {
        _PostOrderNon_R(_root);
        cout << endl;
    }
    
    //层次遍历
    void LevelOrder()
    {
        _LevelOrder(_root);
        cout << endl;
    }


    //节点数
    size_t Size()
    {
        return _Size(_root);
    }

    //深度（高度）
    size_t Depth()
    {
        return _Depth(_root);
    }

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

    //第k层节点
    size_t kLevelSize(int k)
    {
        return _kLevelSize(_root, k);
    }
    
protected:
    void _Destroy(Node* root)
    {
        if (root == NULL)
        {
            return;
        }
        if (root->_left == NULL && root->_right == NULL)
        {
            delete root;
            root = NULL;
            return;
        }
        _Destroy(root->_left);
        _Destroy(root->_right);
    }

    Node* _Copy(Node* troot)
    {
        if (troot == NULL)
        {
            return NULL;
        }

        Node* root = new Node(troot->_data);

        root->_left = _Copy(troot->_left);
        root->_right = _Copy(troot->_right);
        return root;
    }

    //方法1：
    /*size_t _LeafSize(Node* root)
    {
        static int size = 0;
        if (root == NULL)
        { 
            return size;
        }
        if (root->_left == NULL && root->_right == NULL)
        {
            size++;
            return size;
        }    
        _LeafSize(root->_left);
        _LeafSize(root->_right);
    }*/

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

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

    size_t _Depth(Node* root)
    {
        if (root == NULL)
        {
            return 0;
        }
        int LeftDepth = _Depth(root->_left);
        int RightDepth = _Depth(root->_right);
        return LeftDepth > RightDepth ? LeftDepth +1: RightDepth+1;
    }

    size_t _kLevelSize(Node* root,int k)//默认根节点为第1层
    {
        assert(k > 0);
        if (root == NULL)
        {
            return 0;
        }
        if (k == 1)
        {
            return 1;
        }
        //不可以传参数k--,不然只能是执行完这一句代码后k才会发生变化，k一直为3
        //不可以传参数--k,执行root->_left时，k变为2，执行root->_right时为同一层k变为1
        //传参数k-1
        return _kLevelSize(root->_left, k-1) + _kLevelSize(root->_right, k-1);
    }

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


    //前序遍历：访问根节点->左子树->右子树
    void _PrevOrder(Node* root)
    {
        if (root == NULL)
        {
            return;
        }
        cout << root->_data << "  ";
        _PrevOrder(root->_left);
        _PrevOrder(root->_right);
    }

    //前序遍历的非递归
    void _PrevOrderNon_R(Node* root)
    {
        stack<Node*> s;
        if (root == NULL)
        {
            return;
        }

        s.push(root);
        while (!s.empty())
        {
            root = s.top();
            cout << root->_data << "  ";
            s.pop();
            if (root->_right)
            {
                s.push(root->_right);
            }
            if (root->_left)
            {
                s.push(root->_left);
            }
        }
    }

    //中序遍历：访问左子树->根节点->右子树
    void _InOrder(Node* root)
    {
        if (root == NULL)
        {
            return;
        }
        _InOrder(root->_left);
        cout << root->_data << "  ";
        _InOrder(root->_right);
    }

    //中序遍历的非递归
    void _InOrderNon_R(Node* root)
    {
        if (root == NULL)
        {
            return;
        }
        stack<Node*> s;
        Node* cur = root;
        Node* tmp = root;
        while (cur || !s.empty())
        {
            while (cur)
            {
                tmp = cur;
                s.push(cur);                
                cur = cur->_left;
            }

            cur = s.top();//将栈顶元素保存，以便于后面判断它是否有右孩子
            cout << s.top()->_data << "  ";        
            s.pop();

            if (cur->_right == NULL)
            {
                cur = NULL;
            }
            else
            {
                cur = cur->_right;
            }
        }
    }

    //后序遍历：访问左子树->右子树->根节点
    void _PostOrder(Node* root)
    {
        if (root == NULL)
        {
            return;
        }
        _PostOrder(root->_left);
        _PostOrder(root->_right);
        cout << root->_data << "  ";
    }

    //后序遍历非递归
    void _PostOrderNon_R(Node* root)
    {
        if (root == NULL)
        {
            return;
        }
        Node* cur = root;
        Node* prev = NULL;
        stack<Node*> s;
        while (cur || !s.empty())
        {
            while (cur)
            {
                s.push(cur);                
                cur = cur->_left;                
            }
            cur = s.top();
            if (cur->_right == NULL ||cur->_right==prev )
            {
                cout << cur->_data << "  ";
                s.pop();
                prev = cur;
                cur = NULL;
            }
            else
            {
                cur = cur->_right;
            }
        }                
    }

    //层次遍历
    void _LevelOrder(Node* root)
    {
        queue<Node*> q;
        if (root == NULL)
        {
            return;
        }
        q.push(root);
        while (!q.empty())
        {
            if (q.front()->_left != NULL)
            {
                q.push(q.front()->_left);

            }
            if (q.front()->_right != NULL)
            {
                q.push(q.front()->_right);

            }
            cout << q.front()->_data<< "  ";
            q.pop();
        }        
    }
    
protected:
    Node* _root;
};

#endif    //__TREE_H__


本文出自 “Han Jing's Blog” 博客，请务必保留此出处http://10740184.blog.51cto.com/10730184/1765514

hanjing_1995
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构二叉树的遍历 二叉树的深度 二叉树的某结点层次 二叉树结点数
08-27
数据结构二叉树的遍历 二叉树的深度 二叉树的某结点层次 二叉树结点数
是不是二叉树？
drizzle2333的博客
03-29 1555
二叉树是每个节点最多有两个子树的层次结构，现要求实现函数，判断是否为二叉树 函数接口定义： int isTree(TreeNode Head); Head为要判断的树的头节点，返回1则代表为二叉树，返回0则代表不为二叉树 其中，TreeNode的结构如下 typedef int ElemType; typedef struct Node { ElemType data; struct Node *lchild, *rchild; } *TreeNode; 裁判测试程
二叉树
lanse_l的博客
07-10 256
二叉树 二叉树是每个结点最多有两个子树的树结构 顺序存储 顺序存储通常只考虑完全二叉树，下标与数组一样，从0开始 第n个节点的左子节点下标为 (2* n + 1) 第n个节点的右子节点下标为 (2* n + 2) 第n个节点的父节点下标为 (n-1) /2 可以看出顺序存储有很大的局限性，只有在存储完全二叉树的时候会比较实用，存储其他的二叉树，也要按照完全二叉树的形式来存储，会...
数据结构学习之二叉树（面试易考题整理）
ZP1015
06-23 7991
【摘要】计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。二叉树是递归定义的，因此，与二叉树有关的题目基本都可以用递归思想解决，当然有些题目非递归解法也应该掌握，如非递归遍历节点等等。本文努力对二叉树相关题目做一个较全的整理总结，希望对找工作的同学有所帮助。二叉树
二叉排序树 成员函数实现详解（C++）
Garen的博客
11-29 810
1 相关概念 1.1 定义 一棵空树，或者是具有下列性质的二叉树： 若左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若右子树不空，则右子树上所有结点的值均大于它的根结点的值； 左、右子树也分别为二叉排序树； 没有键值相等的结点。 1.2 性质 对二叉树进行中序遍历，可以得到一个递增的有序序列。 插入的新结点一定是某个叶子结点。 2 二叉排序树的实现 2.1 结点结构 stru...
【数据结构】二叉树的实现（如：默认成员函数、（叶子）节点数、深度、四种遍历）...
weixin_34021089的博客
04-19 141
二叉树：树的每个节点最多有两个子节点。我们看下它的结构，有二叉链表结构与三叉链表结构，具体结果如我摘自《C++Primer》中的图。相比之下，三叉链表的优势在于当我们知道父亲节点要找他的子女节点比较方便和便捷，反之当我们知道子女节点找它的父亲节点时也方便。下面，我实现下二叉链表的结构。template<classT> structBinaryTreeNode...
python数据结构：求二叉树节点个数
01-21
求二叉树节点个数 1.设计思想： 建立一棵二叉树，利用递归求二叉树节点个数 2.实现代码 class BinaryTreeNode(object): # 创建二叉树结点的函数 def __init__(self): self.data = '#' self.LChild = None self....
数据结构二叉树：从先序和中序遍历结果恢复二叉树
05-25
题目：从先序和中序遍历结果恢复二叉树。 分析：输入先序序列和中序序列，从而得到一个完整的二叉树。 步骤：1.找到root，前序遍历的第一节点G就是root。 2.继续观察前序遍历GDAFEMHZ，除了知道G是root，剩下的节点...
山东建筑大学计算机学院数据结构实验二：二叉树的遍历
03-31
3、实现统计二叉树叶子结点个数和计算二叉树深度的操作； 要求： 1、二叉链表结点类的定义； 2、二叉树类的定义； 3、创建一棵二叉树： 4、实现输出以上二叉树先序、中序和后序遍历序列中第k个数据元素的操作； 5、...
C语言数据结构实现二叉树的建立与遍历.cpp
04-18
C语言数据结构实现二叉树的建立与遍历.cpp
二叉树类的定义和成员函数的实现
09-12
本程序定义了二叉树和它的成员函数的实现，包过层序遍历和查找、删除等。
递归算法计算二叉树中叶子节点的数目
04-28
递归算法计算二叉树中叶子节点的数目
编写递归算法，计算二叉树中叶子结点的数目
01-25
编写递归算法，计算二叉树中叶子结点的数目
二叉树的创建及成员函数的实现
dream
04-20 5726
本文实现了二叉树的创建及其成员函数的实现 成员函数包括： 1)构造函数 2)拷贝构造函数 3)赋值运算符重载 4)先序遍历（先根遍历） 5)中序遍历 6)后序遍历（后根遍历） 7)层序遍历 8)节点个数 9)叶子节点个数 10)二叉树深度 二叉树的实现： #pragma once #include #include #include using namespac
C语言实现二叉树的四种遍历和求深度与叶子结点个数
酒醉浮生的博客
09-04 9061
C语言实现二叉树的四种遍历和求深度与叶子结点个数使用链式存储实现二叉树使用顺序队列实现二叉树的层序遍历功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 使用链式存储实现二叉树 定义存储数据类型和链式二叉树 //定义数据类型 ty
【数据结构】找出N个数据中最大的前k个数据（利用堆排序）
热门推荐
hanjing_1995的博客
05-30 1万+
我们举例，假若从10000万个数里选出前100个最大的数据。首先我们先分析：既然要选出前100个最大的数据，我们就建立一个大小为100的堆（建堆时就按找最大堆的规则建立，即每一个根节点都大于它的子女节点），然后再将后面的剩余数据若符合要求就插入堆中，不符合就直接丢弃该数据。那我们现在考虑：确定是该选择最大堆的数据结构还是最小堆的数据结构呢。分析一下：若选用最大堆的话，堆顶是堆的最大值，我们考虑既然
【数据结构】（面试题）使用两个栈实现一个队列(详细介绍)
hanjing_1995的博客
05-30 9036
使用两个栈实现一个队列思路一：我们设定s1是入栈的，s2是出栈的。入队列，直接压到s1即可出队列，先把s1中的元素倒入到s2中，弹出s2中的栈顶元素；再把s2的剩余元素全部倒回s1中。650) this.width=650;" src="http://s5.51cto.com/wyfs02/M01/7E/E7/wKioL1cMpjajUzcyAABT0frZ3KM694.png" title="N
【数据结构】堆的实现（包括：默认成员函数，插元素push,删元素pop,访问根节点top，判空，大小）
hanjing_1995的博客
05-30 3486
在数据结构里，堆是一类很重要的结构。堆结构是一组数组对象，我们可以把它当作是一颗完全二叉树。最大堆：堆里每一个父亲节点大于它的子女节点。最小堆：堆里每一个父亲节点小于它的子女节点。如图就是一个最大堆:650) this.width=650;" src="http://s1.51cto.com/wyfs02/M01/7F/59/wKioL1cbOTSjDiLRAAAZq4jMjWY012.png"
【数据结构】搜索二叉树的（递归与非递归）实现，包括：增Insert,删Remove,查Find
hanjing_1995的博客
06-03 2503
搜索二叉树，是二叉树一种特殊的结构。 特点： （1）每个节点都有一个关键码，并且关键码不重复。 （2）左子树上的每个节点的关键码都小于根节点的关键码。 （3）右子树上的每个节点的关键码都大于根节点的关键码。 （4）左右子树都是搜索二叉树。 下面，为方便大家理解，我举例画一个搜索二叉树，如下：
数据结构二叉树深度优先遍历
最新发布
01-29
二叉树的深度优先遍历是一种遍历二叉树的方法，它按照根节点、左子树、右子树的顺序进行遍历。深度优先遍历有三种方式：前序遍历、中序遍历和后序遍历。 1. 前序遍历（Preorder Traversal）：先访问根节点，然后...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值