c++二叉树的各种操作

最新推荐文章于 2024-05-15 22:49:24 发布
最新推荐文章于 2024-05-15 22:49:24 发布
阅读量1.2k 收藏 7
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012967763/article/details/51898281
版权

头文件

#ifndef _BINARYTREE_H_
#define _BINARYTREE_H_

const int MaxSize = 100;

template<class T>
struct BTNode
{
    T data;
    BTNode<T> *lchild;
    BTNode<T> *rchild;
};

template<class T>
class BinaryTree
{
public:
    BinaryTree();                   //构造函数
    ~BinaryTree();                  //析构函数
    void PreOrder(){PreOrder(r);}   //递归前序遍历
    void InOrder(){InOrder(r);}     //递归中序遍历
    void PostOrder(){PostOrder1(r);} //递归后序遍历
    void PreOrder1(){PreOrder1(r);}   //非递归前序遍历
    void InOrder1(){InOrder1(r);}     //非递归中序遍历
    void PostOrder1(){PostOrder(r);} //非递归后序遍历
    void LevelOrder(){LevelOrder(r);}//层序遍历
    BTNode<T>* FindNode(T x){FindNode(r,x);}//查找结点
    int BTNodeHeigth(){BTNodeHeigth(r);}//树的高度
    int NodeCount1(){NodeCount1(r);}    //基于前序遍历求结点个数
    int NodeCount2(){NodeCount2(r);}    //基于中序遍历求结点个数
    int NodeCount3(){NodeCount3(r);}    //基于后序遍历求结点个数
    int NodeCount4(){NodeCount4(r);}    //递归求结点个数
    void DispLeaf(){DispLeaf(r);}       //输出树的叶子结点
    void printRouteLength(){printLeavesDepth(r, 0);}//输出树的叶子结点到根结点的路径长度
    bool printAncestor(T x){printAncestor(r,x);}    //输出值为x的结点的祖先结点
private:
    BTNode<T> *r;
    BTNode<T>* CreateTree(BTNode<T> *t);//构造函数调用
    void DestroyTree(BTNode<T> *t);     //析构函数调用
    void PreOrder(BTNode<T> *t);        //递归前序遍历调用
    void InOrder(BTNode<T> *t);         //递归中序遍历调用
    void PostOrder(BTNode<T> *t);       //递归后序遍历调用
    void PreOrder1(BTNode<T> *t);        //非递归前序遍历调用
    void InOrder1(BTNode<T> *t);         //非递归中序遍历调用
    void PostOrder1(BTNode<T> *t);       //非递归后序遍历调用
    void LevelOrder(BTNode<T> *t);       //层序遍历调用
    BTNode<T>* FindNode(BTNode<T> *t, T x);
    int BTNodeHeigth(BTNode<T> *t);
    int NodeCount1(BTNode<T> *t);       //前序遍历求结点个数调用
    int NodeCount2(BTNode<T> *t);       //中序遍历求结点个数调用
    int NodeCount3(BTNode<T> *t);       //后序遍历求结点个数调用
    int NodeCount4(BTNode<T> *t);       //递归求结点个数调用
    void DispLeaf(BTNode<T> *t);
    void printLeavesDepth(BTNode<T> *t,int depth);
    bool printAncestor(BTNode<T> *t,T x);
};
//
template<class T>
BinaryTree<T>::BinaryTree()
{
    r = CreateTree(r);
}
//
template<class T>
BinaryTree<T>::~BinaryTree()
{
    DestroyTree(r);
}
//
template<class T>
void BinaryTree<T>::DestroyTree(BTNode<T> *t)
{
    if(t != NULL)
    {
        DestroyTree(t->lchild);
        DestroyTree(t->rchild);
        delete t;
    }
}
//
template<class T>
BTNode<T>* BinaryTree<T>::CreateTree(BTNode<T> *t)
{
    T ch;
    std::cin>>ch;
    if(ch == '#')
    {
        t = NULL;
    }
    else
    {
        t = new BTNode<T>;
        t->data = ch;
        t->lchild = CreateTree(t->lchild);
        t->rchild = CreateTree(t->rchild);
    }
    return t;
}
//
template<class T>
void BinaryTree<T>::PreOrder(BTNode<T> *t)
{
    if(t != NULL)
    {
        std::cout<<t->data<<"  ";
        PreOrder(t->lchild);
        PreOrder(t->rchild);
    }
}
//
template<class T>
void BinaryTree<T>::InOrder(BTNode<T> *t)
{
    if(t != NULL)
    {
        InOrder(t->lchild);
        std::cout<<t->data<<"  ";
        InOrder(t->rchild);
    }
}
//
template<class T>
void BinaryTree<T>::PostOrder(BTNode<T> *t)
{
    if(t != NULL)
    {
        PostOrder(t->lchild);
        PostOrder(t->rchild);
        std::cout<<t->data<<"  ";
    }
}
//
template<class T>
BTNode<T>* BinaryTree<T>::FindNode(BTNode<T> *t,T x)
{
    BTNode<T> *p;
    if(t == NULL)
    {
        return NULL;
    }
    else if(t->data == x)
    {
        return t;
    }
    else
    {
        p = FindNode(t->lchild,x);
        if(p != NULL)
        {
            return p;
        }
        return FindNode(t->rchild,x);
    }
}
//
template<class T>
int BinaryTree<T>::BTNodeHeigth(BTNode<T> *t)
{
    int lchildh,rchildh;
    if(t == NULL)
    {
        return 0;
    }
    else
    {
        lchildh = BTNodeHeigth(t->lchild);
        rchildh = BTNodeHeigth(t->rchild);
        return (lchildh > rchildh)?(lchildh + 1):(rchildh + 1);
    }
}
//
template<class T>
int BinaryTree<T>::NodeCount4(BTNode<T> *t)
{
    if(t == NULL)
    {
        return 0;
    }
    else
    {
        return (NodeCount4(t->lchild) + NodeCount4(t->rchild) + 1);
    }
}
//
template<class T>
int BinaryTree<T>::NodeCount1(BTNode<T> *t)
{
    int m,n,k;
    if(t != NULL)
    {
        m = NodeCount1(t->lchild);
        k = 1;
        n = NodeCount1(t->rchild);
        return m + n + k;
    }
    return 0;
}
//
template<class T>
int BinaryTree<T>::NodeCount2(BTNode<T> *t)
{
    int m,n,k;
    if(t != NULL)
    {
        m = NodeCount2(t->lchild);
        n = NodeCount2(t->rchild);
        k = 1;
        return m + n + k;
    }
    return 0;
}
//
template<class T>
int BinaryTree<T>::NodeCount3(BTNode<T> *t)
{
    int m,n,k;
    if(t != NULL)
    {
        k = 1;
        m = NodeCount3(t->lchild);
        n = NodeCount3(t->rchild);
        return m + n + k;
    }
    return 0;
}
//
template<class T>
void BinaryTree<T>::DispLeaf(BTNode<T> *t)
{
    if(t != NULL)
    {
        if((t->lchild == NULL)&&(t->rchild == NULL))
        {
            std::cout<<t->data<<"  ";
        }
        DispLeaf(t->lchild);
        DispLeaf(t->rchild);
    }
}
//
template<class T>
//输出路径长度
void BinaryTree<T>::printLeavesDepth(BTNode<T> *t, int depth)
{
  if (t == NULL) return;
  if (t->lchild == NULL && t->rchild == NULL)
  {
    std::cout<<t->data<<": "<<depth<<std::endl;
  }
  else
  {
    printLeavesDepth(t->lchild, depth+1);
    printLeavesDepth(t->rchild, depth+1);
  }
}
//
template<class T>
bool BinaryTree<T>::printAncestor(BTNode<T> *t, T x)
{
    if(t == NULL)
    {
        return false;
    }
    if((t->lchild != NULL)&&(t->lchild->data == x))
    {
        std::cout<<t->data<<"  ";
        return true;
    }
    if((t->rchild != NULL)&&(t->rchild->data == x))
    {
        std::cout<<t->data<<"  ";
        return true;
    }
    if((printAncestor(t->lchild,x))||(printAncestor(t->rchild,x)))
    {
        std::cout<<t->data<<"  ";
        return true;
    }
    return false;
}
//
template<class T>
void BinaryTree<T>::PreOrder1(BTNode<T> *t)
{
    BTNode<T> *st[MaxSize];
    int top = -1;
    BTNode<T> *p;
    top++;
    st[top] = t;                //将根结点入栈
    while(top != -1)            //栈非空
    {
        p = st[top];
        top--;
        std::cout<<p->data<<"  ";
        if(p->rchild != NULL)   //右孩子先进栈
        {
            top++;
            st[top] = p->rchild;
        }
        if(p->lchild != NULL)   //左孩子再进栈
        {
            top++;
            st[top] = p->lchild;
        }
    }
}
//中序遍历非递归算法
template<class T>
void BinaryTree<T>::InOrder1(BTNode<T> *t)
{
    BTNode<T> *st[MaxSize];
    BTNode<T> *p;
    int top = -1;
    p = t;
    while((top != -1)||(p!=NULL))   //栈不空或p不为空时
    {
        while(p != NULL)            //扫描所有左结点并进栈
        {
            top++;
            st[top] = p;
            p = p->lchild;
        }
        if(top > -1)                //若栈不为空
        {
            p = st[top];
            top--;
            std::cout<<p->data<<"  ";
            p = p->rchild;          //转向处理右子树
        }
    }
}
//
template<class T>
void BinaryTree<T>::PostOrder1(BTNode<T> *t)
{
    BTNode<T> *st[MaxSize],*p,*q;
    p = t;
    int top = -1;
    bool flag;
    do
    {
        while(p != NULL)        //将p结点及所有的左下结点进栈
        {
            top++;
            st[top] = p;
            p = p->lchild;
        }
        q = NULL;              //q指向栈顶结点的前一个已经访问的结点
        flag =true;              //表示p结点的左子树已经遍历完
        while((top != -1)&&(flag == true))//若p结点及其右子树已访问或为空
        {
            p = st[top];
            if(p->rchild == q)
            {
                std::cout<<q->data<<"  ";
                top--;
                q = p;
            }
            else
            {
                p = p->rchild;
                flag = false;
            }
        }
    }
    while(top != -1);
}
//
template<class T>
void BinaryTree<T>::LevelOrder(BTNode<T> *t)
{
    BTNode<T> *qu[MaxSize],*p;
    int front = 0, rear = 0;
    rear++;
    qu[rear] = t;
    while(front != rear)    //队列不为空
    {
        front = (front + 1) % MaxSize;
        p = qu[front];
        std::cout<<p->data<<"  ";
        if(p->lchild != NULL)
        {
            rear = (rear + 1) % MaxSize;
            qu[rear] = p->lchild;
        }
        if(p->rchild != NULL)
        {
            rear = (rear + 1) % MaxSize;
            qu[rear] = p->rchild;
        }
    }
}
#endif // _BINARYREE_H_

