二叉树类的定义、实现以及应用

最新推荐文章于 2024-09-23 07:00:00 发布
最新推荐文章于 2024-09-23 07:00:00 发布
阅读量3.4k 收藏 18
点赞数 6
分类专栏： 数据结构课程笔记 文章标签： 数据结构 二叉树 c++ 非递归 哈夫曼
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/juddi/article/details/102887286
版权

本例程实现二叉树的二叉链表存储结构类的定义、实现、应用以及Huffman树，包括：

三种构造函数：

1、键盘输入扩展二叉树的前序序列构造二叉树

2、由扩展二叉树的前序遍历序列s构造二叉树

3、由扩展二叉树的前序遍历序列sp,中序遍历序列sm构造二叉树

析构函数：释放二叉链表中各结点的存储空间

获得指向根结点的指针

二叉树的遍历：

1、前中后序遍历二叉树的递归实现

2、前中后序遍历二叉树的非递归实现，后序遍历二叉树只进一次栈的非递归实现

3、层序遍历二叉树

应用：

1、求二叉树结点个数

2、前序遍历顺序输出二叉树叶子结点

3、非递归中序遍历顺序输出二叉树叶子结点

4、求二叉树的高度

5、计算二叉树中有所有叶子结点的和

6、Huffman树

#include<iostream>
#include<iomanip>
#include<string>
using namespace std;
int m=0;
template <class T>
struct BiNode   //二叉树的结点结构
{
  T data;
  BiNode<T> *lchild, *rchild;
};
template <class T>
struct BiNodeTag   //用于后序遍历二叉树非递归实现（2次进栈）的结点结构
{
  char tag;
  BiNode<T> *pt;
};

template <class T>
class BiTree
{ //二叉树类
public:
    BiTree( );       //构造函数，键盘输入扩展二叉树的前序序列构造二叉树
    BiTree(char *s); //构造函数，由扩展二叉树的前序遍历序列s构造二叉树
    BiTree(string sp,string sm); //构造函数，由扩展二叉树的前序遍历序列sp,中序遍历序列sm构造二叉树
    ~BiTree(void);         //析构函数，释放二叉链表中各结点的存储空间
    BiNode<T>* Getroot();  //获得指向根结点的指针
    void PreOrder(BiNode<T> *root);     //前序遍历二叉树递归
    void PreOrder0(BiNode<T> *root);    //前序遍历二叉树非递归
    void InOrder(BiNode<T> *root);      //中序遍历二叉树递归
    void InOrder0(BiNode<T> *root);    //中序遍历二叉树非递归
    void PostOrder(BiNode<T> *root);    //后序遍历二叉树递归
    void PostOrder0(BiNode<T> *root);    //后序遍历二叉树非递归
    void PostOrder1(BiNode<T> *root);    //后序遍历二叉树非递归1,只进一次栈
    void LevelOrder(BiNode<T> *root);   //层序遍历二叉树
private:
    BiNode<T> *root;         //指向根结点的头指针
    BiNode<T> *Creat();     //无参构造函数调用
    BiNode<T> *Creat(char *s);     //有参构造函数调用
    BiNode<T> *Creat(string sp,string sm);     //有参构造函数调用
    void Release(BiNode<T> *root);   //析构函数调用
};


/*
 *前置条件：二叉树不存在
 *输    入：无
 *功    能：构造一棵二叉树
 *输    出：无
 *后置条件：产生一棵二叉树
 */
template<class T>
BiTree<T>::BiTree(char *s )
{
    m=0;
    root = Creat(s);
}
template<class T>
BiTree<T>::BiTree( )
{
    root = Creat();
}
template<class T>
BiTree<T>::BiTree(string sp,string sm )
{
    root = Creat(sp,sm);
}
/*
 *前置条件：二叉树已存在
 *输    入：无
 *功    能：释放二叉链表中各结点的存储空间
 *输    出：无
 *后置条件：二叉树不存在
 */
template<class T>
BiTree<T>::~BiTree(void)
{
    Release(root);
}
/*
 *前置条件：二叉树已存在
 *输    入：无
 *功    能：获取指向二叉树根结点的指针
 *输    出：指向二叉树根结点的指针
 *后置条件：二叉树不变
 */
