当前位置：首页 > news >正文

#数据结构笔记三

news 来源：原创 2024/7/7 16:21:26

二叉树

1. 概念

二叉树Binary Tree是n个结点的有限集合。它或者是空集n=0，或者是由一个根结点以及两颗互不相交、分别称为左子树和右子树的二叉树组成。

二叉树与普通有序树不同，二叉树严格区分左子和右子，即使只有一个子结点也要区分左右。

二叉树的树度数最大为2。

2. 性质*

关于树的一些基本念

(1)度数：一个节点的子树的个数(一个节点的子树的个数称为该节点的度数,3)

(2)树度数：树中节点的最大度数

(3)叶节点或终端节点: 度数为零的节点

(4)分支节点：度数不为零的节点(B一层)

(5)内部节点：除根节点以外的分支节点（B，C，D）

(6)节点层次: 根节点的层次为1，根节点子树的根为第2层，以此类推

(7)树的深度或高度: 树中所有节点层次的最大值（4）

二叉树的第k层上的结点最多个2k-1个
深度为k的二叉树最多有2k-1个结点

Sn=a1(1-qn)/(1-q)=a1(1-2k)/(1-2)=(1-2k)/-1=2k-1

在任意一颗二叉树中，树叶的数目比度数为2的结点数目多1。

N：结点的总数

N0：没有子结点的结点个数

N1：只有一个子结点的结点个数

N2：有两个子结点的结点个数

总结点 = 各节点数目之和 N = N0 + N1 + N2

总结点 = 所有子节点 + 根 N = 0 × N0 + 1 × N1 + 2 × N2 + 1

联立以上两式可得： N0 = N2 + 1

(网易)一棵二叉树有8个度为2的节点，5个度为1的节点，那么度为0的节点个数为 ( 9 )

满二叉树和完全二叉树

满二叉树：深度为k(k>=1)时，第k层结点个数为2k-1

完全二叉树：只有最下面两层有度数小于2的节点，且最下面一层的结点集中在最左边的若干位置上。

3. 实现

二叉树的存储结构有两种，分为顺序存储和链式存储

3.1. 顺序存储

二叉树的顺序存储，指的是使用顺序表（数组）存储二叉树。需要注意，顺序存储只适用于完全二叉树。换句话说，只有完全二叉树才可以用顺序表存储。因此，如果我们想要顺序存储普通二叉树，就需要将其提前转换成完全二叉树。

普通二叉树转完全二叉树的方法很简单，只需给二叉树额外添加一些结点，将其"拼凑"成一个完全二叉树即可。

如图所示：

：

左侧是普通二叉树，右侧是转化后的完全(满)二叉树。

完全(满)二叉树的顺序存储，仅需要从根结点开始，按照层次依次将树中结点存储到数组即可。

存储图 2 所示的完全二叉树：

存储由普通二叉树转化来的完全二叉树也是如此。

图 1 中普通二叉树在顺组中的存储状态如图：

完全二叉树中结点按照层次并从左到右依次编号（123...），若结点i有左子，则其左子的结点编号为2*i，右子编号为2*i+1。

设完全二叉树的结点数为n，某结点的编号为i。

当i>1时(不是根结点时)，有父节点，其编号为i/2。

当2*i <= n时，有左子，其编号为2*i，否则没有左子，没左子一定没右子，其本身为叶节点。

当2*i+1 <= n时，有右子，其编号为2*i+1，否则就没有右子。

3.1.1. 遍历*

先序：根----->左----->右

A B D H I E J C F K G

中序：左----->根----->右

H D I B E J A F K C G

后序：左----->右----->根

H I D J E B K F G C A

已知遍历结果如下，试画出对应的二叉树，写出后续：

先序：A B C E H F I J D G K 根----->左----->右

中序：A H E C I F J B D K G 左----->根----->右

因为先序是根在最前面的，所以在先序中从前往后地取结点拿到中序中作为根，循环重复。

3.2. 链式存储

链式存储此二叉树，从根结点开始，将各个结点以及其左右子的地址使用链表进行存储。

3.2.1. 定义操作完全二叉树结构体*

