二叉树类模版及各种函数操作

最新推荐文章于 2023-10-17 19:02:12 发布
最新推荐文章于 2023-10-17 19:02:12 发布
阅读量287 收藏 3
点赞数 1
分类专栏： 编程 文章标签： c++ 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51802524/article/details/121182263
版权

有需要的小伙伴可以借鉴代码思路，但是不要copy～

main函数

随便调试的函数，大家根据需要自己调试函数哈～

#include "BiTree.cpp"
#include <iostream>
using namespace std;
#define NodesLength 27

int main(int argc, const char * argv[]) {
    
//    char preOrder[NodesLength] = {'A', 'B', 'D', 'C', 'E', 'F'};
//    char inOrder[NodesLength] = { 'D', 'B', 'A', 'E', 'C', 'F'};
//    BiTree<char> T(preOrder, inOrder, NodesLength);
//    T.PostOrder();
    BiTree<char> T;
    cout << T.GetNodesNumberOfKthLevle(3) << endl; 
    cout << T.GetLeafNodesNumberOfKthLevel(3);
    T.PrintNodesOfKthLevel(3);
    cout << endl;
    T.PrintLeafNodesOfKthLevel(3);
    
    
    return 0;
}

.h 文件

#ifndef BiTree_hpp
#define BiTree_hpp

#include <stdio.h>
#include <stdlib.h>
template <class ElemType>
struct BiNode{
    ElemType data;
    BiNode <ElemType> *lchild,*rchild;
};

template<class ElemType>
class BiTree{
private:
    BiNode<ElemType> *root;
    BiNode<ElemType> *Creat(BiNode<ElemType> *bt);
    void Release(BiNode<ElemType> *bt);
    void PreOrder(BiNode<ElemType> *bt);
    void InOrder(BiNode<ElemType> *bt);
    void PostOrder(BiNode<ElemType> *bt);
    void LevelOrder(BiNode<ElemType> *bt);
    int Depth(BiNode<ElemType> *bt);
    int Count(BiNode<ElemType> *bt);
    int CountLeaf(BiNode<ElemType> *bt);
    void PrintLeaf(BiNode<ElemType> *bt);
    int SmallestDepth(BiNode<ElemType> *bt);
    int IsCompleteBiTree(BiNode<ElemType> *bt);
    int IsCheck(BiNode<ElemType> *lchild , BiNode<ElemType> *rchild);
    int IsStructureSymmetric(BiNode<ElemType> *bt);
    int IsL_R_Check(BiNode<ElemType> *lchild, BiNode<ElemType> *rchild);
    //二叉树第k层的结点个数和叶子结点个数
    int GetNodesNumberOfKthLevle(BiNode<ElemType> *bt,int k);
    int GetLeafNodesNumberOfKthLevel(BiNode<ElemType> *bt,int k);
    //打印二叉树第k层的结点和叶子结点
    void PrintNodesOfKthLevel(BiNode<ElemType> *bt,int k);
    void PrintLeafNodesOfKthLevel(BiNode<ElemType> *bt,int k);
public:
    BiTree(){root = Creat(root);}
    ~BiTree(){
        Release(root);
    }
    void PreOrder(){
        PreOrder(root);
    }
    void InOrder(){
        InOrder(root);
    }
    void PostOrder(){
        PostOrder(root);
    }
    void LevelOrder(){
        LevelOrder(root);
    }
    int Depth(){
        return Depth(root);
    }
    int Count(){
        return Count(root);
    }
    int CountLeaf(){
        return CountLeaf(root);
    }
    void PrintLeaf(){
        PrintLeaf(root);
    }
    int SmallestDepth(){
        return SmallestDepth(root);
    }
    int IsCompletBiTree(){
        return IsCompleteBiTree(root);
    }
    int IsStructureSymmetric(){
        return IsStructureSymmetric(root);
    }
    int IsL_R_Check(){
        return IsL_R_Check(root->lchild, root->rchild);
    }
    //根据前序和中序序列构造二叉树  有参构造函数
    BiTree(ElemType *preOrder, ElemType *inOrder, int len) {
        root = Rebuild(preOrder, inOrder, len);
    }
    BiNode<ElemType>* Rebuild(ElemType *preOrder,ElemType *inOrder,int n);
    //二叉树第k层的结点个数和叶子结点个数
    int GetNodesNumberOfKthLevle(int k){
        return GetNodesNumberOfKthLevle(root, k);
    };
    int GetLeafNodesNumberOfKthLevel(int k){
        return GetLeafNodesNumberOfKthLevel(root, k);
    };
    //打印二叉树第k层的结点和叶子结点
    void PrintNodesOfKthLevel(int k){
        PrintNodesOfKthLevel(root, k);
    };
    void PrintLeafNodesOfKthLevel(int k){
        PrintLeafNodesOfKthLevel(root, k);
    };
};



