数据结构-二叉树模板

最新推荐文章于 2022-06-01 13:15:42 发布
最新推荐文章于 2022-06-01 13:15:42 发布
阅读量206 收藏
点赞数
分类专栏： 数据结构 文章标签： 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiujie_said/article/details/116601360
版权

数据结构课上自己写了个二叉树类，后面一堆数据结构课的作业全是在这个代码上改的，有需求的自取。

文章目录

普通二叉树

#include <iostream>
using namespace std;
template <class ElemType>
struct BinTreeNode
{
    ElemType data;
    BinTreeNode<ElemType> *leftChild;
    BinTreeNode<ElemType> *rightChild;
    BinTreeNode();
    BinTreeNode(const ElemType &d,BinTreeNode<ElemType> *lChild=NULL,BinTreeNode<ElemType> *rChild=NULL);
    BinTreeNode(const BinTreeNode<ElemType>& cpy);
};

template<class ElemType>
BinTreeNode<ElemType>::BinTreeNode()    //无参构造
{
    leftChild=rightChild=NULL;
}

template<class ElemType>
BinTreeNode<ElemType>::BinTreeNode(const ElemType &d,BinTreeNode<ElemType> *lChild,BinTreeNode<ElemType> *rChild)   //含参构造
{
    data=d;
    leftChild=lChild;
    rightChild=rChild;
}


template <class ElemType>
class BinaryTree
{
protected:
    BinTreeNode<ElemType> *root;
    BinTreeNode<ElemType> *CopyTree(BinTreeNode<ElemType> *t);
    void Destroy(BinTreeNode<ElemType> *&r);
    BinTreeNode<ElemType>* buildWithPreIn(ElemType *pre,ElemType *in,int size);
   
public:
    ~BinaryTree();
    BinaryTree(ElemType *pre,ElemType *in,int size);
    void PreOrder(BinTreeNode<ElemType>* r);  //正序输出以r为根的树，不换行
    void InOrder(BinTreeNode<ElemType>* r);   //中序输出以r为根的树，不换行
    void PostOrder(BinTreeNode<ElemType>* r); //后序输出以r为根的树，不换行
    void showPre();
    void showIn();
    void showPost();
};

template<class ElemType>
BinTreeNode<ElemType>* BinaryTree<ElemType>::CopyTree(BinTreeNode<ElemType> *t)
{
    BinTreeNode<ElemType>* tcpy=new BinTreeNode<ElemType>(t->data);
    if(t->leftChild!=NULL)
    {
        BinTreeNode<ElemType>* left=CopyTree(t->leftChild);
        tcpy->leftChild=left;
    }
    if(t->rightChild!=NULL)
    {
        BinTreeNode<ElemType>* right=CopyTree(t->rightChild);
        tcpy->rightChild=right;
    }
    root=tcpy;
    return tcpy;
}

template<class ElemType>
void BinaryTree<ElemType>::Destroy(BinTreeNode<ElemType> *&r)
{
    if(r!=NULL)
    {
        Destroy(r->leftChild);
        Destroy(r->rightChild);
        delete r;
        r=NULL;
    }
}

template<class ElemType>
BinTreeNode<ElemType>* BinaryTree<ElemType>::buildWithPreIn(ElemType *pre,ElemType *in,int size)
{
    if(size==0)
    {
        return NULL;
    }
    int pos=0;
    BinTreeNode<ElemType>* r=new BinTreeNode<ElemType>(pre[0]);
    for(int i=0;i<size;i++)
    {
        if(in[i]==pre[0])
        {
            pos=i;
            break;
        }
    }
    r->leftChild=buildWithPreIn(pre+1, in, pos);
    r->rightChild=buildWithPreIn(pre+1+pos, in+1+pos, size-pos-1);
    return r;
}

template<class ElemType>
BinaryTree<ElemType>::~BinaryTree()
{
    Destroy(root);
}

template<class ElemType>
BinaryTree<ElemType>::BinaryTree(ElemType *pre,ElemType *in,int size)
{
    root=buildWithPreIn(pre, in, size);
}

template<class ElemType>
void BinaryTree<ElemType>::PreOrder(BinTreeNode<ElemType>* r)
{
    if(r==NULL)
    {
        return;
    }
    cout<<r->data<<" ";
    PreOrder(r->leftChild);
    PreOrder(r->rightChild);
    return;
}

template<class ElemType>
void BinaryTree<ElemType>::InOrder(BinTreeNode<ElemType>* r)
{
    if(r==NULL)
    {
        return;
    }
    InOrder(r->leftChild);
    cout<<r->data<<" ";
    InOrder(r->rightChild);
    return;
}

