树（二叉树）的基本操作

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

一、树的基本术语：                                      

结点的度：结点拥有的子树数
树的度：树内各结点的度的最大值
叶子：度为0的结点
分支结点：度不为0的结点
深度：树中结点的最大层次

二、二叉树                                                    

在讨论一般树之前，我们讨论二叉树：1）每个结点最多只有两棵子树；2）二叉树的子树有左右之分
1、二叉树的基本性质
        。。。。。
2、二叉树的存储结构
     顺序存储结构仅适用于完全二叉树，所以一般使用链式存储结构（二叉链表、三叉链表）；
     二叉树的二叉链表存储表示 ：
           
typedef  struct  BiTNode{
        TElemType data;
        struct  BitNode *lchild,*rchild;
}BiTNode,*BiTree;


三、二叉树的基本操作                                

#include  <iostream>
#include  <cstdio>
#include  <cstring>
#include  <cstdlib>

using  namespace  std;

typedef  struct  BiTNode
{      
         char  data;
         struct  BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
int  Max( int  x, int  y)
{
         return  x>y?x:y;
}

void  Create(BiTree &T)   // 先序建一颗二叉树
{
        char  ch;
       scanf(  "%c" ,&ch);
        if (ch== '#'  )
              T=NULL;
        else
       {
              T=(BiTNode *)malloc(  sizeof (BiTNode));
              T->data=ch;
              Create(T->lchild);
              Create(T->rchild);
       }
}
void  Preorder(BiTree &root)   // 先序遍历打印二叉树
{
         if (root!=NULL)
       {
              printf(  "%c " ,root->data);
              Preorder(root->lchild);
              Preorder(root->rchild);
       }
}
void  Inorder(BiTree &root)   // 中序遍历打印二叉树
{
         if (root!=NULL)
       {
              Inorder(root->lchild);
              printf(  "%c " ,root->data);
              Inorder(root->rchild);
       }
}
void  Postorder(BiTree &root)   // 后续遍历打印二叉树
{
         if (root!=NULL)
       {
              Postorder(root->lchild);
              Postorder(root->rchild);
              printf(  "%c " ,root->data);
       }
}
void  Preorderleaf(BiTree &root)  // 先序遍历输出叶子节点
{
         if (root!=NULL)
       {
               if (root->lchild==NULL&&root->rchild==NULL)
                    printf(  "%c " ,root->data);
              Preorderleaf(root->lchild);
              Preorderleaf(root->rchild);
       }
}
int  LeafCount(BiTree &root)   // 统计叶子节点的个数
{
         int  leaf;
         if (root==NULL)
            leaf=0;
         else  if  (root->lchild==NULL&&root->rchild==NULL)
            leaf=1;
         else
            leaf=LeafCount(root->lchild)+LeafCount(root->rchild);
         return  leaf;
}
int  PostTreeDepth(BiTree &root)   // 统计树的高度
{
      int  hl,hr,max;
     if (root!=NULL)
    {
          hl=PostTreeDepth(root->lchild);
          hr=PostTreeDepth(root->rchild);
          max=Max(hl,hr);
           return  max+1;
    }
     else
         return  0;
}
void  dowork()
{
       BiTree cam;
       Create(cam);
       Preorder(cam);  // 先序遍历
       printf(  "\n" );
       Inorder(cam);  // 中序遍历
       printf(  "\n" );
       Postorder(cam);  // 后续遍历
       printf(  "\n" );
       
       printf(  " 叶子节点： " );
       Preorderleaf(cam);
       printf(  "\n" );
       
       printf(  " 叶子节点的个数为 :%d\n" ,LeafCount(cam));
       printf(  " 树的深度为 :%d\n" ,PostTreeDepth(cam));
}
int  main()
{
       dowork();
         return  0;
}


下面的代码是可以运行的，在《零基础学算法》中有，直接拷贝过来。
main.cpp中 

  #include <stdio.h> 
  #include "3-1 BinTree.c"
   
  void oper(ChainBinTree *p) //操作二叉树结点数据 
  {
        printf("%c ",p->data); //输出数据
        return;
  }
  ChainBinTree *InitRoot()  //初始化二叉树的根 
  {
      ChainBinTree *node;
      if(node=(ChainBinTree *)malloc(sizeof(ChainBinTree))) //分配内存
      {
          printf("\n输入根结点数据:");
          scanf("%s",&node->data);
          node->left=NULL;
          node->right=NULL;
          return BinTreeInit(node);
      }
      return NULL;
  }
  void AddNode(ChainBinTree *bt)  //添加结点
  {
       ChainBinTree *node,*parent;
       DATA data;
       char select;
      if(node=(ChainBinTree *)malloc(sizeof(ChainBinTree))) //分配内存
      {
          printf("\n输入二叉树结点数据:");
          fflush(stdin);//清空输入缓冲区 
          scanf("%s",&node->data);
          node->left=NULL; //设置左右子树为空 
          node->right=NULL;
          
  
          printf("输入父结点数据:");
          fflush(stdin);//清空输入缓冲区 
          scanf("%s",&data);
          parent=BinTreeFind(bt,data);//查找指定数据的结点 
          if(!parent)//若未找到指定数据的结点 
          {
              printf("未找到父结点!\n");
              free(node); //释放创建的结点内存 
              return;
           }
           printf("1.添加到左子树\n2.添加到右子树\n");
           do{
              select=getch();
              select-='0';
              if(select==1 || select==2)
                  BinTreeAddNode(parent,node,select); //添加结点到二叉树 
           }while(select!=1 && select!=2);
      }
      return ;
  }
  int main() 
  {
      ChainBinTree *root=NULL; //root为指向二叉树根结点的指针 
      char select;
      void (*oper1)(); //指向函数的指针 
      oper1=oper; //指向具体操作的函数 
      do{
          printf("\n1.设置二叉树根元素    2.添加二叉树结点\n");
          printf("3.先序遍历            4.中序遍历\n");
          printf("5.后序遍历            6.按层遍历\n");
          printf("7.二叉树深度          0.退出\n");
          select=getch();
          switch(select){
          case '1': //设置根元素 
               root=InitRoot();
               break;
          case '2': //添加结点 
               AddNode(root);
               break;
          case '3'://先序遍历
               printf("\n先序遍历的结果：");
               BinTree_DLR(root,oper1);
               printf("\n");
               break;
          case '4'://中序遍历 
               printf("\n中序遍历的结果：");
               BinTree_LDR(root,oper1);
               printf("\n");
               break;
          case '5'://后序遍历 
               printf("\n后序遍历的结果：");
               BinTree_LRD(root,oper1);
               printf("\n");
               break;
          case '6'://按层遍历
               printf("\n按层遍历的结果：");
               BinTree_Level(root,oper1);
               printf("\n");
               break;
          case '7'://二叉树的深度
              printf("\n二叉树深度为:%d\n",BinTreeDepth(root));
              break; 
          case '0':
               break;
         }
     }while(select!='0');
     BinTreeClear(root);//清空二叉树 
     root=NULL;
     getch();
     return 0;
 }


3-1BinTree.cpp中

 #include <stdio.h> 
 #include <stdlib.h> 
   
 #define QUEUE_MAXSIZE 50
 typedef char DATA;       //定义元素类型 
 typedef struct ChainTree  //定义二叉树结点类型 
 {
       DATA data;    //元素数据
       struct ChainTree *left;    //左子树结点指针
      struct ChainTree *right;    //右子树结点指针
 }ChainBinTree;
  
 ChainBinTree *BinTreeInit(ChainBinTree *node) //初始化二叉树根结点 
 {
       if(node!=NULL) //若二叉树根结点不为空 
           return node;
       else
           return NULL;
 }
 int BinTreeAddNode(ChainBinTree *bt,ChainBinTree *node,int n) //添加数据到二叉树 
  //bt为父结点，node为子结点,n=1表示添加左子树，n=2表示添加右子树 
 {
      if(bt==NULL)
      {
          printf("父结点不存在，请先设置父结点!\n");
          return 0;
      } 
      switch(n)
      {
          case 1: //添加到左结点 
              if(bt->left) //左子树不为空 
              {
                  printf("左子树结点不为空!\n");
                  return 0;
              }else
                  bt->left=node;
              break;
          case 2://添加到右结点
              if( bt->right) //右子树不为空 
              {
                  printf("右子树结点不为空!\n"); 
                  return 0;
              }else
                  bt->right=node;
              break;
          default:
              printf("参数错误!\n");
              return 0;
      }
      return 1;
 }
 ChainBinTree *BinTreeLeft(ChainBinTree *bt) //返回左子结点 
 {
      if(bt)
          return bt->left;
      else
          return NULL;
 }
 ChainBinTree *BinTreeRight(ChainBinTree *bt) //返回右子结点 
 {
      if(bt)
          return bt->right;
      else
          return NULL;
 }
 int BinTreeIsEmpty(ChainBinTree *bt) //检查二叉树是否为空，为空则返回1,否则返回0 
 {
      if(bt)
          return 0;
      else
          return 1;
 } 
 int BinTreeDepth(ChainBinTree *bt) //求二叉树深度
 {
      int dep1,dep2;
      if(bt==NULL)
          return 0; //对于空树，深度为0
      else
      {
          dep1 = BinTreeDepth(bt->left); //左子树深度 (递归调用)
          dep2 = BinTreeDepth(bt->right); //右子树深度 (递归调用)
          if(dep1>dep2)
             return dep1 + 1; 
          else
              return dep2 + 1; 
      } 
 } 
 ChainBinTree *BinTreeFind(ChainBinTree *bt,DATA data) //在二叉树中查找值为data的结点 
 {
      ChainBinTree *p;
      if(bt==NULL)
          return NULL;
      else
      {
          if(bt->data==data)
              return bt; 
          else{ // 分别向左右子树递归查找 
              if(p=BinTreeFind(bt->left,data))
                  return p;
             else if(p=BinTreeFind(bt->right, data)) 
                 return p;
             else
                 return NULL; 
         } 
     } 
 } 
 void BinTreeClear(ChainBinTree *bt) // 清空二叉树，使之变为一棵空树
 {
      if(bt)
      {
          BinTreeClear(bt->left); //清空左子树 
          BinTreeClear(bt->right);//清空右子树 
          free(bt);//释放当前结点所占内存 
          bt=NULL;
      }
      return; 
 }
 void BinTree_DLR(ChainBinTree *bt,void (*oper)(ChainBinTree *p))  //先序遍历 
 {     
      if(bt)//树不为空，则执行如下操作 
      {
          oper(bt); //处理结点的数据 
          BinTree_DLR(bt->left,oper);
          BinTree_DLR(bt->right,oper);
      }
      return; 
 } 
 void BinTree_LDR(ChainBinTree *bt,void(*oper)(ChainBinTree *p))  //中序遍历 
 {
      if(bt)//树不为空，则执行如下操作 
      {
          BinTree_LDR(bt->left,oper); //中序遍历左子树
          oper(bt);//处理结点数据 
          BinTree_LDR(bt->right,oper); //中序遍历右子树/
      }
      return; 
 } 
 void BinTree_LRD(ChainBinTree *bt,void (*oper)(ChainBinTree *p)) //后序遍历
 {
      if(bt)
      {
          BinTree_LRD(bt->left,oper); //后序遍历左子树 
          BinTree_LRD(bt->right,oper); //后序遍历右子树/
          oper(bt); //处理结点数据
      }
      return; 
 }
 
 void oper(ChainBinTree *p) //操作二叉树结点数据 
 {
      printf("%c ",p->data); //输出数据
      return;
 }
 
 void BinTree_Level(ChainBinTree *bt,void (*oper)(ChainBinTree *p)) //按层遍历 
 {
      ChainBinTree *p;
      ChainBinTree *q[QUEUE_MAXSIZE]; //定义一个顺序栈 
      int head=0,tail=0;//队首、队尾序号 
      if(bt)//若队首指针不为空     
      {
          tail=(tail+1)%QUEUE_MAXSIZE;//计算循环队列队尾序号 
          q[tail] = bt;//将二叉树根指针进队
      }
      while(head!=tail) //队列不为空，进行循环 
      {
          head=(head+1)%QUEUE_MAXSIZE; //计算循环队列的队首序号 
          p=q[head]; //获取队首元素 
          oper(p);//处理队首元素 
          if(p->left!=NULL) //若结点存在左子树，则左子树指针进队 
          {
              tail=(tail+1)%QUEUE_MAXSIZE;//计算循环队列的队尾序号 
              q[tail]=p->left;//将左子树指针进队 
          }
                  
          if(p->right!=NULL)//若结点存在右孩子，则右孩子结点指针进队 
          {
              tail=(tail+1)%QUEUE_MAXSIZE;//计算循环队列的队尾序号 
              q[tail]=p->right;//将右子树指针进队 
          }
      }
      return; 
 }


 

空空大人
关注
专栏目录
树与二叉树的基本操作
feb_red的博客
06-27 194
二叉树基本操作 ///////////////////////////////////////////////// //Desc： 模拟资源管理器,采用孩子—兄弟链表 // 结构实现。 //Author：JRH //Date: 2/18/2009 // //#include "stdafx.h" #include "stdio.h" #include "locale.h" ...
【java 数据结构】还不会二叉树？一篇搞定二叉树
12-21
二叉树是我们常见的数据结构之一，在学习二叉树之前我们需要知道什么是树，什么是二叉树，本篇主要讲述了二叉树，以及二叉树的遍历。 你能get到的知识点？ 1、树的介绍 2、二叉树的介绍 3、二叉树遍历的四种方法 4、牛客题目：反转二叉树 文章目录你能get到的知识点？一、知识预备1、树2、树的相关术语介绍1、二叉树2、二叉树类型二、二叉树实操（我没有说脏话）1、定义二叉树的结点2、遍历二叉树（四种方法）三、小试牛刀leetcode题目：反转二叉树 一、知识预备 1、树 树（Tree）是n（n>=0)个结点的有限集。 数据结构中的树可以看作一个倒立的树，他的‘根’在上面，他的’叶子’在下面。 2、
树与二叉树的常见操作
weixin_30809333的博客
04-21 101
实验内容： 1．输入字符序列，建立二叉链表。 2．前序，中序，后序遍历二叉树:递归算法。 3．中序遍历二叉树:非递归算法。 4．求二叉树的高度 。 5．求二叉树的叶子个数。 6．借助队列实现二叉树的层次遍历。 7．在主函数中设计一个简单的菜单，分别调试上述算法。 #include <iostream&g...
树和二叉树，以及基本操作
LXY224的博客
04-09 454
树，一种重要的非线性结构。树的一些概念1. 树是n个节点的有限集合。在任意一颗非空树中: //链式存储结构 var arr = [];//存储遍历结果 function BinaryTree(data,leftChild,rightChild) { this.data = data || null; this.leftChild = leftChil...
二叉树基本操作
04-30
以二叉链表作存储结构，编写程序，实现如下的功能： 1、根据输入的数据建立一个二叉树；...若它有右子树，便将右子树根结点入队列，直到队列空为止。因为队列的特点是先进先出，从而达到按层次顺序遍历二叉树的目的。
实验四 二叉树基本操作的实现
12-18
在本实验中，我们将深入探讨数据结构中的一个重要概念——二叉树，并实现其基本操作。二叉树是一种非线性的数据结构，它由一个有限集合的节点构成，每个节点最多有两个子节点，通常称为左子节点和右子节点。这个实验...
二叉树基本操作_二叉树基本操作_
10-02
二叉树的基本操作主要包括创建、查找、插入和删除节点，这些操作对于理解和掌握二叉树至关重要。接下来，我们将详细讨论这些操作。 1. **创建二叉树** 创建一个二叉树首先需要定义二叉树节点的数据结构。在链表...
二叉树基本操作的程序实现.zip_二叉树的基本操作
09-21
这篇文档“二叉树基本操作的程序实现”涵盖了二叉树的一些核心概念和基本操作，旨在帮助初学者理解并实现这些概念。 二叉树由节点构成，每个节点最多有两个子节点，通常分为左子节点和右子节点。二叉树的主要类型有...
二叉树-基于C语言实现的二叉树基本操作.zip
最新发布
04-26
本压缩包包含的是基于C语言实现的二叉树基本操作，是学习和理解二叉树概念以及其实现的一个宝贵资源。 在C语言中，实现二叉树通常涉及定义一个结构体来表示节点，这个结构体至少包含两个指针，分别指向左右子节点，...
树以及二叉树的概念及其基本操作
m0_64028711的博客
08-26 398
树和二叉树作为数据结构的一个重点，需要对递归有深入的了解，希望看到这里的各位能够仔细思考二叉树递归创建应该如何创建，以便更好的自主学习。
树与二叉树的表示和基本操作
测试
09-03 3389
1、树的表示方法有哪几种？树的表示方法有以下四种，各用于不同的目的1）直观表示法以倒着的分支树的形式表示。是数据结构中最常用的树的描述方法。其特点就是对树的逻辑结构的描述非常直观。2）嵌套集合表示法将根结点视为一个集合，其子树构成集合中若干个互不相交的子集，如此嵌套下去，即构成一棵树的嵌套集合表示。3）凹入表示法主要用于树的屏幕和打印输出。4）广义表表示法将根作为由子树森林组成的表的名...
二叉树的基本操作
武志祥的博客
08-07 276
div{align=”center”;font-size:200px;}学完了线性结构以后，接下来就要学树了，下面简要讨论一下二叉树； 1、 二叉树的定义 123 二叉树是每个结点最多有两个孩子，且其子树有左右之分的有序树。 二叉树的递归定义 二叉树是一棵有序树，它的任一结点至多只有两个孩子，分别叫做左孩子和右孩子。根的左孩子L和右孩子R也是二叉树，称为根的左子树和右子树。 图
二叉树【操作】
weixin_30788239的博客
07-07 131
二叉树 二叉树操作1 #include<stdio.h> //' '空格代表树的元素为空 #include<stdlib.h> #define OVERFLOW -1 typedef char TElemType; typedef struct BitNode { TElemType data; struct BitNode *lchi...
二叉树 java泛型_java二叉树
weixin_36331336的博客
02-13 602
二叉树的非递归遍历二叉树的非递归遍历java的非递归后续遍历文章yichudu2014-04-04791浏览量Java工程师必知词汇：二叉树|名词定义|二叉树(Binary tree)是每个节点最多只有两个分支(即不存在分支度大于2的节点)的树结构。通常分支被称作“左子树”或“右子树”。二叉树的分支具有左右次序，不能随意颠倒。二叉树而言，在进行数据获取的时候也有三种形式：前序遍历(根-左-右)、中...
java 二叉树（二）递归方式创建二叉树
Sun_Ru的博客
07-06 906
链表中的数据区，使用结构体存储: class Object{ public int value; }     树类创建：创建一个树类Tree，在类中创建一个根节点。 链表类Node： public class Node{ public Object data; public Node leftNode; public Node rightNode; public Node(O
java数据结构15_二叉树和红黑二叉树
安德的博客
02-28 218
l 二叉树的定义 二叉树是树形结构的一个重要类型。 许多实际问题抽象出来的数据结构往往是二叉树的形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。 二叉树(BinaryTree)由一个结点及两棵互不相交的、分别称作这个根的左子树和右子树的二叉树组成。下图中展现了五种不同基本形态的二叉树。 (a) 为空树。 (b) 为仅有一个结点的二叉树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值