#endif /* BiTree_hpp */

.m文件，因为我的不能设置成.m文件，只好用另一个cpp文件来代替了

#include "BiTree.hpp"
#include "CirQueue.cpp"
#include <iostream>
using namespace std;

//前序遍历
template <class Elemtype>
void BiTree<Elemtype>::PreOrder(BiNode<Elemtype> *bt){
    if (bt == NULL) {
        return;
    }
    else{
        cout << bt->data << " ";
        PreOrder(bt->lchild);
        PreOrder(bt->rchild);
    }
}
//中序遍历
template <class Elemtype>
void BiTree<Elemtype>::InOrder(BiNode<Elemtype> *bt){
    if(bt==NULL){
        return;
    }
    else{
        InOrder(bt->lchild);
        cout << bt->data << " ";
        InOrder(bt->rchild);
    }
}
//后序遍历
template <class ElemType>
void BiTree<ElemType>::PostOrder(BiNode<ElemType> *bt){
    if (bt == NULL) {
        return;
    }
    else{
        PostOrder(bt->lchild);
        PostOrder(bt->rchild);
        cout << bt->data << "";
    }
}
//层序遍历
template <class ElemType>
void BiTree<ElemType>::LevelOrder(BiNode<ElemType> *bt){
    const int MaxSize = 100;
    //采用顺序队列，假设不会发生溢出
    int front = 0, rear = 0;
    BiNode<ElemType> *Q[MaxSize],*q;
    if (bt == NULL) {
        return;
    }
    else{
        Q[rear++] = bt;                     //bt入队
        //队列非空时循环
        while (front!=rear) {
            q = Q[front++];                 //队头出队
            cout << q->data << " ";         //访问队头
            if (q->lchild != NULL) {        //如果队头有左孩子，则左孩子入队
                Q[rear++] = q->lchild;
            }
            if (q->rchild !=NULL) {         //如果队头有右孩子，则右孩子入队
                Q[rear++] = q->rchild;
            }
        }
    }
}
//构造函数
template <class ElemType>
BiNode<ElemType> *BiTree<ElemType>::Creat(BiNode<ElemType> *bt){
    ElemType ch;
//    cout << "请输入创建一棵二叉树的节点数据：" << endl;
    cin >> ch;
    if (ch == '*'){
        return NULL;
    }
    else{
        bt = new BiNode<ElemType>;
        bt->data = ch;
        bt->lchild = Creat(bt->lchild);
        bt->rchild = Creat(bt->rchild);
    }
    return bt;
}

//析构函数
template <class ElemType>
void BiTree<ElemType>::Release(BiNode<ElemType> *bt){
    if (bt != NULL) {
        Release(bt->lchild);
        Release(bt->rchild);
        delete bt;
    }
}

//求二叉树的深度
template <class ElemType>
int BiTree<ElemType>::Depth(BiNode<ElemType> *bt){
    if (bt == NULL) {
        return 0;
    }
    else{
        int dep1 = Depth(bt->lchild);
        int dep2 = Depth(bt->rchild);
        return (dep1>dep2)?(dep1+1):(dep2+1);
    }
}

//求二叉树的节点个数
int countNode = 0;
template <class ElemType>
int BiTree<ElemType>::Count(BiNode<ElemType> *bt){
    if (bt != NULL) {
        Count(bt->lchild);
        countNode++;
        Count(bt->rchild);
    }
    return countNode;
}


//求二叉树的叶子节点个数
int countLeaf = 0;
template <class ElemType>
int BiTree<ElemType>::CountLeaf(BiNode<ElemType> *bt){
    if (bt != NULL) {
        if (bt->lchild == NULL && bt->rchild == NULL) {
            
            countLeaf++;
        }
        CountLeaf(bt->lchild);
        CountLeaf(bt->rchild);
    }
    return countLeaf;
}

