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

最新推荐文章于 2023-03-22 23:00:57 发布
最新推荐文章于 2023-03-22 23:00:57 发布
阅读量3.3k 收藏 17
点赞数 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
关注
  • 6
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——常见二叉树的分类（完全二叉树、满二叉树、平衡二叉树、二叉搜索树、红黑树）
weixin_45338443的博客
06-25 2558
二叉树的定义、特点和常见分类
数据结构与算法之二叉树大全
努力让自己发光，对的人才能迎着光而来
09-04 2万+
二叉树的定义 二叉树的性质(特性) 满二叉树与完全二叉树 链式存储的二叉树 顺序存储的二叉树 线索二叉树(Threaded BinaryTree) 二叉排序树（Binary Sort Tree） 平衡二叉树（ Balanced Binary Tree） 为什么使用平衡二叉树？ 如何判断平衡二叉树？ 相关概念 旋转方式 实例 代码实现...
二叉树知识点最详细最全讲解
前景
04-05 3万+
1.树的介绍 1.1树的定义 树是一种数据结构，它是由n（n>=1）个有限节点组成一个具有层次关系的集合。 把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 1.每个节点有零个或多个子节点; 2.没有父节点的节点称为根节点; 3.每一个非跟节点有且仅有一个父节点; ...
二叉树各种类型汇总
上善若泪
06-26 7965
文章目录1 树类型1.1 二叉树1.2 完全二叉树1.3 满二叉树1.4 二叉搜索树（二叉排序树、二叉查找树）1.5 平衡二叉树1.6 红黑树1.6.1 红黑树概念1.6.2 红黑树和AVL树区别1.7 B树类型1.7.1 B树1.7.2 B-树1.7.3 B+树1.7.4 B*树 学习了树的结构类型后，主要对各种树类型进行汇总总结 1 树类型 树中的基本概念：https://jingzh.blog.csdn.net/article/details/107128291 树类型概述： 二叉树，完全二叉树，满二
二叉树及其作用浅析
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
10-14 1万+
在学习数据结构和算法时看到各种树，把人都整蒙了，枯燥且提不起学习兴趣。等逐渐感受到二叉树的神奇作用和巨大的应用价值后，觉得二叉树原来也这么有趣，值得好好学习。 先从整体上认识下二叉树及其他各种树的区别和用途。 大致有哪些树？ 树有很多种，其中二拆树因为其特殊的结构和特点在计算上最为常用。 常见的二叉树：二叉查找树，平衡二叉树(AVL)，红黑树，B+树，B-树，字典树，满二叉树，完全二叉树，霍夫曼树，伸展树，最小堆，最大堆等。 二叉树有什么用？ 二叉树应用非常广泛。 在操作系统源程序中，树和.
二叉树的基本操作实现及其应用
05-24
设计程序实现二叉树结点的类型定义和对二叉树的基本操作。该程序包括二叉树结构类型以及每一种操作的具体的函数定义和主函数。 1. 按先序次序建立一个二叉树 ，用#表示某结点的左右子树是否为空，用于表示该结点是否...
python二叉树的实现实例
12-24
树的定义树是一种重要的非线性数据结构，直观地看，它是数据元素（在树中称为结点）按...树的递归定义如下：（1）至少有一个结点（称为根）（2）其它是互不相交的子树二叉树：　二叉树是由n（n≥0）个结点组成的有限
MFC实现（数据结构）二叉树的应用
11-27
其中包括二叉树的各种基本函数以及常用函数（实现二叉树的建立以及建立二叉树后的中序、前序、后序的递归和非递归函数，层次遍历的非递归函数）。 通过MFC实现可视化，即输入前序遍历二叉树的序列，即可以显示二叉树...
Windows应用程序中二叉树的实现
02-22
本文通过分析单任务件产系统)∗ “ 与多任务操作系统∀#∃...管理上的不同, 参照, 语言在) + & 少实现二叉树的原班, 对二叉树节点数据类型的 定义作相应的修改提出− 了一种在∀ #∃ % + ∀ 。编程中实现二又树的方法。
【数据结构】——二叉树详解
热门推荐
atwdy的博客
07-28 4万+
二叉树(Binary Tree)是由n个结点构成的有限集(n≥0)，n=0时为空树，n>0时为非空树。对于非空树TTT有且仅有一个根结点；除根结点外的其余结点又可分为两个不相交的子集TLT_LTL​和TRT_RTR​，分别称为TTT的左子树和右子树，且TLT_LTL​和TRT_RTR​本身又都是二叉树。很明显该定义属于递归定义，所以有关二叉树的操作使用递归往往更容易理解和实现。从定义也可以看出二叉树与一般树的区别主要是两点，一是每个结点的度最多为2；
二叉树的基本定义
小孙的博客
02-15 6343
树的定义 树是n个结点的有限集。当n = 0时称为空树，在任意一颗非空树种； 有且仅有一个特定的称为根的结点 当n > 1时，其余结点可分为m(m > 0) 个互不相交的有限集T1、T2、……、Tm,其中每一个集合本身又是一棵树，并且称为跟的子树。 树结点的分类 结点拥有的子树称为度。度为0的结点称为叶结点或终端结点；度不为零的结点称为非终端结点或分支结点。除根节点外，分支结点也称为内部节点。树的度是树内树内各节点的度的最大值。 树与结点之间的关系 结点的子树的根称为该结点的孩子
二叉树的简介
风间琉璃的博客
11-02 481
文章目录前言????二叉树的定义????二叉树的类型????斜树????满二叉树????完全二叉树????二叉树的存储结构总结 前言 提示：以下是本篇文章正文内容 ????二叉树的定义 二叉树是n(n>=0)个节点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根节点和两颗互不相交的，分别称为根节点的左子树和右子树的二叉树组成 二叉树的特点： (1)每个节点最多有两颗子树 (2)二叉树是有序的，其次序不能随意颠倒 这两颗二叉树是不一样的 二叉树的基本形态：包含五种 注：二叉树和树
二叉树的应用详解 - 数据结构
黄规速博客:学如逆水行舟，不进则退
06-25 4万+
概述： 平衡树——特点：所有结点左右子树深度差≤1 排序树——特点：所有结点“左小右大 字典树——由字符串构成的二叉排序树 判定树——特点：分支查找树（例如12个球如何只称3次便分出轻重） 带权树——特点：路径带权值（例如长度） 最优树——是带权路径长度最短的树，又称 Huffman树，用途之一是通信中的压缩编码。 1. 二叉排序树（二叉查找树Binary Sear
二叉树 前序、中序、后序、层次遍历及非递归实现 查找、统计个数、比较、求深度的递归实现...
weixin_30588907的博客
09-28 311
一、基本概念 每个结点最多有两棵子树，左子树和右子树，次序不可以颠倒。 性质： 1、非空二叉树的第n层上至多有2^(n-1)个元素。 2、深度为h的二叉树至多有2^h-1个结点。 满二叉树：所有终端都在同一层次，且非终端结点的度数为2。 在满二叉树中若其深度为h，则其所包含的结点数必为2^h-1。 完全二叉树：除了最大的层次即成为一颗满二叉树且层次最大那层所有的结...
二叉树的概念
crazy的博客
10-05 1021
1.二叉树的定义及其主要特性 》》二叉树的定义 1）、二叉树是另一种树形结构，其特点是每个结点至多只有两棵子树（即二叉树中不存在度大于 2的结点），并且，二叉树的子树有左右之分，其次序不能任意颠倒。 2）、与树相似，二叉树也以递归的形式定义。二叉树是 n （n>= 0 ）个结点的有限集合： ...
二叉树的应用
zd454909951的博客
12-19 1084
一、二叉排序树在建立二叉树的同时，数据已经经过初步的比较，并按照二叉树的建立规则来存放数据，规则如下： 第一个输入数据作为根节点 之后的数据以递归的方式与树根进行比较，小于树根置于左子树，大于树根置于右子树 按照上述规则建立好二叉树后，只要利用中序遍历方式就可得到由小到大排序好的数据。如果想得到由大到小排列，可将最后结果置于堆栈内再POP出来。二、二叉搜索树如果一个二叉树符合“每一个节点的数据大于左
二叉树定义及其性质
qq_38122800的博客
02-14 1024
1. 二叉树的定义 二叉树（Binary Tree）是n（n>=0）个结点的有限集合，该集合或者为空集（空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。 2. 二叉树的五种基本形态： • 空二叉树 • 只有一个根结点 • 根结点只有左子树 • 根结点只有右子树 • 根结点既有左子树又有右子树 3. 斜树 4. 满二叉树 在一棵二叉树中，如果所有分...
[数据结构]二叉树概念
qq_66767938的博客
03-22 714
认识二叉树
数据结构---二叉树
weixin_52575498的博客
03-02 711
一、树形结构： 树是 n(n>=0) 个结点的有限集合T，当 n=0 时，称为空树；当 n>0 时，该集合满足如下条件： (1)其中必有一个称为跟（root）的特定结点，他没有直接前驱，但有0个或多个直接后继。 (2)其余 n-1 个结点可以划分成 m(m>=0) 个互不相交的有限集合，T1,T2,T3，··· Tm，其中Ti又是一棵树，称为根的子树。子树的定义也同树的定义一样。 一个直观的二叉树 ...
java 二叉树实现类
最新发布
05-09
Java的二叉树实现类，是一种常见的数据结构和算法基础。在程序设计中，二叉树广泛应用于搜索、排序、储存、压缩、编码等方面，具有较高的实用价值和研究价值。 Java的二叉树实现可以采用多种方式，例如：链式存储、数组存储、堆存储等。其中，链式存储是一种常见的实现方式，其基本思想是使用节点类来表示树的结构，在每个节点类中保存左子树和右子树的引用信息。 具体实现时，需要定义一个Node类表示一个节点，该类中包含三个属性：data存储节点数据、left存储左子节点的引用、right存储右子节点的引用。通过使用Node类，便可以实现二叉树的遍历、插入、删除、查找等基本操作。 在实现Java的二叉树时，需要注意以下几点：首先，需要定义二叉树的根节点，并在每次操作后实时更新根节点的引用；其次，需要考虑二叉树的节点数据类型，如果节点数据类型不同，则需要使用泛型来处理；最后，需要结合具体应用场景，来灵活运用不同的遍历算法和数据结构，实现高效和优化的代码逻辑。 总之，Java的二叉树实现类虽然简单，但实际应用中却有着广泛的应用。通过深入理解二叉树的基本概念和常见实现方法，可以提高程序设计水平和算法思维能力，为实现更加复杂和高级的数据结构和算法奠定坚实的基础。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值