template<class T>
BiNode<T>* BiTree<T>::Getroot( )
{
    return root;
}
/*
 *前置条件：二叉树已存在
 *输    入：无
 *功    能：前序遍历二叉树
 *输    出：二叉树中结点的一个线性排列
 *后置条件：二叉树不变
 */
template<class T>
void BiTree<T>::PreOrder(BiNode<T> *root)
{
    if(root==NULL)  return;
    else{
        cout<<root->data<<" ";
        PreOrder(root->lchild);
        PreOrder(root->rchild);
    }
}

/*
 *前置条件：二叉树已存在
 *输    入：无
 *功    能：中序遍历二叉树
 *输    出：二叉树中结点的一个线性排列
 *后置条件：二叉树不变
 */
template <class T>
void BiTree<T>::InOrder (BiNode<T> *root)
{
    if (root==NULL)  return;      //递归调用的结束条件
    else{
        InOrder(root->lchild);    //中序递归遍历root的左子树
        cout<<root->data<<" ";    //访问根结点的数据域
        InOrder(root->rchild);    //中序递归遍历root的右子树
    }
}
/*
 *前置条件：二叉树已存在
 *输    入：无
 *功    能：后序遍历二叉树
 *输    出：二叉树中结点的一个线性排列
 *后置条件：二叉树不变
 */
template <class T>
void BiTree<T>::PostOrder(BiNode<T> *root)
{
    if (root==NULL)   return;       //递归调用的结束条件
    else{
        PostOrder(root->lchild);    //后序递归遍历root的左子树
        PostOrder(root->rchild);    //后序递归遍历root的右子树
        cout<<root->data<<" ";      //访问根结点的数据域
    }
}

/*
 *前置条件：二叉树已存在
 *输    入：无
 *功    能：层序遍历二叉树
 *输    出：二叉树中结点的一个线性排列
 *后置条件：二叉树不变
 */
template <class T>
void BiTree<T>::LevelOrder(BiNode<T> *root)
{
    const int MaxSize = 100;

    int front = 0;
    int rear = 0;  //采用顺序队列，并假定不会发生上溢

    BiNode<T>* Q[MaxSize];
    BiNode<T>* q;

    if (root==NULL) return;
    else{
        Q[rear++] = root;
        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;
        }
    }
}

/*
 *前置条件：空二叉树
 *输    入：数据ch;
 *功    能：初始化一棵二叉树,构造函数调用
 *输    出：无
 *后置条件：产生一棵二叉树
 */
//int m=0;
template <class T>
BiNode<T>* BiTree<T>::Creat(char *s)
{
    BiNode<T>* root;
    char ch=s[m++];
    //cout<<"请输入创建一棵二叉树的结点数据"<<endl;
    //cin>>ch;
    if (ch=='#') root = NULL;
    else{
         root = new BiNode<T>;       //生成一个结点
         root->data=ch;
         root->lchild = Creat(s );    //递归建立左子树
         root->rchild = Creat(s );    //递归建立右子树
    }
    return root;
}
template <class T>
BiNode<T>* BiTree<T>::Creat(string sp,string sm)
{
    BiNode<T>* root=NULL;
    if(sp.length() > 0)
    {
        root=new BiNode<T> ;
        root->data=sp[0];
        int index=sm.find(sp[0]);
        string in_left_str=sm.substr(0, index);
        string in_right_str=sm.substr(index+1);
        string pre_left_str=sp.substr(1, index);
        string pre_right_str=sp.substr(index+1);
        root->lchild = Creat(pre_left_str, in_left_str);    //递归建立左子树
        root->rchild = Creat(pre_right_str, in_right_str);    //递归建立右子树
    }
    return root;
}
template <class T>
BiNode<T>* BiTree <T>::Creat()
{   BiNode<T>* root;
    char ch;
    cout<<"Input a char: ";
    cin>>ch;
    if (ch=='#')     root=NULL;
    else {
        root=new BiNode<T>;
        root->data=ch;
        root-> lchild=Creat();
        root-> rchild=Creat();
    }
 return root;
}