//输出二叉树的叶子结点
template<class ElemType>
void BiTree<ElemType>::PrintLeaf(BiNode<ElemType> *bt){
    if(bt != NULL){
        if (bt->lchild == NULL && bt->rchild == NULL) {
            cout << bt->data << " " ;
        }
        PrintLeaf(bt->lchild);
        PrintLeaf(bt->rchild);
    }
}
//求二叉树的最小深度
template <class ElemType>
int BiTree<ElemType>::SmallestDepth(BiNode<ElemType> *bt){
    if(bt == NULL)
        return 0;
    if(bt->lchild == NULL)
        return SmallestDepth(bt->rchild) + 1;
    if(bt->rchild == NULL)
        return SmallestDepth(bt->lchild) + 1;
    int m = SmallestDepth(bt->lchild) + 1;
    int n = SmallestDepth(bt->rchild) + 1;
    return m < n ? m:n;
}
//判断二叉树是否为完全二叉树
template <class ElemType>
int BiTree<ElemType>::IsCompleteBiTree(BiNode<ElemType> *bt){
    CirQueue<BiNode<ElemType> *> Q;
    BiNode<ElemType> *p;
    if(bt == NULL) return 1;
    Q.EnQueue(bt);
    //当出队的队头指针不为空时，将其左、右指针入队
    while ( (p = Q.DeQueue()) != NULL) {
        Q.EnQueue(p->lchild);
        Q.EnQueue(p->rchild);
    }
    //当遇到空指针时，判断队列中是否有非空指针
    //如果有，则不是完全二叉树，没有，则为完全二叉树
    while(!Q.Empty()){
        p = Q.DeQueue();
        if (p != NULL){
            return 0;
        }
    }
    return 1;
}
//判断二叉树左右子树是否结构对称
template <class ElemType>
int BiTree<ElemType>::IsCheck(BiNode<ElemType> *lchild, BiNode<ElemType> *rchild){
    if(lchild == NULL && rchild == NULL){
        return 1;
    }
    if(lchild == NULL || rchild == NULL){
        return 0;
    }
    return IsCheck(lchild->lchild, rchild->rchild) && IsCheck(lchild->rchild, rchild->lchild);
}
//判断二叉树是否结构对称
template <class ElemType>
int BiTree<ElemType>::IsStructureSymmetric(BiNode<ElemType> *bt){
    if(bt == NULL){
        return 1;
    }
    return IsCheck(bt->lchild,bt->rchild);
}
//判断二叉树是否对称
template <class ElemType>
int BiTree<ElemType>::IsL_R_Check(BiNode<ElemType> *lchild, BiNode<ElemType> *rchild){
    if(lchild == NULL && rchild == NULL){
        return 1;
    }
    if(lchild == NULL || rchild == NULL){
        return 0;
    }
    //此处与判断结构性对称不同
    if (lchild->data != rchild->data) {
        return  0;
    }
    return IsL_R_Check(lchild->lchild, rchild->rchild) && IsL_R_Check(lchild->rchild, rchild->lchild);
}
/*根据前序遍历和中序遍历重建二叉树*/
template <class ElemType>
BiNode<ElemType> * BiTree<ElemType>::Rebuild(ElemType *preOrder, ElemType *inOrder, int n){
    if (n == 0) {
        return NULL;
    }
    //获得前序遍历的第一个节点
    ElemType c = preOrder[0];
    //创建根节点
    BiNode<ElemType> *node = new BiNode<ElemType>;
    node->data = c;
    node->lchild = NULL;
    node->rchild = NULL;
    int i;
    //在中序遍历序列中寻找根节点的位置
    for (i = 0; i < n && inOrder[i] != c; i++) {
    }
    //左子树节点的个数
    int lenLeft = i;
    //右子树节点个数
    int lenRight = n - i - 1;
    //左子树不为空，递归重建左子树
    if (lenLeft > 0) {
        node->lchild = Rebuild(&preOrder[1], &inOrder[0], lenLeft);
    }
    //右子树不为空，递归重建右子树
    if (lenRight > 0) {
        node->rchild = Rebuild(&preOrder[lenLeft+1],&inOrder[lenLeft+1],lenRight);
    }
    return node;
}

//二叉树第k层的结点个数和叶子结点个数
template <class ElemType>
int BiTree<ElemType>::GetNodesNumberOfKthLevle(BiNode<ElemType> *bt, int k){
    if (bt == NULL || k < 1) {
        return 0;
    }
    if (k == 1) {
        return 1;
    }
    return GetNodesNumberOfKthLevle(bt->lchild, k - 1) + GetNodesNumberOfKthLevle(bt->rchild, k-1);
}

template <class ElemType>
int BiTree<ElemType>::GetLeafNodesNumberOfKthLevel(BiNode<ElemType> *bt, int k){
    if (bt == NULL || k < 1) {
        return 0;
    }
    else {
        if (k == 1) {
            if (bt->lchild == NULL && bt->rchild == NULL) return 1;
            else return 0;
        }
        else if(k > 1){
            return GetLeafNodesNumberOfKthLevel(bt->lchild, k-1) + GetLeafNodesNumberOfKthLevel(bt->rchild, k-1);
        }
    }
    return 1;
}

