二叉树

最新推荐文章于 2022-07-09 13:48:50 发布
最新推荐文章于 2022-07-09 13:48:50 发布
阅读量1k 收藏
点赞数
分类专栏： C++模板 数据结构与算法 C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zhx6044/article/details/8937607
版权 
/************************************************
*
*author:周翔
*e-mail:604487178@qq.com
*blog:http://blog.youkuaiyun.com/zhx6044
*
*
*************************************************/

#include "linkQueue.hpp"

#ifndef BINARYTREE_HPP
#define BINARYTREE_HPP

#include <iostream>

template <typename T>
class BinaryTree
{
public:
    BinaryTree();
    ~BinaryTree();
    bool isEmpty() const;
    void clear();
    int size() const;
    int height() const;
    void create(T stop);

    void preTraverse(std::ostream &os = std::cout) const;
    void midTraverse(std::ostream &os = std::cout) const;
    void postTraverse(std::ostream &os = std::cout) const;


private:
    struct node{
        T d;
        node* lc,*rc;
        node():lc(0),rc(0){

        }
        node(const T &t, node* _lc = 0, node* _rc = 0):
            d(t),
            lc(_lc),
            rc(_rc) {

        }
        ~node(){}
    };

    node *root;

    void clear(node *t) const;
    int size(node *t) const;
    int height(node *t) const;
    void preTraverse(node *t, std::ostream &os = std::cout) const;
    void midTraverse(node *t, std::ostream &os = std::cout) const;
    void postTraverse(node *t, std::ostream &os = std::cout) const;
};


template <typename T>
BinaryTree<T>::BinaryTree():
    root(0)
{

}

template <typename T>
BinaryTree<T>::~BinaryTree()
{
    if(!isEmpty()) {
        clear();
    }

}


template <typename T>
bool BinaryTree<T>::isEmpty() const
{
    return root == 0;
}

template <typename T>
void BinaryTree<T>::clear(node *t) const
{
    if (t->lc != 0) {
        clear(t->lc);
    }
    if (t->rc != 0) {
        clear(t->rc);
    }
    delete t;
}

template <typename T>
int BinaryTree<T>::size(node *t) const
{
    if (t == 0) return 0;
    return 1 + size(t->lc) + size(t->rc);

}

template <typename T>
int BinaryTree<T>::height(node *t) const
{
    if (t == 0) return 0;
    int i = height(t->lc);
    int j = height(t->rc);
    //高度为来个子树中高度较大的加一
    return 1 + ( i > j ? i : j );
}

template <typename T>
void BinaryTree<T>::clear()
{
    clear(root);
}

template <typename T>
int BinaryTree<T>::size() const
{
    return size(root);
}

template <typename T>
int BinaryTree<T>::height() const
{
    return height(root);
}

template <typename T>
void BinaryTree<T>::preTraverse(node *t, std::ostream &os) const
{
    if (t != 0) {
        os << t->d << "   ";
        preTraverse(t->lc);
        preTraverse(t->rc);
    }

}

template <typename T>
void BinaryTree<T>::midTraverse(node *t, std::ostream &os) const
{
    if (t != 0) {
        midTraverse(t->lc);
        os << t->d << "  ";
        midTraverse(t->rc);
    }

}

template <typename T>
void BinaryTree<T>::postTraverse(node *t, std::ostream &os) const
{
    if (t != 0) {
        postTraverse(t->lc);
        postTraverse(t->rc);
        os << t->d << "   ";
    }


}

template <typename T>
void BinaryTree<T>::preTraverse(std::ostream &os) const
{
    if (!isEmpty()) {
        preTraverse(root,os);
    }
}

template <typename T>
void BinaryTree<T>::midTraverse(std::ostream &os) const
{
    if (!isEmpty()) {
        midTraverse(root,os);
    }
}

template <typename T>
void BinaryTree<T>::postTraverse(std::ostream &os) const
{
    if (!isEmpty()) {
        postTraverse(root,os);
    }
}

template <typename T>
/**
 * @brief BinaryTree<T>::create 从上到下按层创建
 * @param stop 结束符
 */
void BinaryTree<T>::create(T stop)
{
    LinkQueue<node*> queue;
    T x,l,r;
    node* t;
    std::cout << "输入根节点:\n";
    std::cin >> x;
    root = new node(x);
    queue.enqueue(root);
    while (!queue.isEmpty()) {
        t = queue.dequeue();
        std::cout << "输入" << "节点" << t->d << "的两个孩子，没有则输入" << stop << '\n';
        std::cin >> l >> r;
        if (l != stop) queue.enqueue(t->lc = new node(l));
        if (r != stop) queue.enqueue(t->rc = new node(r));
    }

}


#endif // BINARYTREE_HPP