/*
 *前置条件：二叉树已经存在
 *输    入：无
 *功    能：释放二叉树的存储空间，析构函数调用
 *输    出：无
 *后置条件：二叉树不存在
 */
template<class T>
void BiTree<T>::Release(BiNode<T>* root)
{
  if (root != NULL){
      Release(root->lchild);   //释放左子树
      Release(root->rchild);   //释放右子树
      delete root;
  }
}

template<class T>
void BiTree<T>::PreOrder0(BiNode<T> *root)
{//前序遍历二叉树非递归
    const int MaxStackSize=100;
    BiNode<T> *S[MaxStackSize];
    int top= -1;   // 构造空栈,采用顺序栈，并假定不会发生上溢
    while (root!=NULL||top!= -1)
     {
         while (root!= NULL)
         {
             cout<<root->data;
             S[++top]=root;;
             root=root->lchild;
         }
         if (top!= -1) {
             root=S[top--];
             root=root->rchild;
         }
     }
}
template<class T>
void BiTree<T>::InOrder0(BiNode<T> *root)
{//中序遍历二叉树非递归
    const int MaxStackSize=100;
    BiNode<T> *S[MaxStackSize];
    int top= -1;   // 构造空栈,采用顺序栈，并假定不会发生上溢
    while (root!=NULL||top!= -1)
     {
         while (root!= NULL)
         {
             S[++top]=root;
             root=root->lchild;
         }
         if (top!= -1) {
             root=S[top--];cout<<root->data;
             root=root->rchild;
         }
     }
}
template<class T>
void BiTree<T>::PostOrder0(BiNode<T> *root)
{//二叉树后序遍历非递归 2次入栈
    const int MaxStackSize=100;
    BiNodeTag<T> S[MaxStackSize];
    BiNodeTag<T> p;
    int top= -1;   // 构造空栈,采用顺序栈，并假定不会发生上溢
    while (root!=NULL||top!= -1)
     {
       while (root!= NULL)
        {
          p.pt=root;p.tag='L';
          S[++top]=p;
          root=root->lchild;
         }
       if (top!= -1) {
          p=S[top--];
          if(p.tag=='L'){p.tag='R';S[++top]=p;root=p.pt->rchild;}
          else if(p.tag=='R'){cout<<p.pt->data;//root=NULL;
          }
          }
     }
}

template<class T>
void BiTree<T>::PostOrder1(BiNode<T> *root)//后序遍历二叉树非递归1,只进一次栈
{
    //二叉树后序遍历非递归 一次入栈：
    //后序遍历在中序的双层循环的基础上需要加入一个记录记录上一次出栈的节点。步骤如下：
    //1、如果栈顶元素非空且左孩子存在，将左孩子入栈，重复该过程。若不存在则进入第2步（该过程和中序遍历一致）
    //2、判断上一次出栈节点是否当前节点的右孩子，或者当前节点是否存在右孩子，满足任一条件，将当前节点输出，并出栈。否则将右节点压栈。跳至第1步
    const int MaxStackSize=100;
    BiNode<T> *S[MaxStackSize];
    int top= -1;   // 构造空栈,采用顺序栈，并假定不会发生上溢
    if(root == NULL) return;
    S[++top]=root;
    BiNode<T>* lastpop = NULL;
    while(top!= -1)
    {
        while(S[top]->lchild != NULL)
            {
                top++;
                S[top]=S[top-1]->lchild;
            }
        while(top!= -1)
        {
            if(lastpop == S[top]->rchild || S[top]->rchild == NULL)
            {//判断上次弹出的结点是不是当前结点的右孩子，或者当前节点没有右孩子，因为访问次序是“左-右-中”。
                cout<<S[top]->data;
                lastpop = S[top--];
            }
            else if(S[top]->rchild != NULL)
            {
                top++;
                S[top]=S[top-1]->rchild;
                break;
            }
        }
    }
}
template <class T>
void Count(BiNode<T> *root,int &n)  //n为全局量并已初始化为0
{//求二叉树结点个数
    if (root) {
         Count(root->lchild,n);
         n++;
         Count(root->rchild,n);
   }
}
template <class T>
int CountNodes(BiNode<T> *root){//求二叉树结点个数
    int n=0;
    Count(root,n);
    return n;
    }