//打印二叉树第k层的结点和叶子结点
template <class ElemType>
void BiTree<ElemType>::PrintNodesOfKthLevel(BiNode<ElemType> *bt, int k){
    if (bt == NULL || k < 1) {
        return;
    }
    if(k == 1){
        cout << bt->data<<" ";
    }
    PrintNodesOfKthLevel(bt->lchild, k - 1);
    PrintNodesOfKthLevel(bt->rchild, k - 1);
}

template <class ElemType>
void BiTree<ElemType>::PrintLeafNodesOfKthLevel(BiNode<ElemType> *bt, int k){
    if (bt == NULL || k < 1) return ;
    if (bt != NULL ){
        if (k == 1){
            if(bt->lchild == NULL && bt->rchild == NULL)
                cout << bt->data<< " ";}
        else if (k > 1){
            PrintLeafNodesOfKthLevel(bt->lchild, k-1);
            PrintLeafNodesOfKthLevel(bt->rchild, k-1);
        }
    }
}

队列的类模版（部分）：

#ifndef CIRQUEUE_H
#define CIRQUEUE_H

const int QueueSize = 100; /*定义循环队列的容量*/
template <class ElemType> /*定义模板类CirQueue*/
class CirQueue{
public:
    CirQueue(); /*构造函数，循环队列的初始化*/
    void EnQueue(ElemType x); /*入队操作*/
    ElemType DeQueue(); /*出队操作*/
    int Empty(); /*判断队列是否为空，若为空返回1，否则返回0*/
private:
    ElemType data[QueueSize]; /*存放队列元素的数组*/
    int front, rear; /*队头，队尾指针*/
};
#endif

.cpp（.m）文件

#include <iostream>
using namespace std;
#include "CirQueue.hpp"

template <class ElemType>
CirQueue<ElemType>::CirQueue() {
    front = QueueSize-1;
    rear = QueueSize-1;
}

template <class ElemType>
void CirQueue<ElemType>::EnQueue(ElemType x) {
    if((rear + 1) % QueueSize == front)
        throw "循环队列已满，溢出！";
    rear = (rear + 1) % QueueSize;
    data[rear] = x;
}

template <class ElemType>
ElemType CirQueue<ElemType>::DeQueue() {
    if(rear == front)
        throw "循环队列为空！";
    front = (front + 1) % QueueSize;
    return data[front];
}

template <class ElemType>
int CirQueue<ElemType>::Empty() {
    if(front == rear)
        return 1;
    else
        return 0;
}

