数据结构(C语言描述)读书笔记之二叉树

最新推荐文章于 2021-05-24 09:58:23 发布
最新推荐文章于 2021-05-24 09:58:23 发布
阅读量859 收藏
点赞数
分类专栏： 基础知识 c/c++ 文章标签： c 数据结构 读书笔记 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/shaohuifan88/article/details/10022225
版权
本文是关于二叉树数据结构的读书笔记，涵盖了二叉树的定义、性质，以及如何用C语言实现二叉树的初始化、建立、遍历、查找、插入和删除操作。同时介绍了二叉搜索树的概念及其查找、插入操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

      树是树型结构的简称。若树中各节点的子树是按照一定的次序从左到右安排的，则称之为有序树，否则称为无序树。
    森林是m(m>=0)棵互不相交的树的集合。
    树的性质：
    1,树中的结点数等于所有结点的度数加1.
    2,度为k的树中第i层上至多有k^(i-1)个结点(i>=1).
    3,深度为h的k叉树至多有(k^h-1）/(k-1)个结点。
    4,具有n个结点的k叉树的最小深度为logk(n(k-1)+1的上取整数。
     
     二叉树是指树的度为2的有序树。

      二叉树的存储结构:
     strcut BTreeNode{
          ElemType data;
          struct BTreeNode* left;
          struct BTreeNode* right;
     }
      初始化二叉树
     void InitBTree(struct BTreeNode**　BT)
     {
          *BT=NULL;
     }
     建立二叉树:
     我们的算法是由广义表字符串建立一个二叉树，广义表的样式为(A(B(C),D(E(F,G),H(,I)))
     void CreateBTree(struct BTreeNode** BT, char* a)
     {
          struct BTreeNode* p;
          struct BTreeNode* s[StackMaxSize];
          int top=-1;
          int k;
          int i=0;
          *BT=NULL;
          while(a[i])
          {
               switch(a[i]){
                    case ' ':
                         break;
                    case '(':
                         if(top==StackMaxSize-1){
                              printf("stack is too small ,please increase!\n");
                              exit(1);
                         }
                         top++;s[top]=p;k=1;
                         break;
                    case ')':
                         if(top==-1){
                              printf("a is not valid!\");
                              exit(1);
                         }
                         top--;break;
                    case ',':
                         k=2;break;
                    default:
                         p=malloc(sizeof(struct BTreeNode));
                         p->data=a[i];p->left=p->right=NULL;
                         if(*BT=NULL) *BT=p;
                         else{
                              if(k==1) s[top]->left=p;
                              else s[top]->right=p;
                         }
                }
                 i++;
          }
           检查二叉树是否为空
          int BTreeEmpty(struct BTreeNode* BT)
          {
               if(BT==NULL)return 1;else return0;
          }
            求二叉树深度
          int BTreeDepth(struct BTreeNode* BT)
          {
               if(BT==NULL)
                    return 0;
               else{
                    int dep1=BTreeDepth(BT->left);
                    int dep2=BTreeDepth(BT->right);
                    if(dep1>dep2)
                         return dep1+1;
                    else
                         return dep2+1;
               }
          }
          从二叉树中查找值为x的节点，若存在则返回元素存储位置，否则返回空值。
          ElemType* FindBTree(struct BTreeNode* BT,ElemType x)
          {
               if(BT==NULL) return NULL;
               if(BT->data==x)return &(BT->data);
               if(p=FindBTree(BT->left,x))return p;
               if(p=FindBTree(BT->right,x)) return p;
               return NULL;
           }
           输出二叉树
          void PrintBTree(struct BTreeNode* BT)
          {
               if(BT!=NULL){
                    printf("%c",BT->data);
                    if(BT->left!=NULL||BT->right!=NULL){
                         printf("(");
                         PrintBTree(BT->left);
                         if(BT->right!=NULL)printf(",");
                         PrintBTree(BT->right);
                         printf(")");
                   }
               }
         }
          清除二叉树,使之变为一棵空树
          void ClearBTree(struct BTreeNode** BT)
          {
               if(*BT!=NULL){
                    ClearBTree(&((*BT)->left));
                    ClearBTree(&((*BT)->right));
                    free(*BT);
                    *BT=NULL;
               }
          }
           四种遍历方法：
           1,前序:
           void Preorder(struct BTreeNode* BT)
          {
               if(BT!=NULL)
               {
                      printf("%c",BT->data);
                      Preorder(BT->left);
                    Preorder(BT->right);
               }
          }
          2,中序
          void Inorder(struct BTreeNode* BT)
          {
               if(BT!=NULL)
               {
                      Inorder(BT->left);
                      printf("%c",BT->data);
                      Inorder(BT->right);
               }
          }
          3,后序
          void Postorder(struct BTreeNode* BT)
          {
               if(BT!=NULL){
                     Postorder(BT->left);
                     Postorder(BT->right);
                     printf("%c ",BT->data);
               }
          }
          4,按层遍历
          void Levelorder(struct BTreeNode* BT)
          {
               struct BTreeNode* p;
               struct BTreeNode* q[QueueMaxSize];
               int front=0,rear=0;
               if(BT!=NULL){
                    rear=(rear+1)%QueueMaxSize;
                    q[rear]=BT;
               }
               while(front!=rear){
                    front=(front+1)%QueueMaxSize;
                    p=q[front];
                    printf("%c ",p->data);
                    if(p->left!=NULL){
                         rear=(rear+1)%QueueMaxSize;
                         q[rear]=p->left;
                    }
                    if(p->right!=NULL){
                         rear=(rear+1)%QueueMaxSize;
                         q[rear]=p->right;
                    }
               }
          }
          二叉搜索树,又称二叉排序树，它或者是一棵空树，或者是一棵具有如下特性的非空二叉树。
          (1)若它的左子树非空，则左子树上所有的结点的关键字均小于根节点的关键字。
          (2)若它的右子树非空,则右子树上所有结点的关键字均大于根结点的关键字。
          (3)左、右子树本身又各是一棵二叉搜索树。

           查找
          ElemType* Find(struct BTreeNode* BST,ElemType x)
          {
               if(BST==NULL)return NULL;
               if(x==BST->data)return &(BST->data);
               else if(x<BST->data)
                    return Find(BST->left,x);
               else
                    return Find(BST->right,x);
          }
           插入
          void Insert(struct BTreeNode** BST,ElemType x)
          {
               if(*BST==NULL){
                    struct BTreeNode* p=malloc(sizeof(struct BTreeNode));
                    p->data=x;
                    p->left=p->right=NULL;
               *BST=p;
               }
               else if(x<(*BST)->data) Insert(&(*BST)->left),x);
               else Insert(&((*BST)->right),x);
          }
           非递归的方法
          void Insert(struct BTreeNode** BST,ElemType x)
          {
               struct BTreeNode* p;
               struct BTreeNode* t=*BST,*parent=NULL;
               while(t!=NULL){
                    parent=t;
                    if(x<t->data)t=t->left;
                    else t=t->right;
               }
               p=malloc(sizeof(struct BTreeNode));
               p->data=x;
               p->left=p->right=NULL;
               if(parent==NULL) *BST=p;
               else if(x<parent->data)
                    parent->left=p;
               else parent->right=p;
           }
           删除
          int Delete(struct BTreeNode** BST,ElemType x)
          {
               struct BTreeNode* temp;
               temp=*BST;
               if(*BST==NULL） return 0;
               if(x<(*BST)->data)return Delete(&((*BST->left),x);
               if(x>(*BST)->data)return Delete(&((*BST->right),x);
               if((*BST)->left==NUL){
                    *BST=(*BST)->right;free(temp);return 1;
               }
               else if((*BST)->right==NULL){
                    *BST=(*BST)->left;free(temp);return 1;
               }
               else{
                    if((*BST)->left->right=NULL){
                         (*BST)->data=(*BST)->left->data;
                         return Delete(&((*BST)->left),(*BST)->data);
                    }
                    else{
                         struct BTreeNode *p1=*BST,*p2=p1->left;
                         while(p2->right!=NULL){p1=p2;p2=p2->right;}
                         (*BST)->data=p2->data;
                         return Delete(&(p1->right),p2->data);
                    }
               }
          }      
          
二叉树算法c语言描述
BlissG817的博客
11-29 693
#include typedef struct Node {     int data;     struct Node * next; }Node,*LinkList; LinkList CreateFro,Head() {     LinkList L;     Node * S;     int n=-1,flag=1;     L = (Node *)malloc(
描述c语言的数据结构中的二叉树
12-05
一个用c语言描述的数据结构哦中的二叉树，帮助读者很好的学习有关数据结构中的知识
二叉树相关(C语言描述)
qq_43909184的博客
10-10 254
二叉树和递归有着妙不可言的联系，这篇文章会有着不断的递归，递归往往代码简单，但是十分难想 首先给出二叉树的结构 //二叉树的数据结构 typedef char Elem; typedef struct BNode { Elem _data; struct BNode* _left; struct BNode* _right; }BNode; 以前序遍历的方式建立二叉树 如果字符不为‘#’...
二叉树编程实战-C语言描述
码云仓库地址：https://gitee.com/lance-gyq
05-24 152
二叉树编程实战 拷贝二叉树.c 二叉树编程实战_拷贝二叉树.c #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<string.h> #include<stdlib.h> //二叉树结点 typedef struct BINARYNODE { char ch; struct BINARYNODE*lchild; struct BINARYNODE*rchil
递归遍历二叉树-用C语言描述
Ezra1991的博客
01-22 180
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> typedef int ElementType; ElementType NoInfo = 0; /*用0表示没有结点*/ /*============================结构体===========================================*/ /* 二叉树最常用的表示方法是用链表表示，每个结点由数据和.
严蔚敏《数据结构》（C语言版）笔记和习题（含考研真题）详解
01-15
《严蔚敏《数据结构》（C语言版）笔记和习题（含考研真题）详解》是一份针对计算机科学与技术专业学生和考研备考者的重要参考资料。这本书以C语言为编程工具，深入浅出地讲解了数据结构这一核心课程的知识点。数据...
小甲鱼C-C语言描述数据结构 笔记.pdf
11-17
数据结构和C语言是计算机科学中的基础概念，它们在编程中扮演着至关重要的角色。数据结构是用来组织、管理和处理数据的特定方式，而C语言是一种强大的、底层的编程语言，适用于实现这些数据结构。 1. **数据结构** ...
数据结构（C语言描述）学习笔记.zip
最新发布
06-17
本压缩包“数据结构（C语言描述）学习笔记.zip”提供了大学生深入理解数据结构的重要资源，特别适合正在学习这门课程的学生。 在C语言中描述数据结构，主要是通过指针、结构体等概念来实现的，这使得C语言成为理解...
二叉树的基本操作（数据结构与算法C描述）
Luckily_Girl的博客
11-26 491
刚刚学习的知识，希望大神们多多指教 #include typedef struct Node{ char data; struct Node *LChild; struct Node *RChild; }BiTNode,*BiTree; void CreateBiTree(BiTree *bitree){ char c = getchar(); i
数据结构-二叉树的存储结构与遍历
weixin_34021089的博客
10-24 145
定义 一个有穷的结点集合，可以为空。若不为空，则它是由根结点和称为其左子树和右子树的两个互不相交的二叉树组成。 二叉树的五种基本形态： tree_state 二叉树的子树是有顺序之分的，称为左子树和右子树 left_right_tree 几种特殊的二叉树 斜二叉树 skew_tree 完美二叉树（满二叉树） full_tree 完全二叉树有n个结点的二叉树，对树中结点按从上之...
二叉树的各种实现（创建，叶子结点数，是否为堆，完全二叉树，二叉查找树，交换左右孩子）...
iteye_8029的博客
01-03 195
import java.util.LinkedList; import java.util.Queue; import java.util.Scanner; import java.util.Stack; public class BTree&lt;AnyType extends Comparable&lt;? super AnyType&gt;&gt; { BTNode root=ne...
c语言数据结构学习心得——二叉树
weixin_30699741的博客
03-26 625
二叉树 n（n>=0）个结点的有限集合：（五种形态） 1.或者为空二叉树，n=0； 2.或者由一个根结点和两个互不相交的被称为根的左子树和右子树组成。左子树和右子树又分别是一棵二叉树。 3.每个结点最多有2棵子树 4.左右子树有顺序 特殊二叉树 一.斜树 二.满二叉树：1.分支结点都存在左右子树 2.叶子都在同一层 3.非叶子结点的度一定为2 4.相同深度二叉树中满二叉...
C语言描述二叉树的实现及操作（链表实现）
weixin_30826095的博客
12-11 354
概述 　 二叉树为每个节点最多有两个儿子节点（左儿子节点和右儿子节点）的树。 　　前序遍历：根结点 ---> 左子树 ---> 右子树。 　　中序遍历：左子树--->根结点---> 右子树。 　　后序遍历：左子树 ---> 右子树---> 根结点。 　　节点深度：节点ni的深度（depth）为从根到ni的唯一路径的长。根的深度为0。 　　...
二叉树的存储结构
一只不开窍的笨鸟
09-30 414
1. 二叉树的顺序存储结构 将完全二叉树的节点按照层序编号，然后将这棵树二叉树存入到数组中 ，相应的下标对应相应的位置： 下标：1    2    3      4  5  6    7              A    B   C     D     E     F     G 对于一般的二叉树，可以将不存在的节点用“^”标识进行占位。但是对于只有右结点的树，会严重浪费空间
C语言总结——二叉树
u014682756的专栏
03-18 854
关于二叉树的总结，并使用内核链表构造的队列，对二叉树按层遍历
二叉树的解题感悟
YangYoung_的博客
12-03 239
做二叉树的题目，你要坚信题目定义的函数就是那个含义 如果需要传不属于题目本身函数的参数进去，就重新定义一个函数，如果美原油，就直接用题目自己的函数
二叉树给我的人生感悟
阅读修身
06-16 1161
人生的意义到底是什么呢？ 我们活着到底是为了找寻什么呢？ 有的人说活着就是为了寻找一个目标，然后为之奋斗。但是这样是不是太过于单调呢？生命就像一个无限分支的二叉树，向下，直到生命终结。而咱们人生的选择只能算是其中的一个分支，如果人生就像是刚才所说那样，找一个目标然后奋斗一生，这样是不是太过于单调了呢？二叉树如下图所示（可以继续往下一直分叉）。 但是作为好奇心极其强烈的人类来说
大话数据结构读书笔记系列（六）树<上篇>
沉溺于移动互联网
04-21 2253
第6章 树 6.2　树的定义 之前我们一直在谈的是一对一的线性结构，可现实中，还有很多一对多的情况需要处理，所以我们需要研究这种一对多的数据结构——“树”。 树（Tree）是n（n≥0）个结点的有限集。n=0时称为空树。在任意一棵非空树中：（1）有且仅有一个特定的称为根（Root）的结点；（2）当n＞1时，其余结点可分为m（m＞0）个互不相交的有限集T1、T2、……、Tm，其中每一个集合本
二叉树的性质和存储结构
ker的博客
01-19 2187
初学者二叉树总结一、二叉树的性质二、二叉树的存储结构二叉树的顺序存储(数组)二叉树的链式存储二叉链表存储结构表示三叉链表存储结构表示（有三个指针域） 一、二叉树的性质 在二叉树的第i层上至多有2的i-1次方个结点（i>=1）,第i层上至少有1个结点 深度为k的二叉树至多有2^k -1 个结点（k>=1）,深度为k时至少有k个结点 对任何一颗二叉树T,如果其叶子结点数为n0,度为...
C语言数据结构学习笔记精要
资源摘要信息: "c语言数据结构（C语言描述）学习笔记.zip" 这份压缩包资源主要是关于C语言和数据结构的学习笔记，适合于希望在C语言环境中理解和实践数据结构概念的学生或开发者。在深入理解这些资源内容之前，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值