数据结构：二叉树的递归实现

最新推荐文章于 2020-10-10 17:31:28 发布
最新推荐文章于 2020-10-10 17:31:28 发布
阅读量752 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 二叉树-c 递归 遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjx624bjh/article/details/78905493
版权

一，概念

二叉树就是一颗特殊的树，二叉树每个结点最多有两个孩子结点,即就是左孩子和右孩子。

接下来我们将以此树为例来进行分析！
这里写图片描述

表示

（1）数组表示
当二叉树的大小和形态不发生剧烈变化时，用一组连续的存储单元存储二叉树的数据元素，为反应各结点在二叉树中的位置及相互关系，须适当安排各结点的存储次序。
假若一个子结点的下标为i,那仫它的父节点的下标为:(i-1)/2;
假若一个父结点的下标为i，那仫它的左孩子的下标为:2*i+1,它的右孩子的下标为:2*i+2.
缺点：如果不是满二叉树和完全二叉树则有太多的内存浪费，且插入删除不便.
用数组表示一个树适用于满二叉树和完全二叉树.
（2）链式存储表示
在一棵树中进行插入和删除时，为反应结点层次的变动，可能需要移动许多节点，常用的是二叉链表，每一个结点至少包括数据data，左孩子leftchild和右孩子rightchild。

分类

（1）满二叉树：所有叶子节点在同一层，通俗点说就是每一层都是满的 （2）完全二叉树局：n-1层是满的
图示：
这里写图片描述

二，基本实现

（1）定义一个二叉树节点

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

（2）构造二叉树

BinaryTree()
        :_root(NULL)
    {}
    BinaryTree(T* a,size_t n,const T& invalid)
    {
        size_t index = 0;
        _root = CreateTree(a,n,invalid,index);
    }
    BinaryTree(const BinaryTree<T>& t)

    {
        _root = _Copy(t._root);
    }

    BinaryTree<T>& operator=(const BinaryTree<T> t)
    {
        if(this != %t)
        {
            swap(t._root,_root)
        }
    }

递归调用过程图：
这里写图片描述

（3）前序遍历
先访问根结点，再递归访问左子树，最后访问右子树

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

这里写图片描述

（4）中序遍历
先访问左子树，再访问根结点，最后访问右子树.

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

这里写图片描述

（5）后序遍历
先访问左子树，再访问右子树，最后访问根结点.

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

这里写图片描述

（6）层序遍历（广度优先遍历）
一层层结点依次遍历，在实现层序遍历的时候用到了队列先进先出的性质,将每一层的数据一次进队列，而每次出队列的元素就是层序遍历的当前元素.

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

            }
        }
    }

在这里用到了队列，先压入根节点，依据父节点出队列，子节点进队列原则，然后依次访问对头元素求得层序遍历顺序
k
（7）叶子节点个数
叶子节点(即没有左子树也没有右子树),左子树的叶子节点总数+右子树的叶子节点总数.

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

（8）第k层节点数

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

三，完整代码

using namespace std;
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(T* a,size_t n,const T& invalid)
    {
        size_t index = 0;
        _root = CreateTree(a,n,invalid,index);
    }
    BinaryTree(const BinaryTree<T>& t)

    {
        _root = _Copy(t._root);
    }

    BinaryTree<T>& operator=(const BinaryTree<T> t)
    {
        if(this != %t)
        {
            swap(t._root,_root)
        }
    }

    void PrevOrder()//前序遍历
    {
        return _PrevOrder(_root);
    }
    void InOrder()//中序遍历
    {
        return _InOrder(_root);
    }
    void PosOrder()//后续遍历
    {
        return _PosOrder(_root);
    }
    void LevelOrder()//层序遍历
    {
        return _LevelOrder(_root);
    }
    size_t Size()//大小
    {
        return _Size(_root);
    }
    Node* find(const T&x)//查找一个节点
    {
        return _find(_root,x);
    }
    size_t Depth()//求深度
    {
        return _Depth(_root);
    }
    size_t LeafSize()
    {
        return _LeafSize(_root);
    }
    size_t GetKLevel(size_t k)
    {
        return _GetKLevel(_root,k);
    }