template<class ElemType>
void BinaryTree<ElemType>::PostOrder(BinTreeNode<ElemType>* r)
{
    if(r==NULL)
    {
        return;
    }
    PostOrder(r->leftChild);
    PostOrder(r->rightChild);
    cout<<r->data<<" ";
    return;
}

template<class ElemType>
void BinaryTree<ElemType>::showPre()
{
    PreOrder(root);
    cout<<endl;
}

template<class ElemType>
void BinaryTree<ElemType>::showIn()
{
    InOrder(root);
    cout<<endl;
}

template<class ElemType>
void BinaryTree<ElemType>::showPost()
{
    PostOrder(root);
    cout<<endl;
}

int main()
{
    char pre[]={'A','B','D','E','H','C','F','G'};
    char in[]={'D','B','E','H','A','F','C','G'};
    BinaryTree<char> tree(pre,in,8);
    tree.showPre();
}

一般树孩子兄弟表示法

#include<iostream>
#include<queue>
using namespace std;
template <class ElemType>
struct TreeNode
{
    ElemType data;
    TreeNode<ElemType> *firstChild;
    TreeNode<ElemType> *nextSibling;
    TreeNode();
    TreeNode(const ElemType &d,TreeNode<ElemType> *child=NULL,TreeNode<ElemType> *sibling=NULL);
    TreeNode(const TreeNode<ElemType>& cpy);
};

template<class ElemType>
TreeNode<ElemType>::TreeNode()    //无参构造
{
    firstChild=nextSibling=NULL;
}

template<class ElemType>
TreeNode<ElemType>::TreeNode(const ElemType &d,TreeNode<ElemType> *child,TreeNode<ElemType> *sibling)   //含参构造
{
    data=d;
    firstChild=child;
    nextSibling=sibling;
}


template <class ElemType>
class Tree
{
protected:
    TreeNode<ElemType> *root;
    void Destroy(TreeNode<ElemType> *&r);
    TreeNode<ElemType>* buildWithPreIn(ElemType *pre,ElemType *in,int size);
   
public:
    ~Tree();
    Tree(ElemType *pre,ElemType *in,int size);
    void PreOrder(TreeNode<ElemType>* r);  //正序输出以r为根的树，不换行
    void InOrder(TreeNode<ElemType>* r);   //中序输出以r为根的树，不换行
    void PostOrder(TreeNode<ElemType>* r); //后序输出以r为根的树，不换行
    void showPre();
    void showIn();
    void showPost();
    int getDepth(const ElemType & find,int ans=1,TreeNode<ElemType> *r=NULL) const ;
    int Depth() const;
    int Degree() const;
};

template<class ElemType>
void Tree<ElemType>::Destroy(TreeNode<ElemType> *&r)
{
    if(r!=NULL)
    {
        Destroy(r->firstChild);
        Destroy(r->nextSibling);
        delete r;
        r=NULL;
    }
}

template<class ElemType>
TreeNode<ElemType>* Tree<ElemType>::buildWithPreIn(ElemType *pre,ElemType *in,int size)
{
    if(size==0)
    {
        return NULL;
    }
    int pos=0;
    TreeNode<ElemType>* r=new TreeNode<ElemType>(pre[0]);
    for(int i=0;i<size;i++)
    {
        if(in[i]==pre[0])
        {
            pos=i;
            break;
        }
    }
    r->firstChild=buildWithPreIn(pre+1, in, pos);
    r->nextSibling=buildWithPreIn(pre+1+pos, in+1+pos, size-pos-1);
    return r;
}

template<class ElemType>
Tree<ElemType>::~Tree()
{
    Destroy(root);
}

template<class ElemType>
Tree<ElemType>::Tree(ElemType *pre,ElemType *in,int size)
{
    root=buildWithPreIn(pre, in, size);
}

template<class ElemType>
void Tree<ElemType>::PreOrder(TreeNode<ElemType>* r)
{
    if(r==NULL)
    {
        return;
    }
    cout<<r->data<<" ";
    PreOrder(r->firstChild);
    PreOrder(r->nextSibling);
    return;
}

template<class ElemType>
void Tree<ElemType>::InOrder(TreeNode<ElemType>* r)
{
    if(r==NULL)
    {
        return;
    }
    InOrder(r->firstChild);
    cout<<r->data<<" ";
    InOrder(r->nextSibling);
    return;
}