结点结构体由三部分组成：

指向左子结点的指针(Lchild)
结点存储的数据（结点编号）
指向右子结点的指针(Rchild)

// 1. 定义操作二叉树的结构体
typedef char datatype_tree;
typedef struct tree_node_t
{datatype_tree data;//数据域struct tree_node_t *lchild;//左子left struct tree_node_t *rchild;//右子right 
}bitree_node_t,*bitree_list_t;

3.2.2. 创建二叉树*

#include "bitree.h"// 2. 创建二叉树
// 主函数传参 n 树中结点总数; i 结点编号(从1开始)
bitree_list_t CreateBitree(int n,int i)
{// 2.1 开辟空间存放结构体bitree_list_t r = (bitree_list_t)malloc(sizeof(bitree_node_t));if(NULL == r){printf("CreateBitree malloc failed\n");return NULL;}// 2.2 初始化结构体成员// 2.3 判断有无左右子// 2.3.1 有左子r->data = i;if(2 * i <= n){r->lchild = CreateBitree(n,2*i);}// 2.3.2 无左子else{r->lchild = NULL;}// 2.3.3 有右子if(2*i + 1 <= n){r->rchild = CreateBitree(n,2*i+1);}// 2.3.4 无右子else{r->rchild = NULL;}return r;
}#include "bitree.h"
int main(int argc, const char *argv[])
{bitree_node_t *r = CreateBitree(3,1);return 0;
}

3.2.3. 先序遍历*

//前序
// 3. 先序遍历二叉树
// 根——左——右
void PreOrder(bitree_list_t r)
{if(NULL == r)return;printf("%d ",r->data);							 // 根// 如果有左子，则将左子作为根将该函数的全部操作走一遍if(r->lchild != NULL)							 // 左PreOrder(r->lchild);
// 如果有右子，则将右子作为根将该函数的全部操作走一遍if(r->rchild != NULL)PreOrder(r->rchild);						 // 右
}

3.2.4. 中序遍历

// 4. 中序遍历
// 左——根——右
void InOrder(bitree_list_t r)
{if(NULL == r)return;// 如果有左子，则将左子作为根将该函数的全部操作走一遍if(r->lchild != NULL)								 // 左InOrder(r->lchild);printf("%d ",r->data);								 // 根// 如果有右子，则将右子作为根将该函数的全部操作走一遍if(r->rchild != NULL)InOrder(r->rchild);									 // 右
}

3.2.5. 后序遍历

// 5. 后序遍历
// 左——右——根
void PostOrder(bitree_list_t r)
{if(NULL == r)return;// 如果有左子，则将左子作为根将该函数的全部操作走一遍if (r->lchild != NULL)                           // 左PostOrder(r->lchild);// 如果有右子，则将右子作为根将该函数的全部操作走一遍if (r->rchild != NULL)                           // 右PostOrder(r->rchild);printf("%d\t", r->data);                         // 根
}

总结：

#include "bitree.h"
bitree_list_t CreateBitree(int n,int i)
{bitree_list_t r = (bitree_list_t)malloc(sizeof(bitree_node_t));if(NULL == r){printf("CreateBitree malloc failed\n");return NULL;}r->data = i;if(2 * i <= n){r->lchild = CreateBitree(n,2*i);}else{r->lchild = NULL;}if(2*i + 1 <= n){r->rchild = CreateBitree(n,2*i+1);}else{r->rchild = NULL;}return r;
}
//前序
void PreOrder(bitree_list_t r)
{if(NULL == r)return;printf("%d ",r->data);if(r->lchild != NULL)PreOrder(r->lchild);if(r->rchild != NULL)PreOrder(r->rchild);
}
//中序
void InOrder(bitree_list_t r)
{if(NULL == r)return;if(r->lchild != NULL)InOrder(r->lchild);printf("%d ",r->data);if(r->rchild != NULL)InOrder(r->rchild);
}
//后序
void PostOrder(bitree_list_t r)
{if(NULL == r)return;if(r->lchild != NULL)PostOrder(r->lchild);if(r->rchild != NULL)PostOrder(r->rchild);printf("%d ",r->data);}