template <class T>
int num_of_nodes(BiNode<T> *t)//求二叉树结点个数
{
    if(t == NULL)return 0;
    int nl=num_of_nodes(t->lchild);
    int nr=num_of_nodes(t->rchild);
    return 1+nl+nr;
}
template <class T>
void PreOrderleaf(BiNode<T> *root)//前序遍历顺序输出二叉树叶子结点
{
    if (root) {
        if (!root->lchild && !root->rchild)
               cout<<root->data;
        PreOrderleaf(root->lchild);
        PreOrderleaf(root->rchild);
   }
}
template<class T>
void InOrder0leaf(BiNode<T> *root)
{   //非递归中序遍历顺序输出二叉树叶子结点
    const int MaxStackSize=100;
    BiNode<T> *S[MaxStackSize];
    int top= -1;   // 构造空栈,采用顺序栈，并假定不会发生上溢
    while (root!=NULL||top!= -1)
     {
         while (root!= NULL)
         {

             S[++top]=root;;
             root=root->lchild;
         }
         if (top!= -1) {
             root=S[top--];
             if(!root->rchild && !root->lchild) cout<<root->data;
             root=root->rchild;
         }
     }
}
template <class T>
int  Depth(BiNode<T> *root)
{//求二叉树的高度
    if (root==NULL) return 0;
    else {
         int hl=Depth(root->lchild);
         int hr=Depth(root ->rchild);
         return hl>hr?hl+1:hr+1;
    }
}
template <class T>
int CountDC(BiNode<T> *root)
//计算二叉树中有所有叶子结点的和。
{
if (root==NULL) return 0;
else{
       if (root->lchild==NULL&& root->rchild==NULL)
               return (int)(root->data);
       else
       return (CountDC(root->lchild)+CountDC(root->rchild));
   }
}

// 哈夫曼树的结点结构
struct element
{
    int weight;        // 权值域
    int lchild, rchild, parent;  // 该结点的左、右、双亲结点在数组中的下标
};
// 选取权值最小的两个结点
void selectMin(element a[],int n, int &s1, int &s2)
{
    for (int i = 0; i < n; i++)
    {
        if (a[i].parent == -1)// 初始化s1,s1的双亲为-1
        {
            s1 = i;
            break;
        }
    }
    for (int i = 0; i < n; i++)// s1为权值最小的下标
    {
        if (a[i].parent == -1 && a[s1].weight > a[i].weight)
            s1 = i;
    }
    for (int j = 0; j < n; j++)
    {
        if (a[j].parent == -1&&j!=s1)// 初始化s2,s2的双亲为-1
        {
            s2 = j;
            break;
        }
    }
    for (int j = 0; j < n; j++)// s2为另一个权值最小的结点
    {
        if (a[j].parent == -1 && a[s2].weight > a[j].weight&&j != s1)
            s2 = j;
    }
}
// 哈夫曼算法
// n个叶子结点的权值保存在数组w中
void HuffmanTree(element huftree[], int w[], int n)
{
    for (int i = 0; i < 2*n-1; i++)    // 初始化，所有结点均没有双亲和孩子
    {
        huftree[i].parent = -1;
        huftree[i].lchild = -1;
        huftree[i].rchild = -1;
    }
    for (int i = 0; i < n; i++)    // 构造只有根节点的n棵二叉树
    {
        huftree[i].weight = w[i];
    }
    for (int k = n; k < 2 * n - 1; k++) // n-1次合并
    {
        int i1, i2;
        selectMin(huftree, k, i1, i2); // 查找权值最小的俩个根节点，下标为i1,i2
        // 将i1，i2合并，且i1和i2的双亲为k
        huftree[i1].parent = k;
        huftree[i2].parent = k;
        huftree[k].lchild = i1;
        huftree[k].rchild = i2;
        huftree[k].weight = huftree[i1].weight + huftree[i2].weight;
    }

}
// 输出哈夫曼树
void print(element hT[],int n)
{
    cout << "index weight parent lChild rChild" << endl;
    cout << left;    // 左对齐输出
    for (int i = 0; i < n; ++i)
    {
        cout << setw(5) << i << " ";
        cout << setw(6) << hT[i].weight << " ";
        cout << setw(6) << hT[i].parent << " ";
        cout << setw(6) << hT[i].lchild << " ";
        cout << setw(6) << hT[i].rchild << endl;
    }
}