源文件 

#include <iostream>
#include "BinaryTree.h"

using namespace std;

int main()
{
    BinaryTree<char> a;

    cout<<"前序遍历：  ";
    a.PreOrder();
    cout<<endl;
    cout<<"中序遍历：  ";
    a.InOrder();
    cout<<endl;
    cout<<"后序遍历：  ";
    a.PostOrder();
    cout<<endl;
    cout<<"层次遍历：  ";
    a.LevelOrder();
    cout<<endl;

    cout<<"该树的高度是:   "<<a.BTNodeHeigth()<<endl;
    cout<<"该树的结点个数为：  "<<a.NodeCount1()<<endl;
    cout<<"该树的叶子结点为： ";
    a.DispLeaf();
    cout<<endl;
    a.printRouteLength();
    cout<<"D的祖先结点有： ";
    a.printAncestor('D');

    return 0;
}


远去的栀子花
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++二叉树的基本操作
wfanyue的博客
06-16 729
#include <iostream> using namespace std; class BinaryTree ; class BinTreeNode //结点类的定义 { friend BinaryTree; private: BinTreeNode *leftChild, *rightChil...
二叉树操作 C++实现
giver
01-01 297
所谓之其然，还要知其所以然，为了提高C++开发效率，我们可能会选择直接使用标准库提供的二叉树操作，但是，作为一个合格的programmer，有必要掌握这些常用数据结构的基本实现。本博文旨在分享自己用C++实现的二叉树操作源码，主要对二叉树的四个遍历方式（层次遍历，先序遍历，中序遍历，后续遍历）做了实现。希望对大家学习二叉树有所参考和帮助。由于时间有限，若有不足，欢迎指出！如果对按层次遍历算法还是没...
【数据结构】C++语言实现二叉树的介绍及堆的实现(详细解读)
最新发布
bhbcdxb123的博客
05-15 2011
int size;}HP;
二叉树的相关操作回顾（C++实现）
黄飞的博客专栏
04-04 601
二叉树的初始化思路： 使用队列，队首出队一个元素队末进两个元素，而这两个元素正好是这个队首元素的左右节点。比如我们给定这样的一组数据：{1, 2, 3, 4, 5, 0, 6, 0, 7, 8, 9} （假设0代表空），则可构建二叉树如下： 整个建树以及遍历过程，在这里不细说，该篇博客主要是对数据结构中二叉树的相关具体实现做回顾与备忘。废话不多说，直接上代码：#include <iostream
【C++ 二叉树操作详解】【转载】
j8267643的博客
02-16 873
在后续遍历得到的序列中，最后一个元素为树的根结点。1. 1->2->4->6->7，7 无左孩子，也无右孩子，输出 7，此时 6 无左孩子，而 6 的右子树也全部输出，输出 6，此时 4 无左子树，而 4 的右子树已全部输出，接着输出 4，此时 2 的左子树全部输出，且 2 无右子树，输出 2，此时 1 的左子树全部输出，接着转向右子树；3. 7 的左孩子为空，输出 7，右孩子也为空，此时 2 的左子树全部输出，输出 2，2 的右孩子为空，此时 1 的左子树全部输出，输出 1，接着 1 的右孩子；
打印二叉树C++
刘望的博客
07-29 1870
作者：知乎用户 链接：https://www.zhihu.com/question/280630276/answer/415783268 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 struct node {int value; struct node *left, *right; }; // 一个数组，数组长度不低于二叉树的高度，为了简便起见，这里假设是一百, // 自己使用得时候可以改成动态数组(或链表) int vec_left[100] = {0}; //.
C++二叉树结构的建立与基本操作
09-04
在C++中，二叉树是一种重要的数据结构，它由一系列结点组成，每个结点最多有两个子结点，通常称为左子结点和右子结点。二叉树的构建和基本操作是理解和应用二叉树的关键。 首先，我们需要定义二叉树的结构。在C++中...
c++二叉树的基本操作
11-25
递归二叉树的基本操作，递归创建，递归先序遍历、中序遍历、后序遍历，求树的高度，求叶子结点的个数，交换树的左右孩子
二叉树-基于C++实现的二叉树操作.zip
04-26
总结来说，"二叉树-基于C++实现的二叉树操作.zip"这个压缩包文件很可能包含了以上讨论的二叉树概念、节点类定义、基本操作（插入、搜索、删除）以及遍历算法的C++代码实现。通过学习和理解这些内容，你可以掌握...
C++二叉树基本操作
07-03
这个压缩包文件“C++二叉树基本操作”显然是一个关于使用C++实现二叉树操作的示例代码集，对于学习C++和数据结构的人来说极具价值。 二叉树是由节点（或称为元素）构成的数据结构，每个节点最多有两个子节点，通常...
C++实现二叉树基本操作详解
08-28
C++ 实现二叉树基本操作详解 二叉树是一种重要的非线性数据结构，广泛应用于计算机科学和信息技术领域。为了帮助读者更好地理解和掌握二叉树的基本操作，本文将详细介绍 C++ 语言实现二叉树基本操作的方法和技术。 ...
c++元编程打印二叉树
weixin_39057744的博客
10-16 142
#include<iostream> using namespace std; template<typename T,T val,typename L,typename R> struct Tree {}; template<typename T> struct Print {}; template<typename T, T val,typename L, typename R> struct Print<Tree<T,val,L,R&gt
从上往下打印二叉树（C++）
田螺姑娘的博客
03-18 929
从上往下打印二叉树 描述   不分行从上往下打印出二叉树的每个节点，同层节点从左至右打印。例如输入{8,6,10,#,#,2,1}，如以下图中的示例二叉树，则依次打印8,6,10,2,1(空节点不打印，跳过)，请你将打印的结果存放到一个数组里面，返回。 数据范围: 0<=节点总数<=1000 -1000<=节点值<=1000 示例1 输入： {8,6,10,#,#,2,1} 返回值： [8,6,10,2,1] 示例2 输入： {5,4,#,3,#,2,#,1} 返回值： [5,4
C++打印漂亮的二叉树
using namespace 数学工具构造器;
12-07 495
stackoverflow的讨论：print-binary-tree-in-a-pretty-way-using-c cpp代码 #include <bits/stdc++.h> using namespace std; typedef long long ll; const double pi = acos(-1); class BTNode { public: int val; BTNode *left; BTNode *right; BTNode(
从上至下打印二叉树（C++）
weixin_38679101的博客
04-04 405
struct TreeNode{ int val; struct TreeNode* left; struct TreeNode* right; TreeNode(int x): val(x), left(NULL),right(NULL){ } }; vector<int> CenShowTree(TreeNode* pRo...
C++ 从上到下，从左至右打印二叉树
chenxin_003的专栏
09-19 1226
代码如下： #include #include "BinaryTree.h" #include using namespace std; void PrintTree_from_head_to_tail(TreeNode* proot) { if(proot == NULL) return; deque tree_que; TreeNode* node = proot; tre
从上往下打印二叉树 — C++实现
Jeaten
09-04 255
题目描述 从上往下打印出二叉树的每个节点，同层节点从左至右打印。 牛客网题目链接 解题思路 此题属于队列的应用，具体解题过程为： 遇到根节点，先输出 如果其有左右子结点，则将左右子结点存在队列中（置于队尾） 再从队列中按序取出结点，并进行相同的操作，直至队列为空位置 代码实现 class Solution { public: vector<int> PrintFromTopToBottom(TreeNode* root) { vector <int>res
C++打印二叉树形状
weixin_44589374的博客
12-15 3253
C++打印二叉树形状 把二叉树按层序遍历的顺序放在e数组里，虚结点用逗号表示 void print() { int i; int num=0; int row=0; for(i=0;e[i]!='#'&&i<100;i++) { num++; } for(i=0;i<10;i++) { if(pow(2,i)>=num) { ...
c++二叉树打印（只为美观）
weixin_41990671的博客
09-30 4825
文章目录先上效果图然后上代码测试用例：思路写在最后 先上效果图 然后上代码 /** * 中序遍历返回节点数组 * @param root 根节点 * @return 中序遍历节点数组 */ std::vector<TreeNode *> inorderTraversal(TreeNode *root) { std::vector<TreeNode *> res; std::stack<TreeNode *> stk; w
c++ 二叉树基本操作
08-11
在二叉树中，有一些基本的操作可以帮助我们对二叉树进行各种操作。 首先是创建二叉树的操作。我们可以通过手动输入节点的值来创建一个二叉树。根据输入的值，我们可以根据特定规则将节点连接起来，形成一个完整的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值