2.
顺序存储: 完全二叉树和满二叉树是可以通过顺序表来存储的,这是因为他们两种二叉树有一个特点,即,从根节点开始,一层一层的按照顺序依次放进顺
名词解释
节点: 每个元素
父子关系: 用来连线相邻节点之间的关系
父节点: A节点就是B节点的父节点
子节点: B节点就是A节点的子节点
兄弟节点: B、C、D这三个节点的父节点是同一个节点
根结点: 没有父节点的节点
叶子结点: 没有子节点的节点
节点的高度: 节点到叶子结点到最长路径(边数) (计数起点为0, 从下往上)
节点的深度: 根节点到这个节点经历过的边个数 (计数起点为0, 从上往下)
节点的层数: 节点到深度 + 1 (计数起点为1)
树的高度: 根节点的高度
特点
最常用的树数据结构
每个节点最多有两个子节点(左子节点、右子节点)
满二叉树: 叶子节点全都在最底层，除了叶子节点之外，每个节点都有左右两个子节点
完全二叉树: 叶子节点都在最底下两层，最后一层的叶子节点都 靠左排列 ，并且除了最后一层，其他层的节点个数都要达到最大
二叉树存储方式
数组顺序存储法
通过数组下标来顺序存储数据 (i表示当前节点深度,从0开始)
根节点: i = 1，左节点:2 * i，右节点: 2 * i + 1，父节点: i / 2
完全二叉树采用此方式节省内存空间
链式存储法
每个节点需要存储三分数据:当前节点数据、左节点指针、右节点指针,比较占用空间
遍历
常用方式
前序遍历: 树任意节点，先打印当前节点，再打印它的左子树，最后打印它的右子树
中序遍历: 树任意节点，先打印它的左子树，再打印当前节点，最后打印它的右子树
后序遍历: 树任意节点，先打印它的左子树，再打印它的右子树，最后打印当前节点
二叉树的前、中、后序遍历就是一个递归的过程
时间复杂度是O(n)
每个节点最多被访问两次，遍历 *** 作的时间复杂度跟节点的个数n成正比
特点
二叉查找树为实现快速查找而生，支持快速查找一个数据、快速插入、快速删除一个数据
特殊结构: 其左子树每个节点的值 <树的任意一个节点的值 <其右子树每个节点的值
先取根节点，如果它等于要查找的数据，那就返回。
如果要查找的数据比根节点的值小，那就在左子树中递归查找；
如果要查找的数据比根节点的值大，那就在右子树中递归查找
一般插入的数据在叶子节点上，从根节点开始依次比较要插入的数据和节点的大小关系
如果插入数据比节点的数值大，并且节点的右子树为空，将新数据插到右子节点位置；
如果不为空，就再递归遍历右子树，查找插入位置。
如果插入数据比节点的数值小，并且节点的左子树为空，将新数据插到左子节点位置；
如果不为空，就再递归遍历左子树，查找插入位置。
针对要删除节点的子节点个数的不同，需分三种情况来处理
1.如果要删除的节点没有子节点，步骤如下: (如图中的删除节点55)
只需将父节点中指向要删除节点的指针置为null
2.如果要删除的节点只有一个子节点，步骤如下: (如图中删除节点13)
只需将父节点中指向要删除节点的指针，让它指向要删除节点的子节点即可
3.如果要删除的节点有两个子节点，步骤如下: (如图中的删除节点18)
首先，需要找到这个节点的右子树中的最小节点，把它替换到要删除的节点上；
然后，再删除掉这个最小节点，因为最小节点肯定没有左子节点
删除 *** 作，有个优化方案: 就是单纯将要删除的节点标记为“已删除”，
这种方案删除 *** 作就变简单很多，但是比较浪费内存空间
支持快速地查找最大节点和最小节点、前驱节点和后继节点
另外一种重要特性:
中序遍历二叉查找树，可以输出有序的数据序列，时间复杂度为O(n)
因此，二叉查找树也叫作二叉排序树
以上几种 *** 作都默认树中节点存储的都是数字，而且都是不存在键值相同的情况
实际应用场景中采用对象的某个字段作为键值来构建二叉查找树，其他字段称为卫星数据
如果存储的两个对象键值相同，两种解决方案
1.把值相同的数据都存储在同一个节点(采用链表或支持动态扩容的数组等数据结构)
2.每个节点只存储一个数据，把这个新插入的数据当作大于这个节点的值来处理，如下图:
查找 *** 作
当查找数据时遇到值相同的节点，继续在右子树中查找，直到遇到叶子节点才停止。
这样就把键值等于要查找值的所有节点都查找出来
删除 *** 作
先查找到每个要删除的节点，然后再按前面讲的删除 *** 作的方法，依次删除
对于同一组数据可构造不同二叉查找树。查找、插入、删除 *** 作的执行效率都不一样
图最左边树，根节点的左右子树极度不平衡，退化成链表，查找时间复杂度为O(n)
最理想的情况，二叉查找树是一棵完全二叉树（或满二叉树）
时间复杂度都跟树的高度成正比，也就是O(height)
树的高度就等于最大层数减一，为了方便计算，我们转换成层来表示
满二叉树: 下一层节点个数是上一层的2倍，第K层包含节点个数就是2^(K-1)
完全二叉树: 假设最大层数是L，总的节点个数n，它包含的节点个数在1个到2^(L-1)个之间
L的范围是[ , +1]，完全二叉树的高度小于等于
极度不平衡的二叉查找树，它的查找性能肯定不能满足我们的需求
平衡二叉查找树: 树的高度接近logn，时间复杂度较稳定为O(logn)
1.排序对比
散列表中的数据是无序存储的，如果要输出有序的数据，需要先进行排序
二叉查找树只需要中序遍历，就可以在O(n)的时间复杂度内，输出有序的数据序列
2.性能稳定性对比
散列表扩容耗时很多，而且当遇到散列冲突时，性能不稳定
最常用的平衡二叉查找树的性能非常稳定，时间复杂度稳定在O(logn)
3.时间复杂度对比
散列表查找等 *** 作时间复杂度是常量级，因存在哈希冲突，这个常量不一定比logn小
另外加上哈希函数的耗时，也不一定就比平衡二叉查找树的效率高
4.结构设计对比
散列表构造比较复杂，需要考虑:散列函数设计、冲突解决办法、扩容、缩容等
平衡二叉查找树只需要考虑平衡性，而且目前这个的解决方案较成熟、固定
5.空间复杂度
散列表: 避免过多散列冲突，装载因子不能太大，特别基于开放寻址法，否则浪费太多空间
（以下有一段代码，自己先看看学学吧）
数据结构C语言版 二叉树的顺序存储表示和实现
P126
编译环境：Dev-C++ 4.9.9.2
日期：2011年2月13日
*/
#include <stdio.h>
typedef char TElemType
// 二叉树的顺序存储表示
#define MAX_TREE_SIZE 100 // 二叉树的最大结点数
typedef TElemType SqBiTree[MAX_TREE_SIZE]// 0号单元存储根结点
typedef struct
{
int level, //结点的层
order //本层序号(按满二叉树计算)
}position
typedef int QElemType
// 队列的顺序存储结构(可用于循环队列和非循环队列)
#define MAXQSIZE 5 // 最大队列长度(对于循环队列，最大队列长度要减1)
typedef struct
{
QElemType *base// 初始化的动态分配存储空间 相当于一个数组
int front // 头指针,若队列不空,指向队列头元素，相当于一个数组下标
int rear // 尾指针,若队列不空,指向队列尾元素的下一个位置
// 相当于一个数组下标
}SqQueue
#define ClearBiTree InitBiTree // 在顺序存储结构中，两函数完全一样
TElemType Nil = ' '// 设空为字符型的空格符
// 构造空二叉树T。因为T是固定数组，不会改变，故不需要&
int InitBiTree(SqBiTree T)
{
int i
for(i=0i<MAX_TREE_SIZEi++)
T[i]=Nil// 初值为空
return 1
}
void DestroyBiTree()
{
// 由于SqBiTree是定长类型,无法销毁
}
// 按层序次序输入二叉树中结点的值(字符型或整型), 构造顺序存储的二叉树T
int CreateBiTree(SqBiTree T)
{
int i = 0, l
char s[MAX_TREE_SIZE]
printf("请按层序输入结点的值(字符)，空格表示空结点，结点数≤%d:\n",
MAX_TREE_SIZE)
printf("例如：abcefgh\n")
gets(s) // 输入字符串
l = strlen(s) // 求字符串的长度
for(i<li++) // 将字符串赋值给T
{
T[i]=s[i]
// 此结点(不空)无双亲且不是根,T[(i+1)/2-1] == Nil表示T[i]无双亲
if(i!=0 &&T[(i+1)/2-1] == Nil &&T[i] != Nil)
{
printf("出现无双亲的非根结点%c\n",T[i])
exit(0)
}
}
for(i=li<MAX_TREE_SIZEi++) // 将空赋值给T的后面的结点
T[i]=Nil
return 1
}
// 若T为空二叉树,则返回1,否则0
int BiTreeEmpty(SqBiTree T)
{
if(T[0]==Nil) // 根结点为空,则树空
return 1
else
return 0
}
// 返回T的深度
int BiTreeDepth(SqBiTree T)
{
int i,j=-1
for(i=MAX_TREE_SIZE-1i>=0i--) // 找到最后一个结点
if(T[i] != Nil)
break
i++// 为了便于计算
do
j++
while(i>=pow(2,j)) //i >pow(2, depth-1) &&i <= pow(2, depth)
return j //j = depth
}
// 当T不空,用e返回T的根,返回1否则返回0,e无定义
int Root(SqBiTree T,TElemType *e)
{
if(BiTreeEmpty(T)) // T空
return 0
else
{
*e=T[0]
return 1
}
}
// 返回处于位置e(层,本层序号)的结点的值
TElemType Value(SqBiTree T,position e)
{
// 将层、本层序号转为矩阵的序号
return T[((int)pow(2,e.level-1) - 1) + (e.order - 1)]
// ((int)pow(2,e.level-1) - 1)为该e.level的结点个数，
// (e.order - 1)为本层的位置
}
// 给处于位置e(层,本层序号)的结点赋新值value
int Assign(SqBiTree T,position e,TElemType value)
{
// 将层、本层序号转为矩阵的序号
int i = (int)pow(2,e.level-1) + e.order - 2
if(value != Nil &&T[(i+1)/2-1] == Nil) // 叶子非空值但双亲为空
return 0
else if(value == Nil &&(T[i*2+1] != Nil || T[i*2+2] != Nil))
// 双亲空值但有叶子（不空）
return 0
T[i]=value
return 1
}
// 若e是T的非根结点,则返回它的双亲,否则返回＂空＂
TElemType Parent(SqBiTree T,TElemType e)
{
int i
if(T[0]==Nil) // 空树
return Nil
for(i=1i<=MAX_TREE_SIZE-1i++)
if(T[i]==e) // 找到e
return T[(i+1)/2-1]
return Nil// 没找到e
}
// 返回e的左孩子。若e无左孩子,则返回＂空＂
TElemType LeftChild(SqBiTree T,TElemType e)
{
int i
if(T[0]==Nil) // 空树
return Nil
for(i=0i<=MAX_TREE_SIZE-1i++)
if(T[i]==e) // 找到e
return T[i*2+1]
return Nil// 没找到e
}
// 返回e的右孩子。若e无右孩子,则返回＂空＂
TElemType RightChild(SqBiTree T,TElemType e)
{
int i
if(T[0]==Nil) // 空树
return Nil
for(i=0i<=MAX_TREE_SIZE-1i++)
if(T[i]==e) // 找到e
return T[i*2+2]
return Nil// 没找到e
}
// 返回e的左兄弟。若e是T的左孩子或无左兄弟,则返回＂空＂
TElemType LeftSibling(SqBiTree T,TElemType e)
{
int i
if(T[0]==Nil) // 空树
return Nil
for(i=1i<=MAX_TREE_SIZE-1i++)
if(T[i] == e &&i%2 == 0) // 找到e且其序号为偶数(是右孩子)
return T[i-1]
return Nil// 没找到e
}
// 返回e的右兄弟。若e是T的右孩子或无右兄弟,则返回＂空＂
TElemType RightSibling(SqBiTree T,TElemType e)
{
int i
if(T[0]==Nil) // 空树
return Nil
for(i=1i<=MAX_TREE_SIZE-1i++)
if(T[i]==e&&i%2) // 找到e且其序号为奇数(是左孩子)
return T[i+1]
return Nil// 没找到e
}
// 把从q的j结点开始的子树移为从T的i结点开始的子树
// InsertChild()用到
void Move(SqBiTree q,int j,SqBiTree T,int i)
{
if(q[2*j+1] != Nil) // q的左子树不空
Move(q,(2*j+1),T,(2*i+1))// 把q的j结点的左子树移为T的i结点的左子树
if(q[2*j+2] != Nil) // q的右子树不空
Move(q,(2*j+2),T,(2*i+2))// 把q的j结点的右子树移为T的i结点的右子树
T[i]=q[j]// 把q的j结点移为T的i结点
q[j]=Nil// 把q的j结点置空
}
// 根据LR为0或1,插入c为T中p结点的左或右子树。p结点的原有左或
// 右子树则成为c的右子树
int InsertChild(SqBiTree T,TElemType p,int LR,SqBiTree c)
{
int j,k,i=0
for(j=0j<(int)pow(2,BiTreeDepth(T))-1j++) // 查找p的序号
if(T[j]==p) // j为p的序号
break
k=2*j+1+LR// k为p的左或右孩子的序号
if(T[k] != Nil) // p原来的左或右孩子不空
Move(T,k,T,2*k+2)// 把从T的k结点开始的子树移为从k结点的右子树开始的子树
Move(c,i,T,k)// 把从c的i结点开始的子树移为从T的k结点开始的子树
return 1
}
// 构造一个空队列Q
int InitQueue(SqQueue *Q)
{
(*Q).base=(QElemType *)malloc(MAXQSIZE*sizeof(QElemType)) //分配定长的空间，相当于一个数组
if(!(*Q).base) // 存储分配失败
exit(0)
(*Q).front=(*Q).rear=0 //初始化下标
return 1
}
// 插入元素e为Q的新的队尾元素
int EnQueue(SqQueue *Q,QElemType e)
{
if((*Q).rear>=MAXQSIZE)
{ // 队列满，增加1个存储单元
(*Q).base=(QElemType *)realloc((*Q).base,((*Q).rear+1)*sizeof(QElemType))
if(!(*Q).base) // 增加单元失败
return 0
}
*((*Q).base+(*Q).rear)=e
(*Q).rear++
return 1
}
// 若队列不空,则删除Q的队头元素,用e返回其值,并返回1,否则返回0
int DeQueue(SqQueue *Q,QElemType *e)
{
if((*Q).front==(*Q).rear) // 队列空
return 0
*e=(*Q).base[(*Q).front]
(*Q).front=(*Q).front+1
return 1
}
// 根据LR为1或0,删除T中p所指结点的左或右子树
int DeleteChild(SqBiTree T,position p,int LR)
{
int i
int k=1// 队列不空的标志
SqQueue q
InitQueue(&q)// 初始化队列，用于存放待删除的结点
i=(int)pow(2,p.level-1)+p.order-2// 将层、本层序号转为矩阵的序号
if(T[i]==Nil) // 此结点空
return 0
i=i*2+1+LR// 待删除子树的根结点在矩阵中的序号
while(k)
{
if(T[2*i+1]!=Nil) // 左结点不空
EnQueue(&q,2*i+1)// 入队左结点的序号
if(T[2*i+2]!=Nil) // 右结点不空
EnQueue(&q,2*i+2)// 入队右结点的序号
T[i]=Nil// 删除此结点
k=DeQueue(&q,&i)// 队列不空
}
return 1
}
int(*VisitFunc)(TElemType)// 函数变量
void PreTraverse(SqBiTree T,int e)
{
// PreOrderTraverse()调用
VisitFunc(T[e]) //先调用函数VisitFunc处理根
if(T[2*e+1]!=Nil) // 左子树不空
PreTraverse(T,2*e+1) //然后处理左子树
if(T[2*e+2]!=Nil) // 右子树不空
PreTraverse(T,2*e+2)
}
// 先序遍历T,对每个结点调用函数Visit一次且仅一次。
int PreOrderTraverse(SqBiTree T,int(*Visit)(TElemType))
{
VisitFunc=Visit
if(!BiTreeEmpty(T)) // 树不空
PreTraverse(T,0)
printf("\n")
return 1
}
// InOrderTraverse()调用
void InTraverse(SqBiTree T,int e)
{
if(T[2*e+1]!=Nil) // 左子树不空
InTraverse(T,2*e+1)
VisitFunc(T[e])
if(T[2*e+2]!=Nil) // 右子树不空
InTraverse(T,2*e+2)
}
// 中序遍历T,对每个结点调用函数Visit一次且仅一次。
int InOrderTraverse(SqBiTree T,int(*Visit)(TElemType))
{
VisitFunc=Visit
if(!BiTreeEmpty(T)) // 树不空
InTraverse(T,0)
printf("\n")
return 1
}
// PostOrderTraverse()调用
void PostTraverse(SqBiTree T,int e)
{
if(T[2*e+1]!=Nil) // 左子树不空
PostTraverse(T,2*e+1)
if(T[2*e+2]!=Nil) // 右子树不空
PostTraverse(T,2*e+2)
VisitFunc(T[e])
}
// 后序遍历T,对每个结点调用函数Visit一次且仅一次。
int PostOrderTraverse(SqBiTree T,int(*Visit)(TElemType))
{
VisitFunc = Visit
if(!BiTreeEmpty(T)) // 树不空
PostTraverse(T,0)
printf("\n")
return 1
}
// 层序遍历二叉树
void LevelOrderTraverse(SqBiTree T,int(*Visit)(TElemType))
{
int i=MAX_TREE_SIZE-1,j
while(T[i] == Nil)
i--// 找到最后一个非空结点的序号
for(j=0j<=ij++) // 从根结点起,按层序遍历二叉树
if(T[j] != Nil)
Visit(T[j])// 只遍历非空的结点
printf("\n")
}
// 逐层、按本层序号输出二叉树
void Print(SqBiTree T)
{
int j,k
position p
TElemType e
for(j=1j<=BiTreeDepth(T)j++)
{
printf("第%d层: ",j)
for(k=1k <= pow(2,j-1)k++)
{
p.level=j
p.order=k
e=Value(T,p)
if(e!=Nil)
printf("%d:%c ",k,e)
}
printf("\n")
}
}
int visit(TElemType e)
{
printf("%c ",e)
return 0
}
int main()
{
int i,j
position p
TElemType e
SqBiTree T,s
InitBiTree(T)
CreateBiTree(T)
printf("建立二叉树后,树空否？%d(1:是 0:否) 树的深度=%d\n",
BiTreeEmpty(T),BiTreeDepth(T))
i=Root(T,&e)
if(i)
printf("二叉树的根为：%c\n",e)
else
printf("树空，无根\n")
printf("层序遍历二叉树:\n")
LevelOrderTraverse(T,visit)
printf("中序遍历二叉树:\n")
InOrderTraverse(T,visit)
printf("后序遍历二叉树:\n")
PostOrderTraverse(T,visit)
printf("请输入待修改结点的层号 本层序号: ")
scanf("%d%d%*c",&p.level,&p.order)
e=Value(T,p)
printf("待修改结点的原值为%c请输入新值: ",e)
scanf("%c%*c",&e)
Assign(T,p,e)
printf("先序遍历二叉树:\n")
PreOrderTraverse(T,visit)
printf("结点%c的双亲为%c,左右孩子分别为",e,Parent(T,e))
printf("%c,%c,左右兄弟分别为",LeftChild(T,e),RightChild(T,e))
printf("%c,%c\n",LeftSibling(T,e),RightSibling(T,e))
InitBiTree(s)
printf("建立右子树为空的树s:\n")
CreateBiTree(s)
printf("树s插到树T中,请输入树T中树s的双亲结点 s为左(0)或右(1)子树: ")
scanf("%c%d%*c",&e,&j)
InsertChild(T,e,j,s)
Print(T)
printf("删除子树,请输入待删除子树根结点的层号 本层序号 左(0)或右(1)子树: ")
scanf("%d%d%d%*c",&p.level,&p.order,&j)
DeleteChild(T,p,j)
Print(T)
ClearBiTree(T)
printf("清除二叉树后,树空否？%d(1:是 0:否) 树的深度=%d\n",
BiTreeEmpty(T),BiTreeDepth(T))
i=Root(T,&e)
if(i)
printf("二叉树的根为：%c\n",e)
else
printf("树空，无根\n")
system("pause")
return 0
}
/*
输出效果：
请按层序输入结点的值(字符)，空格表示空结点，结点数≤100:
例如：abcefgh
abcdefgh
建立二叉树后,树空否？0(1:是 0:否) 树的深度=4
二叉树的根为：a
层序遍历二叉树:
a b c d e f g h
中序遍历二叉树:
h d b e a f c g
后序遍历二叉树:
h d e b f g c a
请输入待修改结点的层号 本层序号: 3 2
待修改结点的原值为e请输入新值: i
先序遍历二叉树:
a b d h i c f g
结点i的双亲为b,左右孩子分别为 , ,左右兄弟分别为d,
建立右子树为空的树s:
请按层序输入结点的值(字符)，空格表示空结点，结点数≤100:
例如：abcefgh
jk l
树s插到树T中,请输入树T中树s的双亲结点 s为左(0)或右(1)子树: i 0
第1层: 1:a
第2层: 1:b 2:c
第3层: 1:d 2:i 3:f 4:g
第4层: 1:h 3:j
第5层: 5:k
第6层: 9:l
删除子树,请输入待删除子树根结点的层号 本层序号 左(0)或右(1)子树: 2 1 0
第1层: 1:a
第2层: 1:b 2:c
第3层: 2:i 3:f 4:g
第4层: 3:j
第5层: 5:k
第6层: 9:l
清除二叉树后,树空否？1(1:是 0:否) 树的深度=0
树空，无根
请按任意键继续. . .
*/
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）