之后撸的加上

template <typename T>
void BinaryTree<T>::preTraverse2(std::ostream &os) const
{
    if (isEmpty()) {
        os << "这是一颗空树！\n";
    } else {
        LinkStack<node*> stack;
        stack.push(root);
        while(!stack.isEmpty()) {
            node *t = stack.pop();
            os << t->d << "  ";
            //先压右子树再压左子树，这样左子树在上可以先遍历
            if (t->rc != 0)  stack.push(t->rc);
            if (t->lc != 0)  stack.push(t->lc);
        }
    }
}

template <typename T>
/**
 * @brief BinaryTree<T>::midTraverse2
 * @param os
 *
 *
 *
 * 根节点第一次出栈，然后进栈，左子树进栈，然后遍历左子树，根节点第二次出栈，右子树进栈
 *
 */
void BinaryTree<T>::midTraverse2(std::ostream &os) const
{
    if (isEmpty()) {
        os << "这是一颗空树！\n";
    } else {
        LinkStack<elemt> stack;
        stack.push(elemt(root));
        while(!stack.isEmpty()) {
            elemt t = stack.pop();
            if (++t.step == 2) {
                os << t.n->d << "   ";
                if (t.n->rc != 0) {
                    stack.push(elemt(t.n->rc));
                }
            } else {
                stack.push(t);
                if(t.n->lc != 0) {
                    stack.push(t.n->lc);
                }
            }
        }

    }

}


template <typename T>
/**
 * @brief BinaryTree<T>::postTraverse2
 * @param os
 *
 *
 *
 * 根节点第一次出栈进栈，左子树进栈，第二次进栈出栈，右子树进栈，第三次出栈
 */
void BinaryTree<T>::postTraverse2(std::ostream &os) const
{
    if (isEmpty()) {
        os << "这是一颗空树！\n";
    } else {
        LinkStack<elemt> stack;
        stack.push(elemt(root));
        while(!stack.isEmpty()) {
            elemt t = stack.pop();
            if (++t.step == 3) {
                os << t.n->d << "   ";
            } else {
                if (t.step == 2) {
                    stack.push(t);
                    if(t.n->rc != 0) {
                        stack.push(t.n->rc);
                    }
                } else {
                    stack.push(t);
                    if(t.n->lc != 0) {
                        stack.push(t.n->lc);
                    }
                }

            }
        }
    }
}


template <typename T>
/**
 * @brief BinaryTree<T>::changeChildrens 交换子节点，使用一个队列完成
 */
void BinaryTree<T>::changeChildrens()
{
    LinkQueue<node*> queue;
    queue.enqueue(root);
    while(!queue.isEmpty()) {
        node *t = queue.dequeue();
        if (t != NULL) {
            queue.enqueue(t->lc);
            queue.enqueue(t->rc);//将两个字节点入队
            node *t2 = t->lc;//交换子节点
            t->lc = t->rc;
            t->rc = t2;
        }
    }
}


template <typename T>
void BinaryTree<T>::levelTraverse(std::ostream &os) const
{
    LinkQueue<node*> queue;
    queue.enqueue(root);
    while(!queue.isEmpty()) {
        node *t = queue.dequeue();
        if (t != NULL) {
            os << t->d << "  ";
            queue.enqueue(t->lc);
            queue.enqueue(t->rc);
        }
    }
}

template <typename T>
int BinaryTree<T>::degreeTwo() const
{
    int re = 0;
    if (isEmpty()) {
    } else {
        LinkQueue<node*> queue;
        queue.enqueue(root);
        while(!queue.isEmpty()) {
            node *t = queue.dequeue();
            if (t->lc != NULL) {
                queue.enqueue(t->lc);
                if (t->rc != NULL) {
                    queue.enqueue(t->rc);
                    ++re;
                }
            } else {
                if (t->rc != NULL) {
                    queue.enqueue(t->rc);
                }
            }
        }
    }
    return re;
}

template <typename T>
/**
 * @brief BinaryTree<T>::completeBT 将树作为完全二叉树考虑构件，最后看结论是否矛盾（反证法）
 * @return
 */
bool  BinaryTree<T>::completeBT() const
{
    LinkQueue<elemt> queue;
    elemt t,tc;
    int c = 1;//节点的个数
    int l = 1;//最后节点编号
    //root编号为1，根据性质5，如果是完全二叉树则节点个数等于最后节点的编号
    if (isEmpty()) return true;//空树是完全二叉树
    t.n = root;
    t.step = 1;
    queue.enqueue(t);
    while (!queue.isEmpty()) {
        t = queue.dequeue();
        if (t.n->lc != NULL) {
            ++c;
            tc.n = t.n->lc;
            l = tc.step = t.step * 2;//完全二叉树性质5
            queue.enqueue(tc);
        }
        if (t.n->rc != NULL) {
            ++c;
            tc.n = t.n->rc;
            l = tc.step = t.step * 2 + 1;
            queue.enqueue(tc);
        }

    }
    return c == l;
}