protected:
    //成员函数
    Node* _find(Node* root,const T& x)
    {
        if(root==NULL)
        {
            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 _LeafSize(Node* root)
    {
        if(root==NULL)
        {
            return 0;
        }
        if(root->_left==NULL&&root->_right==NULL)
        {
            return 1;
        }
        size_t i = _LeafSize(root->_left);
        size_t j = _LeafSize(root->_right);
        return i+j;
    }
    size_t _GetKLevel(Node* root,size_t k)
    {
        if(root == NULL)
        {
            return 0;
        }
        if(k == 1)
        {
            return 1;
        }
        return _GetKLevel(root->_left,k-1)+(root->_right,k-1);
    }
    size_t _Size(Node* root)
    {
        if(root==NULL)
        {
            return 0 ;
        }
        size_t i =_Size(root->_left);
        size_t j =_Size(root->_right);
        return i+j+1;
    }
    void _LevelOrder (Node* root)
    {
        queue<Node*> q;
        if(root!=NULL)
        {
            q.push(root);
            while(!q.empty())
            {
                Node* front = q.front();
                cout<<front->_data<<" ";
                q.pop();
                if(front->_left)
                {
                    q.push(front->_left);
                }
                if(front->_right)
                {
                    q.push(front->_right);
                }

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

        }
    }

    //前序遍历
    void _PrevOrder(Node* root)
    {
        if(root==NULL)
        {
            return;
        }
        cout<<root->_data<<" ";
        _PrevOrder(root->_left);
        _PrevOrder(root->_right);
    }
    //中序遍历
    void _InOrder(Node* root)
    {
        if(root==NULL)
        {
            return;
        }
        _InOrder(root->_left);
        cout<<root->_data<<" ";
        _InOrder(root->_right);
    }
    //后序遍历
    void _PosOrder(Node* root)
    {
        if(root==NULL)
        {
            return;
        }
        _PosOrder(root->_left);
        _PosOrder(root->_right);
        cout<<root->_data<<" ";
    }
    Node* _Copy(Node* root)
    {
        if(root==NULL)
        {
            return NULL;
        }
        Node* newroot = new Node(root->_data);
        newroot->_left = _Copy(root->_left);
        newroot->_right = _Copy(root->_right);
        return newroot;
    } 
        //构建二叉树
    Node* CreateTree(T* a,size_t n,const T& invalid,size_t& index)
    {
        Node* root =NULL;
        if(index < n && a[index] != invalid)
        {
            root = new Node(a[index]);
            root ->_left = CreateTree(a,n,invalid,++index);
            root ->_right = CreateTree(a,n,invalid,++index);
        }
        return root;
    }

protected: 
    Node* _root; 
    size_t index;
    size_t invalid;
}; 
int main() 
{ 
int a1[10] = {1, 2, 3, '#', '#', 4, '#' , '#', 5, 6};
BinaryTree<int>t1(a1,sizeof(a1)/sizeof(a1[0]),'#');
//t1.PosOrder();
//cout<<endl;
//cout<<t1.Size()<<" ";
//cout<<t1.LeafSize();
//cout<<t1.GetKLevel(2);
t1.LevelOrder();
//cout<<(t1.find(3));
//cout<<t1.Depth();
return 0;
}
德卡拉
关注
专栏目录
二叉树的递归实现
rushing的博客
03-01 1037
递归实现二叉树 学习数据结构就不得不提到树这个概念，通常学习都是从简单的开始，所以我们也就先从最简单的入手，实现一棵简单的二叉树。并且分别实现前中后序的三种遍历。
【数据结构】二叉树的递归实现
天涯海角
09-28 493
二叉树的概念，这里就不想多说了，但是你需要知道满二叉树，完全二叉树等等这些基本 概念，下边进入正题。 首先创建一棵二叉树，下边看代码： Node* _Create(T* a, size_t size,size_t& index,const T& invalid) { assert(a); Node* root = NULL; while (index < size && a[i
c实现树（二叉树）的建立和遍历算法（一）（前序，中序，后序）
weixin_30344131的博客
01-25 128
最近学习树的概念，有关二叉树的实现算法记录下来。。。 不过学习之前要了解的预备知识：树的概念；二叉树的存储结构；二叉树的遍历方法。。 二叉树的存储结构主要了解二叉链表结构，也就是一个数据域，两个指针域，（分别为指向左右孩子的指针），从下面程序1，二叉树的存储结构可以看出。 二叉树的遍历方法：主要有前序遍历，中序遍历，后序遍历，层序遍历。（层序遍历下一篇再讲，本篇主...
数据结构-递归实现二叉树
草根学僧
02-17 617
二叉树： 在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2^{i-1}个结点；深度为k的二叉树至多有2^k-1个结点；对任何一棵二叉树T
数据结构-二叉树递归-非递归实现
04-26
数据结构实验二叉树用递归实现先序遍历、中序遍历和后序遍历，用几种不同非递归方法实现了中序遍历，代码附有详细注释
数据结构：二叉树（链式存储）
最新发布
12-07
以上就是关于“数据结构：二叉树（链式存储）”的主要内容，包括了二叉树的链式存储结构，递归创建二叉树的方法，以及三种遍历策略的实现。这些知识对于理解和操作二叉树至关重要，也是数据结构和算法学习中的基础...
数据结构二叉树遍历递归，非递归
12-12
二叉树作为一种重要的数据结构，在计算机科学中广泛应用于搜索、排序、树形表示等领域。...在学习过程中，可以尝试不同的数据结构和优化策略，如使用迭代而不是递归，或者实现自底向上的遍历方法。
数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。
07-01
数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。 数据结构实用教程之二叉树，其中包含了：二叉树的定义、二叉树的递归遍历、二叉树基本操作。 数据结构实用教程之二叉树，...
数据结构 二叉树的递归与非递归
09-15
总结来说，二叉树的递归与非递归遍历是数据结构中重要的操作。递归遍历简单直观，适用于小规模问题；非递归遍历则适用于处理大规模数据，避免了递归带来的栈空间限制。理解这两种方法并能灵活运用，对于理解和实现...
二叉树遍历（递归调用的算法）
12-04
用c语言所描述的二叉树遍历，实现了相应的功能，遍历后出现先序遍历和中序遍历
数据结构之二叉树的递归实现
微风
09-25 1206
二叉树的概念篇>  (1).二叉树是一颗特殊的树,二叉树每个结点最多有两个孩子结点,即就是左孩子和右孩子  (2).满二叉树：若一颗树的高度为h,则h层均满  (3).完全二叉树：若一棵树的高度为h,则前h-1层均满最后一层可以不满,且最后一层的结点都连续集中在最左边.     我们知道一个数组可以表示一颗树,它的思想是如果该处有结点则直接将该结点放在对应的下标处，如果没有结点则以符号占位
使用递归方式实现的二叉树
dc15822445347的专栏
11-27 443
/* * 文 件 名: Node.java * 修改时间: 2012-11-27 */ package tree; /** * 二叉树的节点 * @version [版本号, 2012-11-27] */ public class Node { int iData; double dData; Node leftChild; Node right
二叉树递归实现
_ACME_的博客
03-30 1168
二叉树递归实现比较符合树的特点，也较容易理解，代码也较为简单。接下来进行图文详解。 C代码下载 C++代码下载 java代码下载 ( 备用地址下载)导航 1.创建二叉树 2.前序遍历二叉树 3.中序遍历二叉树 4.后序遍历二叉树 5.层次遍历二叉树 6.计算二叉树深度 7.计算二叉树双分支节点数 8.计算二叉树单分支节点数 9.计算二叉树叶子节点数
数据结构--二叉树(递归实现)
一氧化二氢的执着
10-23 215
概述 二叉树是数据结构中十分重要的一类结构, 其中有很多应用. 二叉树的特点： 每个结点最多有两棵子树，即二叉树不存在度大于2的结点。 二叉树的子树有左右之分，其子树的次序不能颠倒。 二叉树根据存储的结构可分为链式存储和顺序存储, 本文只涉及链式存储, 顺序存储请参展作者上一篇文章:二叉树的顺序存储–堆 结构 typedef char BTDataType; typedef struct...
DataStructure----二叉树递归算法
qq_45699770的博客
10-10 253
#include <stdio.h> #include <stdlib.h> #define MAXSIZE 100; /*二叉树的数据结构定义*/ typedef struct BiTreeNode { char data; struct BiTreeNode *left; struct BiTreeNode *right; }BiTreeNode,*BiTree; /*二叉树的建立--按照先序方式建立--录入数据--插入*/ void CreateB
数据结构：二叉树的递归定义与遍历解析
"二叉树的递归定义是数据结构中的一个重要概念，特别是在南京理工的考研数据结构课程中。二叉树是由根节点、左子树和右子树这三个基本组成单元构成的非线性数据结构。在遍历二叉树时，目标是访问每个节点一次且仅...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值