#include "bitree.h"
int main(int argc, const char *argv[])
{	bitree_node_t *r = CreateBitree(3,1);PreOrder(r);	printf("\n");InOrder(r);printf("\n");PostOrder(r);printf("\n");return 0;
}

#ifndef _BITREE_H_
#define _BITREE_H_
#include <stdio.h>
#include <stdlib.h>
typedef char datatype_tree;
typedef struct tree_node_t
{datatype_tree data;//数据域struct tree_node_t *lchild;//左子left struct tree_node_t *rchild;//右子right 
}bitree_node_t,*bitree_list_t;
bitree_list_t CreateBitree(int n,int i);
//前序
void PreOrder(bitree_list_t r);
//中序
void InOrder(bitree_list_t r);
//后序
void PostOrder(bitree_list_t r);
//层次
void unOrder(bitree_list_t r);
#endif

3.2.6. 层序遍历

队列的思想

不需要敲代码，看懂就行

示意图

#ifndef _BITREE_H_
#define _BITREE_H_
typedef char datatype_tree;
typedef struct tree_node_t
{datatype_tree data;//数据域 struct tree_node_t *lchild;//左子指针struct tree_node_t *rchild;//右子指针
}bitree_t;
//前序遍历
void preOrder(bitree_t *r);//r二叉树根节点的指针
//中序遍历
void inOrder(bitree_t * r);
//后序遍历
void postOrder(bitree_t *r);
//遍历二叉树 
//s 代表的是打印提示, void (*p)(bitree_t *)函数指针  r遍历的树
void showBitree(char *s,void (*p)(bitree_t *),bitree_t *r);
//创建二叉树,用递归函数创建
bitree_t *createBitree();
//层次遍历
void unOrder(bitree_t *r);
#endif

#ifndef _LINKQUEUE_H_
#define _LINKQUEUE_H_#include "bitree.h"//将 bitree_t * 改名 为datatype_linkqueue 
typedef bitree_t * datatype_linkqueue;//把队列的数据域变成指向树节点的指针
typedef struct node
{datatype_linkqueue data;//数据域struct node *next;//指针域
}linkqueue_node_t,*linkqueue_list_t;//linkqueue_list_t p === linkqueue_node_t *
typedef struct//将队列头指针和尾指针封装到一个结构体里
{linkqueue_list_t front;//相当于队列的头指针linkqueue_list_t rear;//相当于队列的尾指针//有了链表的头指针和尾指针，那么我们就可以操作这个链表
}linkqueue_t;//1.创建一个空的队列
linkqueue_t *createEmptyLinkQueue();
//2.入列 data代表入列的数据
int inLinkQueue(linkqueue_t *p,datatype_linkqueue data);
//3.出列 
datatype_linkqueue outLinkQueue(linkqueue_t *p);
//4.判断队列是否为空
int isEmptyLinkQueue(linkqueue_t *p);
//5.求队列长度的函数
int lengthLinkQueue(linkqueue_t *p);
//6.清空队列
void clearLinkQueue(linkqueue_t *p);
#endif