template <typename T>
/**
 * @brief BinaryTree<T>::isEqual
 * @param t1
 * @param t2
 * @return
 *
 *
 *写递归主要是找出递归出口，这个有三个出口，值不同和形状不同，和都是空节点
 */
bool BinaryTree<T>::isEqual(BinaryTree::node *t1, BinaryTree::node *t2)
{
    //形状，值相同，最后如果相同是以形状出口
    if (t1 == NULL && t2 == NULL) return true;
    if (t1 == NULL || t2 == NULL) return false;
    //值不同，直接出口
    if (t1->d != t2->d) return false;
    //值相同，再看形状，可以是值出口和形状出口
    return isEqual(t1->lc, t2->lc) && isEqual(t1->rc, t2->rc);

}

template <typename T>
bool operator == (const BinaryTree<T> &bt1, const BinaryTree<T> &bt2)
{
    return BinaryTree<T>::isEqual(bt1.root,bt2.root);
}


template <typename T>
/**
 * @brief BinaryTree<T>::mirror 树是镜像的吗，左右子树对称
 * @return
 */
bool BinaryTree<T>::mirror() const
{
    if (isEmpty()) return false;
    return isMirror(root->lc,root->rc);
}

template <typename T>
bool BinaryTree<T>::isMirror(BinaryTree::node *t1, BinaryTree::node *t2)
{
    if (t1 == NULL && t2 == NULL) return true;
    if (t1 == NULL || t2 == NULL) return false;
    if (t1->d != t2->d) return false;

    return isMirror(t1->lc, t2->rc) && isMirror(t1->rc, t2->lc);
}


