二叉树

最新推荐文章于 2019-05-16 21:29:14 发布
最新推荐文章于 2019-05-16 21:29:14 发布
阅读量994 收藏
点赞数
分类专栏： C++模板 数据结构与算法 C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhx6044/article/details/8937607
版权 
/************************************************
*
*author:周翔
*e-mail:604487178@qq.com
*blog:http://blog.csdn.net/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);
}


写了程序换酒钱
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自己动手写数据结构：二叉树BinaryTree类模板C++实现（功能较全）
jobsxiao的专栏
08-09 3912
#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 4303
包含的二叉树运算: 删除一个二叉树, 求一颗二叉树的高度, 求一颗二叉树中叶子结点数, 复制一颗二叉树, 交换一颗二叉树的左右子树, 自上到下, 自左到右层次遍历一颗二叉树. 增加相关功能完善即可, 层次遍历利用队列作为辅助的数据结构, 元素类型是指向二叉树中结点的指针类型. 实现代码: #include "iostream" #include "cstdio" #include "cst
C++模板实现二叉树基本操作
starzyh的博客
05-16 958
#ifndef BINARYTREE_H #define BINARYTREE_H #include <iostream> #include <stack> #include <queue> using namespace std; template <typename T> struct btNode { T _data; s...
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
二叉树 基础
03-08
在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的每个结点至多只有二棵子树...
将满二叉树转化为求和二叉树_二叉树_
09-30
在IT领域，特别是数据结构和算法的学习中，二叉树是一种重要的抽象数据类型。满二叉树是一种特殊的二叉树，其中每一层都是完全填充的，除了可能的最后一层，且最后一层的所有节点都尽可能地向左靠拢。而将满二叉树...
平衡二叉树
03-03
平衡二叉树Java实现，平衡二叉树Java实现，平衡二叉树Java实现，平衡二叉树Java实现，
线索二叉树
04-10
通过前序序列创建线索二叉树 1:中序遍历 2:查找节点前驱后继 3:插入节点 4:删除节点 0:退出
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万+
这个程序是为了大二上学期一个设计作业，写的
Android添加一个Native Service
周翔的专栏
08-07 8300
Native Service其实就是一个linux守护进程，提供一些服务，不过由于android的进程间通讯使用了Binder机制，那么我们就需要按照android的规则来实现我们的Native Service。客户端在请求service的服务时使用了一个具有相同接口的Proxy类。native service这具体实现这个接口，所以android提供了IInterface类，其是”base cla
C++中实现自动注册的工厂
周翔的专栏
01-23 7399
很长时间没有跟新博客了，不是博主懒，是因为博主再帮研究生妹子弄硕士论文，定位方面的，被imu，行人航迹，激光匹配各种虐，不说了，都是泪。Factory模式，在工程中多用了创建派生类实例，内部一般使用switch-case根据不同的key去创建不同的派生类对象。switch(Key) { case A: return new A; case Bw: r
QTabWidget+QToolBar实现浏览器标签页
周翔的专栏
07-11 7253
直接上代码 /******************************************************************** * author 周翔 * e-mail 604487178@qq.com * blog http://blog.csdn.net/zhx6044 *************************************************
C++怎么判断一个类存在指定的函数名的函数
周翔的专栏
08-05 7231
C++怎么获得一个类存在指定的函数名的函数怎么在编译期获得一个类是否存在指定函数名的函数？#define HAS_MEMBER(member)\ template<typename T, typename... Args>struct has_member_##member\ {\ private:\ template<typename U> static auto Check(in
二叉树详解与应用
"二叉树学习PPT涵盖了关于树和二叉树的全面知识，包括定义、术语、遍历算法、线索化二叉树、树与森林的转换、哈夫曼树及其编码计算等核心概念。" 二叉树是树形数据结构的一种特殊类型，具有以下关键知识点： 1. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值