福气耶满满
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树模板 各种函数
12-17
二叉树的模板，可以实现二叉树的各种运算，数组存储
二叉树 常用函数 小结
阿拉修
12-15 2944
实现功能如下 insertLeft 左插 insertRight 右插 delLeft 左删 delRight 右删 preorder 前序遍历 inorder 中序遍历 postorder 后序遍历 levelOrder 层序遍历 traversal 遍历汇总 getHeight 树高 size 树的结点个数 movetree 将a树移到b树的左侧 preCreate 人机交互创建树 reverse 将树的结点翻转 BitreeNode 类代码如下： package tree; class BiTree
二叉树的基本操作及应用-数据结构类C语言
somewon的博客
11-09 1262
二叉树的‘#’输入、前中后序遍历、层次遍历（队列逻辑结构狗）、深度、结点个数、叶子节点个数、度为1/2的结点个数、交换左右孩子、复制二叉树、比较两个二叉树等操作。
数据结构--二叉树构造模板
m0_53252742的博客
11-27 3847
包含四个头文件，需要哪个函数直接抄上就可以的 头文件：binary_tree： #pragma once #pragma once #include<iostream> #include"lk_ queue.h" #include"lk_stack.h" #include"node.h" using namespace std; template <class ElemType> struct BinTreeNode { // 数据成员: ElemType data; .
算法22：二叉树各种算法——万能模板
街头小瘪三的专栏
02-23 370
二叉树算法的固定模板
二叉树模板
最新发布
心如冰清，天塌不惊
10-17 232
二叉树模板
用模板实现二叉树以及各种遍历
03-13
用c++的模板类来实现二叉树，其中包含前序遍历，中序遍历，后序遍历，以及层次遍历。用了递归和非递归2中方法
二叉树 模板代码.cpp
03-20
二叉树的C++模板代码，有很全面的函数，适合VC下使用
二叉树遍历问题 关于二叉树遍历问题的一些总结
07-05
二叉树遍历问题 ⼀、⼆叉树的重要性 很多经典算法如 回溯、⼴度优先遍历、分治、动态规划等通常需要转化为树的问题，⽽树的题⽬难免涉及到递归的问题，因此掌握树的三 种遍历框架是必须的。 　先序遍历：根，左，右 ...
二叉树C++源代码，模板实现，可用于各种类型
12-04
二叉树C++源代码，模板用得非常巧妙，可用于各种类型。
二叉树、线索二叉树类模版（C++）
11-21
二叉树模版：包括先序中序构造，后序中序构造，结点的度，统计度为n的结点个数，高度，宽度，结点的最大值，交换每个结点的左右，删除叶结点，是否完全二叉树，广度优先遍历，先序遍历，中序遍历，后序遍历； 线索二叉树：包括先序中序构造，中序线索化，中序线索化遍历； 包括测试主函数。
构建二叉树模板大全
hjxxxxx123491857的博客
08-30 710
有许多关于构建二叉树的题目，并且这些题目有固定的模板，我将对这类题目将进行分类总结。本篇致力于让读者能够融会贯通，抓住要领，建立模板化思维，看见一题想到一类。构造二叉树一般分为构造普通的二叉树，和构造二叉搜索树。构造二叉树我们学会一种思想，就是第一步先找当前根节点看哪一个数组能够明确确定根节点。第二步划分左区间，右区间。这里需要考察的是对vector的掌握，明确左开右闭，并且如何拷贝，如何resize。二叉搜索树的构建，也是先寻找当前根节点。只不过这里是对一个vector进行操作。......
《数据结构与算法分析 c语言描述》4章二叉树代码~模板
weixin_39075690的博客
06-03 391
书上的二叉查找树基本代码。用模板实现了。模板函数的声明和定义分别放在.h和.cpp文件中，编译时会报链接错误，只能在同时放在头文件中。至于为什么，没太搞清楚，代码如下：#pragma once #include &lt;iostream&gt; template &lt;typename T&gt; struct TREE_NODE{ T value; TREE_NODE* left; TR...
SDUT 二叉树（模板题）
qq_45830025的博客
10-14 238
I - 二叉树 Description 已知二叉树的一个按前序遍历输入的字符序列，如abc,de,g,f, (其中,表示空结点)。请建立二叉树，并输出建立二叉树的前序遍历序列、中序遍历序列、后序遍历序列、层次遍历序列、深度、叶子数。 Input 多组测试数据，对于每组测试数据，输入一个长度小于５０的按前序遍历输入的字符序列。 Output 对于每组测试数据，第1行输出其前序遍历序列、第2行输出其中序遍历序列、第3行输出其后序遍历序列、第4行输出其深度、第5行输出其叶子数。 Sample Input abc,
二叉树的常用操作函数
iQXQZX
12-14 567
二叉树的常用操作函数  未完待续。。。   /*包含二叉树常用操作函数*/ /*未完待续...*/ tree *creat(tree *root) // 以一个字符串为例 构建二叉树 { if (str[cnt] == ',') // 此字符串为全局 { cnt++; // 计数的全局变量 return NULL; } root...
二叉树常见函数实现方法
Cybenko
06-01 2105
 二叉树的最大深度给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。说明: 叶子节点是指没有子节点的节点。示例：给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7返回它的最大深度 3 。思路：利用递归深度遍历二叉树，一个树的最大深度等于左右子树最大深度+1/** * De...
树与二叉树的常用操作函数总结
weixin_34306446的博客
05-29 155
这里也常常用到一些栈与队列的操作函数，就不一一写了，栈与队列总结里会有这些操作；； #include <stdio.h> #include <stdlib.h> /*二叉树的链式结构*/ typedef int ElementType; typedef struct TNode *Position; typedef Position BinT...
实现二叉树操作的主函数
周波的个人博客
06-08 6190
/*BiTree.cpp*/#include "BiTree_Stack.h"#include "BiTree_Op.h"#include "extend.h"#include "BiTree_Queue.h"#include "BiTree_TaskStack.h"#include "BiTree.h"//功能菜单void Mnue_Create(){    cout    cout    co
二叉树基本操作-C语言实现
小铅笔
12-06 1339
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef struct BiTNode { int data; struct BiTNode *lchild, *rchild; } BiTNode, *BiTree; void CreatBiTree(BiTree &amp;T) { int e; s...
c++类模板二叉树顺序存储
05-12
在上面的代码中，SeqBinaryTree类模板包含了二叉树的一些基本操作，包括构造函数、判断是否为空、获取节点数目、获取根节点、获取父节点、获取左子节点、获取右子节点、插入节点、删除节点和打印二叉树。其中构造...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值