template<class ElemType>
void Tree<ElemType>::PostOrder(TreeNode<ElemType>* r)
{
    if(r==NULL)
    {
        return;
    }
    PostOrder(r->firstChild);
    PostOrder(r->nextSibling);
    cout<<r->data<<" ";
    return;
}

template<class ElemType>
void Tree<ElemType>::showPre()
{
    PreOrder(root);
    cout<<endl;
}

template<class ElemType>
void Tree<ElemType>::showIn()
{
    InOrder(root);
    cout<<endl;
}

template<class ElemType>
void Tree<ElemType>::showPost()
{
    PostOrder(root);
    cout<<endl;
}

template<class ElemType>
int Tree<ElemType>::getDepth(const ElemType & find,int ans,TreeNode<ElemType> *r) const
{
    if(r==NULL)
    {
        r=this->root;
    }
    if(r==NULL)
        return -1;
    if(r->data==find)
        return ans;
    TreeNode<ElemType> *p=r;
    if(p->firstChild!=NULL)
    {
        int dep=getDepth(find,ans+1,p->firstChild);
        if(dep!=-1)
        {
            return dep;
        }
    }
    TreeNode<ElemType> *s=p;
    while(s->data!=find)
    {
        if(s->firstChild!=NULL)
        {
            int dep=getDepth(find,ans+1,s->firstChild);
            if(dep!=-1)
                return dep;
        }
        if(s->nextSibling==NULL)
        {
            break;
        }
        else s=s->nextSibling;
    }
    if(s->data==find)
        return ans;
    return -1;
}

template<class ElemType>
int Tree<ElemType>::Depth() const
{
    int ans=1;
    TreeNode<ElemType> *p=root;
    while(p->firstChild!=NULL)
    {
        ans++;
        p=p->firstChild;
    }
    return ans;
}

template<class ElemType>
int Tree<ElemType>::Degree() const
{
    if(root==NULL||root->firstChild==NULL)
        return 0;
    queue<TreeNode<ElemType>*> q;
    int ans=0;
    q.push(root->firstChild);
    while(!q.empty())
    {
        TreeNode<ElemType> *p=q.front();
        int temp=0;
        while(p!=NULL)
        {
            if(p->firstChild!=NULL)
                q.push(p->firstChild);
            temp++;
            p=p->nextSibling;
        }
        ans=max(ans,temp);
        q.pop();
    }
    return ans;
}
int main()
{
    char pre[]={'I','A','B','D','E','H','C','F','G'};
    char in[]={'D','B','E','H','A','F','C','G','I'};
    Tree<char> tree(pre,in,9);
    cout<<tree.getDepth('F')<<endl;
    cout<<tree.Depth()<<endl;
    cout<<tree.Degree()<<endl;
}

BST二叉排序树

#include <iostream>
#include<algorithm>
using namespace std;
const int inf=999999999;
template <class ElemType>
struct BinTreeNode
{
    ElemType data;
    BinTreeNode<ElemType> *leftChild;
    BinTreeNode<ElemType> *rightChild;
    BinTreeNode();
    BinTreeNode(const ElemType &d,BinTreeNode<ElemType> *lChild=NULL,BinTreeNode<ElemType> *rChild=NULL);
    BinTreeNode(const BinTreeNode<ElemType>& cpy);
};

template<class ElemType>
BinTreeNode<ElemType>::BinTreeNode()    //无参构造
{
    leftChild=rightChild=NULL;
}

template<class ElemType>
BinTreeNode<ElemType>::BinTreeNode(const ElemType &d,BinTreeNode<ElemType> *lChild,BinTreeNode<ElemType> *rChild)   //含参构造
{
    data=d;
    leftChild=lChild;
    rightChild=rChild;
}


template <class ElemType>
class BinaryTree
{
protected:
    BinTreeNode<ElemType> *root;
    BinTreeNode<ElemType> *CopyTree(BinTreeNode<ElemType> *t);
    void Destroy(BinTreeNode<ElemType> *&r);
    BinTreeNode<ElemType>* buildWithPreIn(ElemType *pre,ElemType *in,int size);
   
public:
    ~BinaryTree();
    BinaryTree(ElemType *pre,ElemType *in,int size);
    void PreOrder(BinTreeNode<ElemType>* r);  //正序输出以r为根的树，不换行
    void InOrder(BinTreeNode<ElemType>* r);   //中序输出以r为根的树，不换行
    void PostOrder(BinTreeNode<ElemType>* r); //后序输出以r为根的树，不换行
    void showPre();
    void showIn();
    void showPost();
    bool isBST(const BinTreeNode<ElemType> *r,int minx,int maxx) const;
    void outputIsBST() const;
    //判断是否是BST
    void findLittle(const BinTreeNode<ElemType> *r,const ElemType & x) const;
    void outputLittle(const ElemType & x) ;
    //输出比x小的所有元素
};