#include "bitree.h"
#include "linkqueue.h"
#include <stdio.h>
#include <stdlib.h>
//前序遍历
void preOrder(bitree_t *r)//r二叉树根节点的指针
{if(r == NULL)//递归函数的结束条件return;printf("%c ",r->data);//根preOrder(r->lchild);//左preOrder(r->rchild);//右
}
//中序遍历
void inOrder(bitree_t * r)
{if(r == NULL)//递归的结束条件return;inOrder(r->lchild);//左printf("%c ",r->data);//根inOrder(r->rchild);//右
}
//后序遍历
void postOrder(bitree_t *r)
{if(r == NULL)//递归函数的结束条件return;postOrder(r->lchild);//左postOrder(r->rchild);//右printf("%c ",r->data);//根
}
//遍历二叉树 
//s 代表的是打印提示, void (*p)(bitree_t *)函数指针  r遍历的树
void showBitree(char *s,void (*p)(bitree_t *),bitree_t *r)
{printf("%s",s);p(r);printf("\n");
}
//创建二叉树,用递归函数创建
bitree_t *createBitree()
{//root 
//	ABD###CE##F##bitree_t *r = NULL;//用来保存二叉树的根节点char ch;scanf("%c",&ch);if(ch == '#')//输入是'#'，代表没有左子或右子return NULL;r = (bitree_t *)malloc(sizeof(bitree_t));if(NULL == r){perror("r malloc failed");return NULL;}r->data = ch;r->lchild = createBitree();r->rchild = createBitree();return r;
}//层次遍历
void unOrder(bitree_t *r)
{//1.创建一个队列,队列的数据域变成指向树节点的指针linkqueue_t *p = createEmptyLinkQueue();if(r != NULL)inLinkQueue(p,r);//2.循环打印while(!isEmptyLinkQueue(p)){r = outLinkQueue(p);printf("%c ",r->data);if(r->lchild != NULL)//只要左子不为空，就入列，之后出列的时候打印inLinkQueue(p,r->lchild);if(r->rchild != NULL)//只要右子不为空，就入列，之后出列的时候打印inLinkQueue(p,r->rchild);}
}

#include "linkqueue.h"
#include <stdio.h>
#include <stdlib.h>//1.创建一个空的队列
linkqueue_t *createEmptyLinkQueue()
{linkqueue_t *p = (linkqueue_t *)malloc(sizeof(linkqueue_t));if(NULL == p){perror("createEmptyLinkQueue p malloc failed");return NULL;}//申请空间就是为了装东西//申请链表的头节点空间，让rear和front都指向头结点p->front = p->rear = (linkqueue_list_t)malloc(sizeof(linkqueue_node_t));if(NULL == p->rear){perror("p->rear malloc failed");return NULL;}p->rear->next = NULL;//或者用p->front->next = NULL;因为p->rear 和 p->front 指向同一个位置即头节点return p;
}
//2.入列 data代表入列的数据
int inLinkQueue(linkqueue_t *p,datatype_linkqueue data)
{//1.创建一个新的节点，用来保存即将插入的数据linkqueue_list_t pnew = (linkqueue_list_t)malloc(sizeof(linkqueue_node_t));if(NULL == pnew){perror("inLinkQueue pnew malloc failed");return -1;}//2.将入列的数据放入到新的节点中pnew->data = data;pnew->next = NULL;//3.将新节点链链接到链表的尾巴p->rear->next = pnew;//新节点链接到链表的尾p->rear = pnew;//rear移动，因为rear永远指向当前链表的尾return 0;
}
//3.出列 
datatype_linkqueue outLinkQueue(linkqueue_t *p)
{linkqueue_list_t pdel = NULL;//指向被删除的节点//1.容错判断if(isEmptyLinkQueue(p)){printf("isEmptyLinkQueue !!\n");return NULL;}//2.出列数据//(1)定义pdel指向即将被删除的节点就是front指向的节点，出列每次删除的都是front指向的那个节点pdel = p->front;//(2)将front向后移动一个位置p->front = p->front->next;//(3)释放被删除节点free(pdel);pdel = NULL;//(4)将数据出列return p->front->data;
}
//4.判断队列是否为空
int isEmptyLinkQueue(linkqueue_t *p)
{return p->front == p->rear;
}
//5.求队列长度的函数
int lengthLinkQueue(linkqueue_t *p)
{int len = 0;linkqueue_list_t h = p->front;//将链表的头指针保存的地址给h,如果直接用front，求长度之后会找不到链表的头，用h的移动代替front的移动//求长度，相当于遍历有头的单向链表while(h->next != NULL){h = h->next;len++;}return len;
}
//6.清空队列
void clearLinkQueue(linkqueue_t *p)
{while(!isEmptyLinkQueue(p))//只要不为空，就出列outLinkQueue(p);
}

#include "bitree.h"
#include <stdio.h>
#include <stdlib.h>int main(int argc, const char *argv[])
{bitree_t *r = createBitree();showBitree("前序:",preOrder,r);showBitree("中序:",inOrder,r);showBitree("后序:",postOrder,r);showBitree("层次:",unOrder,r);return 0;
}