int main()
{    BiNode<char>* root;
    BiTree<char> bt; //创建一棵二叉树
    root = bt.Getroot( );  //获取指向根结点的指针
    cout<<"------前序遍历------ "<<endl;
    bt.PreOrder(root);
    cout<<endl;
    bt.PreOrder0(root);
    cout<<endl;
    cout<<"------中序遍历------ "<<endl;
    bt.InOrder(root);
    cout<<endl;
    bt.InOrder0(root);
    cout<<endl;
    cout<<"------后序遍历------ "<<endl;
    bt.PostOrder(root);
    cout<<endl;
    bt.PostOrder0(root);
    cout<<endl;
    cout<<"------层序遍历------ "<<endl;
    bt.LevelOrder(root);
    cout<<endl;
    cout<<"Number of nodes="<<CountNodes(root)<<endl;
    cout<<"Number of nodes="<<num_of_nodes(root)<<endl;
    cout<<"Leaf-nodes are ";
    PreOrderleaf(root);
    cout<<endl<<"Leaf-nodes are ";
    InOrder0leaf(root);
    cout<<endl<<"Depth="<<Depth(root)<<endl;

    BiTree<char> bt1("ABD#EI##F##CG#H####"); //创建一棵二叉树
    //BiNode<string>* root;  //获取指向根结点的指针
    root = bt1.Getroot( );

    cout<<"------前序遍历------ "<<endl;
    bt1.PreOrder(root);
    cout<<endl;
    bt1.PreOrder0(root);
    cout<<endl;
    cout<<"------中序遍历------ "<<endl;
    bt1.InOrder(root);
    cout<<endl;
    bt1.InOrder0(root);
    cout<<endl;
    cout<<"------后序遍历------ "<<endl;
    bt1.PostOrder(root);
    cout<<endl;
    bt1.PostOrder0(root);
    cout<<endl;
    cout<<"------层序遍历------ "<<endl;
    bt1.LevelOrder(root);
    cout<<endl;
    /*n=0;
    Count(root);
    cout<<"Number of nodes="<<n<<endl;*/
    cout<<"Number of nodes="<<CountNodes(root)<<endl;
    cout<<"Leaf-nodes are ";
    PreOrderleaf(root);
    cout<<endl<<"Leaf-nodes are ";
    InOrder0leaf(root);
    cout<<endl<<"Depth="<<Depth(root)<<endl;
    cout<<CountDC(root)<<endl;

//    BiTree<char> bt2("DBEAFC","ABDECF"); //创建一棵二叉树
    BiTree<char> bt2("abdcef","dbacfe"); //创建一棵二叉树树
    root = bt2.Getroot( );  //获取指向根结点的指针
    cout<<"------前序遍历------ "<<endl;
    bt2.PreOrder(root);    cout<<endl;
    bt2.PreOrder0(root);    cout<<endl;
    cout<<"------中序遍历------ "<<endl;
    bt2.InOrder(root);    cout<<endl;
    bt2.InOrder0(root);    cout<<endl;
    cout<<"------后序遍历------ "<<endl;
    bt2.PostOrder(root);cout<<endl;
    bt2.PostOrder0(root);cout<<endl;
    bt2.PostOrder1(root);cout<<endl;
    cout<<endl;
    cout<<"------层序遍历------ "<<endl;
    bt2.LevelOrder(root);    cout<<endl;
    cout<<CountDC(root)<<endl;


    int x[] = { 5,29,7,8,14,23,3,11 };        // 权值集合
    element *hufftree=new element[2*8-1];    // 动态创建数组
    HuffmanTree(hufftree, x, 8);
    print(hufftree,15);

    return 0;
}