template<class ElemType>
BinTreeNode<ElemType>* BinaryTree<ElemType>::CopyTree(BinTreeNode<ElemType> *t)
{
    BinTreeNode<ElemType>* tcpy=new BinTreeNode<ElemType>(t->data);
    if(t->leftChild!=NULL)
    {
        BinTreeNode<ElemType>* left=CopyTree(t->leftChild);
        tcpy->leftChild=left;
    }
    if(t->rightChild!=NULL)
    {
        BinTreeNode<ElemType>* right=CopyTree(t->rightChild);
        tcpy->rightChild=right;
    }
    root=tcpy;
    return tcpy;
}

template<class ElemType>
void BinaryTree<ElemType>::Destroy(BinTreeNode<ElemType> *&r)
{
    if(r!=NULL)
    {
        Destroy(r->leftChild);
        Destroy(r->rightChild);
        delete r;
        r=NULL;
    }
}

template<class ElemType>
BinTreeNode<ElemType>* BinaryTree<ElemType>::buildWithPreIn(ElemType *pre,ElemType *in,int size)
{
    if(size==0)
    {
        return NULL;
    }
    int pos=0;
    BinTreeNode<ElemType>* r=new BinTreeNode<ElemType>(pre[0]);
    for(int i=0;i<size;i++)
    {
        if(in[i]==pre[0])
        {
            pos=i;
            break;
        }
    }
    r->leftChild=buildWithPreIn(pre+1, in, pos);
    r->rightChild=buildWithPreIn(pre+1+pos, in+1+pos, size-pos-1);
    return r;
}

template<class ElemType>
BinaryTree<ElemType>::~BinaryTree()
{
    Destroy(root);
}

template<class ElemType>
BinaryTree<ElemType>::BinaryTree(ElemType *pre,ElemType *in,int size)
{
    root=buildWithPreIn(pre, in, size);
}

template<class ElemType>
void BinaryTree<ElemType>::PreOrder(BinTreeNode<ElemType>* r)
{
    if(r==NULL)
    {
        return;
    }
    cout<<r->data<<" ";
    PreOrder(r->leftChild);
    PreOrder(r->rightChild);
    return;
}

template<class ElemType>
void BinaryTree<ElemType>::InOrder(BinTreeNode<ElemType>* r)
{
    if(r==NULL)
    {
        return;
    }
    InOrder(r->leftChild);
    cout<<r->data<<" ";
    InOrder(r->rightChild);
    return;
}

template<class ElemType>
void BinaryTree<ElemType>::PostOrder(BinTreeNode<ElemType>* r)
{
    if(r==NULL)
    {
        return;
    }
    PostOrder(r->leftChild);
    PostOrder(r->rightChild);
    cout<<r->data<<" ";
    return;
}

template<class ElemType>
void BinaryTree<ElemType>::showPre()
{
    PreOrder(root);
    cout<<endl;
}

template<class ElemType>
void BinaryTree<ElemType>::showIn()
{
    InOrder(root);
    cout<<endl;
}

template<class ElemType>
void BinaryTree<ElemType>::showPost()
{
    PostOrder(root);
    cout<<endl;
}

template<class ElemType>
bool BinaryTree<ElemType>::isBST(const BinTreeNode<ElemType> *r,int  minx,int  maxx) const
{
    if(r==NULL)
        return 1;
    if(r->data < minx ||r->data >maxx)
        return 0;
    return isBST(r->leftChild, minx, r->data-1) && isBST(r->rightChild, r->data-1, maxx);
}

template<class ElemType>
void BinaryTree<ElemType>::outputIsBST() const
{
    cout<<isBST(root, -inf, inf)<<endl;
}

template<class ElemType>
void BinaryTree<ElemType>::findLittle(const BinTreeNode<ElemType> *r,const ElemType & x) const
{
    if(r==NULL)
        return;
    if(r->data>x)
    {
        findLittle(r->leftChild, x);
    }
    if(r->data==x)
    {
        cout<<r->data<<" ";
        findLittle(r->leftChild, x);
    }
    if(r->data<x)
    {
        findLittle(r->rightChild, x);
        cout<<r->data<<" ";
        findLittle(r->leftChild, x);
    }
}