自己动手写数据结构：二叉树BinaryTree类模板C++实现（功能较全）
jobsxiao的专栏
08-09 3990
#ifndef MYBINARYTREE_H #define MYBINARYTREE_H template class BinaryTree { protected: struct TNode { T val; TNode* parent; TNode* left; TNode* right; TNode(T t, TNode* p = 0, TNode* l = 0
数据结构实验2(二叉链表实现二叉树的基本运算)
GKHack's Blog
12-13 4365
包含的二叉树运算: 删除一个二叉树, 求一颗二叉树的高度, 求一颗二叉树中叶子结点数, 复制一颗二叉树, 交换一颗二叉树的左右子树, 自上到下, 自左到右层次遍历一颗二叉树. 增加相关功能完善即可, 层次遍历利用队列作为辅助的数据结构, 元素类型是指向二叉树中结点的指针类型. 实现代码: #include "iostream" #include "cstdio" #include "cst
C++模板实现二叉树基本操作
starzyh的博客
05-16 1009
#ifndef BINARYTREE_H #define BINARYTREE_H #include <iostream> #include <stack> #include <queue> using namespace std; template <typename T> struct btNode { T _data; s...
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 36万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
python二叉树
惊鸿的博客
03-12 5957
二叉树特征定义 特征 树是一种 非线性的数据结构，，直观的看，他是数据元素（在树中称为结点）按分支关系组织起来的结构，很像自然界中的树那样，树结构在客观世界中广泛存在，如人类社会的族谱和各种社会组织机构都可以用树形象来表示。还有比如在编译程序的时候，它可以用来表示源程序的语法结构，又或者在数据库中，树型结构也是信息的重要组织形式之一。 总之：一切具有层次关系的问题都可以用树来描述。 定义 树（Tree）是n（≥0）个节点的有限集。在任意一棵树中： 1、有且仅有一个称为根（Root）的结点 2、当n&g
二叉树详解
weixin_59371851的博客
07-09 5万+
目录前言一、树的概念和结构1、树的概念2、树的表示 3、树在实际中的应用（表示文件系统的目录树结构）二、二叉树概念及结构1.概念 2、特殊的二叉树3、二叉树的性质4、二叉树的存储4.1顺序存储4.2链状存储 三、二叉树的顺序结构和实现1、二叉树的顺序结构2、堆的概念及结构3、堆的实现3.1堆的代码框架3.2堆的插入3.3堆的删除3.4堆的建立 3.5建堆的时间复杂度 4、堆的应用4.1堆排序 4.2TOP-K问题四、二叉树链式结构的实现 1、建二叉树2、二叉树的遍历2.1前序、中序以及后序遍历2.2层序遍历
二叉树的基本操作
Daioo 随笔
04-21 12万+
一、实验目的 1、掌握二叉树的定义； 2、掌握二叉树的基本操作，如二叉树的建立、遍历、结点个数统计、树的深度计算等。 二、实验内容 （一）用递归的方法实现以下算法： 1、以二叉链表表示二叉树，建立一棵二叉树（算法5.3）； 2、输出二叉树的中序遍历结果（算法5.1）； 3、输出二叉树的前序遍历结果（见讲稿）； 4、输出二叉树的后序遍历结果（见讲稿）； 5、计算二叉树的深度（算法5.
二叉树建立
Monster
03-20 3万+
结束二叉树输入：如何结束创建二叉树的输入那；把二叉树补全 前序（输入）：AB##C## 中序：#B#A#C# 后序：##B##CA 输出结果如下： 代码如下 #include<iostream> using namespace std; //定义节点 typedef struct node { struct node *left; struct node *...
【数据结构】——二叉树详解
atwdy的博客
07-28 6万+
二叉树(Binary Tree)是由n个结点构成的有限集(n≥0)，n=0时为空树，n>0时为非空树。对于非空树TTT有且仅有一个根结点；除根结点外的其余结点又可分为两个不相交的子集TLT_LTL​和TRT_RTR​，分别称为TTT的左子树和右子树，且TLT_LTL​和TRT_RTR​本身又都是二叉树。很明显该定义属于递归定义，所以有关二叉树的操作使用递归往往更容易理解和实现。从定义也可以看出二叉树与一般树的区别主要是两点，一是每个结点的度最多为2；
将满二叉树转化为求和二叉树_二叉树_
09-30
在IT领域，特别是数据结构和算法的学习中，二叉树是一种重要的抽象数据类型。满二叉树是一种特殊的二叉树，其中每一层都是完全填充的，除了可能的最后一层，且最后一层的所有节点都尽可能地向左靠拢。而将满二叉树...
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
二叉树模拟器.py二叉树模拟器.py
最新发布
07-24
二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py...
易语言二叉树遍历
07-21
在易语言中，处理数据结构如二叉树是一项常见的任务，特别是在处理递归和树形结构的数据时。二叉树遍历是理解数据结构和算法的基础，它包括前序遍历、中序遍历和后序遍历三种主要方法。 1. **二叉树的基本概念**： ...
qwt学习一
周翔的专栏
06-18 2万+
学习这个东西方向对了，就对了一半 今天我开始学习基于qt库的一个开源的绘制2维的统计图的库--qwt。 我们画东西首先要有一个容器，不然都是徒劳，今天我们就介绍这个类--QwtPlot 它继承自QFrame和QwtPlotDict，QFrame提供一个QWidget的框架，QwtPlotDict为QwtPlot管理在其中的plot items，就是绘制的项。在QwtPlot上我们可以绘制无限
CC2530+74HC164矩阵键盘的设计
周翔的专栏
05-07 1万+
最近个大网盘都发出通知，用户的数据将会被清楚，其中就有金山快盘，上大学的时候用的金山，很多重要的资料在其中都保存了一份。现在将其全部下载了下来，然后发现了我的毕业论文，看了一遍，就有了这系类文章。今天将矩阵键盘的设计和编程。 背景我的毕业设计是基于ZigBee网络的一个hub系统，协调器节点作为中枢，控制器和被控制器都连接在这个中枢上。控制器上使用矩阵键盘那就很平常了。CC2530的端口数比较小，这
基于C++11的事件驱动框架
周翔的专栏
04-06 1万+
闲来无事，系统捣鼓C++。之前在signal-slot中提到事件循环，不过那个实在写的太挫。现在写了一个说的过去的。项目地址： https://github.com/ZhouBox/moos.git下面简单的说明下。 task完成实现对事件循环的一个任务的封装。 task_policy实现了各种task的策略。 task_queue是事件队列 looper是一个事件循环。 moos_
Qt HTTP请求同步调用
周翔的专栏
03-24 1万+
在Qt中，进行HTTP就行现在官方提倡使用QNetworkAccessManager，其和QNetworkRequest和QNetworkReply配合使用，来完成，其是只支持异步的操作。最近使用QML做些android的小程序，需要进行HTTPS的操作，开始是使用的JS中的XMLHttpRequest，其不能使用HTTPS，我很郁闷，那只有使用C++来完成，但是又发现只支持异步，但是我希望在进行网
基于TCP协议的视频传输
周翔的专栏
10-12 1万+
这个程序是为了大二上学期一个设计作业，写的
C语言二叉树性质详解
C语言公共基础部分之二叉树性质 根据给定的文件信息，我们可以总结出以下知识点： 1. 二叉树的定义：二叉树是树形结构的一个重要类型，由n个结点的有限集组成，或者是空集，或者由一个根结点及两棵互不相交的、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值