juddi
关注
专栏目录
二叉树的应用
zd454909951的博客
12-19 1142
一、二叉排序树在建立二叉树的同时，数据已经经过初步的比较，并按照二叉树的建立规则来存放数据，规则如下： 第一个输入数据作为根节点 之后的数据以递归的方式与树根进行比较，小于树根置于左子树，大于树根置于右子树 按照上述规则建立好二叉树后，只要利用中序遍历方式就可得到由小到大排序好的数据。如果想得到由大到小排列，可将最后结果置于堆栈内再POP出来。二、二叉搜索树如果一个二叉树符合“每一个节点的数据大于左
二叉树的定义与实现
qq_34228115的博客
10-10 454
/** * 二叉链式存储结构下的二叉树结点 */ public class BiTreeNode { public Object data;// 结点的数据元素 public BiTreeNode lchild, rchild; // 左右孩子 public BiTreeNode() {// 构造一个空结点 this(null); } public BiTreeNode(Object ...
二叉搜索树(BSTree)原理及应用场景
最新发布
weixin_43841461的博客
09-23 2077
二叉搜索树可以用于构建词汇表，其中词汇作为键值，出现频率等信息作为键值对应的数据。在需要动态管理一组有序元素的应用场景中，如任务队列或优先级队列，二叉搜索树可以有效地支持元素的插入、删除操作，同时保持集合的有序性。本文将从二叉搜索树的基本概念出发，逐步介绍其原理、常见算法，并通过具体的Java代码示例来加深理解，最后探讨二叉搜索树在算法中的实际应用场景。二叉搜索树作为一种高效的数据结构，在计算机科学中有广泛的应用。插入新节点时，需要根据节点的值找到合适的位置，以保证二叉搜索树的性质不变。
二叉树类结构的实现
卢冠道(夜空*星星)的专栏
01-09 1795
本人用C#实现了一个二叉树类。封装了二叉树结构，实现方便创建一棵二叉树，并且可以对二叉树实现层序遍历，前序遍历，中序遍历以及后序遍历。控件dll将在过几天发上来共享。以下是实现的源代码：using System;using System.Collections.Generic;using System.Text;using System.Collections;namespace Syst
各类二叉树及其应用
enternalstar的博客
07-19 1268
【各类二叉树】 二叉树的特点：兼顾静态查找和动态修改，即既能像数组一样快速查找也能像快速增删 二叉树：每个节点的度数不超过2 真二叉树：每个节点的度数为0或2 完全二叉树：叶节点在最底部的两层，且最底层的叶节点在左侧 满二叉树：所有叶节点都在最底层，每层节点度数为2 二叉搜索树BST：使得二叉树更加高效地实现查找，类似数组有序后的查找，其特点为： 任意节点大于或等于左孩子，小于或等于右孩子 中序遍历单调非降 平衡二叉搜索树BBST：在BST的基础上，使得兄弟子树的高度彼此接
一句话弄懂常见二叉树类型
热门推荐
许佳佳的博客
11-22 1万+
满二叉树除最后一层无任何子节点外，每一层上的所有结点都有两个子结点二叉树。 完全二叉树一棵二叉树至多只有最下面的一层上的结点的度数可以小于2，并且最下层上的结点都集中在该层最左边的若干位置上，则此二叉树成为完全二叉树。 平衡二叉树它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树 二叉搜索树它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不
C语言实现线索二叉树的定义与遍历示例
08-30
本文主要介绍了C语言实现线索二叉树的定义与遍历，结合具体实例形式分析了基于C语言的线索二叉树定义及遍历操作相关实现技巧与注意事项。 一、线索二叉树的定义 线索二叉树是一种特殊的二叉树结构，它在每个结点中...
二叉树的基本操作实现及其应用
05-24
设计程序实现二叉树结点的类型定义和对二叉树的基本操作。该程序包括二叉树结构类型以及每一种操作的具体的函数定义和主函数。 1. 按先序次序建立一个二叉树 ，用#表示某结点的左右子树是否为空，用于表示该结点是否...
PHP完全二叉树定义与实现方法示例
12-19
- 在提供的PHP代码中，`Node`类用于表示二叉树的节点，包含一个值`$value`以及两个子节点引用`$leftNode`和`$rightNode`。 - `findEmpytNode`函数用于寻找二叉树中下一个可用的空节点，即尚未分配值的节点。它通过...
二叉树类的定义和成员函数的实现
09-12
本文将详细介绍二叉树类的定义以及其主要成员函数的实现。 首先，我们看到定义了一个名为`Balance_factor`的枚举类型，它表示节点的平衡因子，用于判断树是否平衡。`left_higher`表示左子树比右子树高，`equal_...
基于节点类的二叉树实现及部分操作函数
Tomsanm的博客
07-09 298
class BtreeNote(): def __init__(self,data=None,left=None,right=None): self.data =data self.left=left self.right = right self._c =0 def count_Note(self,t):# 实例化...
二叉树实现以及相关算法
04-09
cout<<"****** 二叉树二叉链表结构测试程序 ******"<<endl; cout<<"* 0--退出 *"<<endl; cout<<"* 1--交互创建二叉树 *"<<endl; cout<<"* 2--文件创建二叉树 *"<<endl; cout<<"* 3--完全二叉树序列创建二叉树 *"<<endl; cout<<"* 4--打印二叉树 *"<<endl; cout<<"* 5--销毁二叉树 *"<<endl; cout<<"*--------------------------------------*"<<endl; cout<<"* 6--遍历二叉树（递归） *"<<endl; cout<<"* 7--遍历二叉树（非递归） *"<<endl; cout<<"* 8--求二叉树高度（深度） *"<<endl; cout<<"* 9--求结点层次 *"<<endl; cout<<"* 10-- 判定空树 *"<<endl; cout<<"* 11--求双亲结点 *"<<endl; cout<<"* 12--求孩子结点 *"<<endl; cout<<"* 13--求兄弟结点 *"<<endl; cout<<"* 14--查找结点 *"<<endl; cout<<"* 15--求结点数量
二叉树类实例
11-14
通过数的父类Tree与结构父类TreeNode实现树的实例与属性
二叉树的构造
github_38818603的博客
10-04 1533
struct Node{ char data; Node* right, *left; }; class Bitree{ public: Bitree(){ root = new Node(); root-&gt;left = nullptr; root-&gt;right = nullptr; } void...
二叉树类
黑暗之神
06-04 741
上学期数据结构课上写的一个二叉树类，贴出来，写得不是太好，欢迎高手指点。 struct BiNode//定义节点类型 { char data; BiNode *lchild; BiNode *rchild; }; class BiTree { private: BiNode *root; public: BiTree() { root=NULL; } ~BiT
二叉树 类
沉淀
10-11 392
//biTreeNode class //==================================================================================//notation ://author :jiangtao//purpose: create a biTreeNode//=======================
二叉树的种类
zl15290869125的博客
08-14 766
1.满二叉树 定义：所有叶结点同处于最底层（非底层结点均是内部结点），一个深度为k(&amp;gt;=-1)且有2^(k+1) - 1个结点。 2.平衡二叉树 定义：平衡二叉树（Self-balancing binary search tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡...
二叉树类BinaryTree
haojiani00的博客
10-25 710
二叉树是结点的有限集合, 该集合或者为空集, 或者是由一个根和两棵互不相交的称为该根的左子树和右子树的二叉树组成. 二叉树可以为空集, 可以有空二叉树, 也可以有空的左子树 或/和 又子树. 二叉树的性质: 1.第i层至多有2^(i - 1)个结点. 2.高度为h的二叉树上至多有2*h - 1个结点. 3.包含n个元素的二叉树高度至少为>= log2(n + 1)取整. 3.任意
java 二叉树 遍历_JAVA实现二叉树(简易版--实现了二叉树的各种遍历)
weixin_39883286的博客
02-16 225
1 packagetree;23 importjava.util.ArrayDeque;4 importjava.util.ArrayList;5 importjava.util.List;6 importjava.util.Queue;78 public class BinaryTree{9 //为什么要用静态内部类？静态内部类中不能访问外部类的非静态成员10 public st...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值