template<class ElemType> 
void BinaryTree<ElemType>::outputLittle(const ElemType & x) 
{
    findLittle(root, x);
}
int main()
{
    int pre[]={5,2,1,4,3,6,9,8};
    int in[]={1,2,3,4,5,6,8,9};
    BinaryTree<int> tree(pre,in,8);
    tree.outputIsBST();
    tree.outputLittle(6);
}
DavidXu_JJ
关注
专栏目录
模板--二叉树
To-nemy
07-30 316
问题描述： A binary tree is a finite set of vertices that is either empty or consists of a root r and two disjoint binary trees called the left and right subtrees. There are three most important ways in
二叉树模版
01-19
各类和二叉树有关的模版，binary_tree、huffman_tree、in_thread_binary_tree、sq_binary_tree
树的概念、性质、存储、遍历
weixin_64840732的博客
06-01 170
基本概念： 树是n（n≥0）个结点的有限集合T(Tree)。当n=0时，称为空树；当n>0时， 该集合满足如下条件： (1) 其中必有一个称为根（root）的特定结点，它没有直接前驱，但有零个或多个直接后继。 (2) 其余n-1个结点可以划分成m（m≥0）个互不相交的有限集T1，T2，T3，…，Tm，其中Ti又是一棵树，称为根root的子树。 每棵子树的根结点有且仅有一个直接前驱，但有零个或多个直接后继。 结点：包含一个数据元素及若干指向其它结点的分支信息。 结点的度：一个结点的子树个数称为此结点的度。
SDUT 二叉树（模板题）
qq_45830025的博客
10-14 271
I - 二叉树 Description 已知二叉树的一个按前序遍历输入的字符序列，如abc,de,g,f, (其中,表示空结点)。请建立二叉树，并输出建立二叉树的前序遍历序列、中序遍历序列、后序遍历序列、层次遍历序列、深度、叶子数。 Input 多组测试数据，对于每组测试数据，输入一个长度小于５０的按前序遍历输入的字符序列。 Output 对于每组测试数据，第1行输出其前序遍历序列、第2行输出其中序遍历序列、第3行输出其后序遍历序列、第4行输出其深度、第5行输出其叶子数。 Sample Input abc,
自己动手实现数据结构模板(2)：二叉树
时梦的博客
10-02 1170
date: 2018-09-29 07:37:40+00:00 原标题: 自己动手实现数据结构模板(2)：二叉树 原链接: https://www.dreamoftime0.com/2018/09/29/%e8%87%aa%e5%b7%b1%e5%8a%a8%e6%89%8b%e5%ae%9e%e7%8e%b0%e6%95%b0%e6%8d%ae%e7%bb%93%e6%9e%84%e6%a8%...
数据结构-二叉树的实现.docx
10-10
### 数据结构知识点：二叉树的实现 #### 实验背景与目标 本次实验的主要目的是让学生通过实际编程操作来深入理解二叉树这一重要的数据结构，并掌握其基本操作方法。二叉树是一种非常实用且常见的非线性数据结构，...
比特数据结构课件-Lesson5-二叉树.pdf
最新发布
07-07
【二叉树】是数据结构中的重要组成部分，它是一种特殊的树结构，每个节点最多只有两个子节点，分别称为左子节点和右子节点。二叉树的概念有助于解决许多计算机科学中的问题，例如文件系统目录结构的表示、搜索算法的...
C++数据结构-二叉树和线索二叉树
01-03
添加、删除、拷贝、清空、树深度计算、父节点、兄弟节点获取、先中后序递归及非遍历、按层次遍历、中序迭代器（非递归算法）、节点查找、先序和中序序列重建二叉树、数组和二叉链表存储结构相互转换。使用模板偏特化...
数据结构实验报告-二叉树.pdf
10-27
5. **系统设计**：基于二叉树的定义和实验要求，设计二叉树模板类，包含建立、遍历、计算属性等操作。同时，设计了菜单供用户选择不同的功能进行调试。 6. **编程环境**：实验在Windows操作系统上使用Visual Studio...
数据结构实验报告-二叉树.docx
06-17
《算法与数据结构》课程实验报告关注的是二叉树这一重要的数据结构，实验的主要目标是理解和实现二叉树的各种操作。二叉树是一种特殊的树形数据结构，其中每个节点最多有两个子节点，通常分为左子节点和右子节点。本...
二叉树（模板）
qz13110802018的专栏
08-22 472
前序：根-左子树右子树
二叉树模板
qq_31602961的博客
03-27 195
#include<cstdio> //二叉树结点 struct node{ int data; node* lchild; node* rchild; }; //新建二叉树结点 node* newnode(int data){ node* a = new node; a->data = data; a->lchild = ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值