课后作业:
-
是否同一棵二叉搜索树 小白专场将详细介绍C语言实现方法,属于基本训练,一定要做;
-
Root of AVL Tree 2013年浙江大学计算机学院免试研究生上机考试真题,是关于AVL树的基本训练,一定要做;
-
Complete Binary Search Tree 2013年秋季PAT甲级真题,略有难度,量力而行。第7周将给出讲解。
-
二叉搜索树的操作集 用C语言的同学,可以在这里把老师讲过的各种操作都试用一下。
1.是否同一颗二叉搜索树
//注意,标志位在置位时,尽量将其设置为置1语句,不容易出错。
#include <stdio.h>
#include <stdlib.h>
#define ElementType int
typedef struct BSTNode *Position;
typedef Position BSTree; /* 二叉搜索树类型 */
struct BSTNode
{
ElementType Data; /* 结点数据 */
BSTree Left; /* 指向左子树 */
BSTree Right; /* 指向右子树 */
int flag; //结点被访问过的标志
};
BSTree MakeTree(int N); //根据输入建立一个二叉搜索树T,并返回首结点地址
BSTree Insert(BSTree T, ElementType v); //向二叉搜索树中插入一个结点v;
int Judge(BSTree T, int N); //判断输入序列与二叉搜索树T是否匹配,匹配返回1
int check(BSTree T, ElementType X); //在树T中搜索结点元素X,若所经过结点的flag标志为1,则继续向子树元素检查;若flag为0,且结点与x相等,则返回1
void ResetT(BSTree T); //重置树T中的标志数据flag
void FreeTree(BSTree T); //释放掉树T的空间
int main(void)
{
int N, L; // N是二叉树结点数,L是后面需要判断的序列个数
BSTree T;
scanf("%d", &N);
while (N)
{
scanf("%d", &L);
T = MakeTree(N);
for (int i = 0; i < L; i++)
{
if (Judge(T, N))
printf("Yes\n");
else
printf("No\n");
ResetT(T); //清楚T中标记falg
}
FreeTree(T);
scanf("%d", &N); //输入下一个判别序列的结点数N
}
return 0;
}
BSTree MakeTree(int N)
{ //建立第一颗树
BSTree T = (BSTree)malloc(sizeof(struct BSTNode));
T->flag = 0;
T->Left = NULL;
T->Right = NULL;
int v, i;
scanf("%d", &v);
T->Data = v;
for (i = 1; i < N; i++)
{
scanf("%d", &v);
T = Insert(T, v);
}
return T;
}
BSTree Insert(BSTree T, ElementType v)
{ //向二叉搜索树中插入一个结点v;
if (!T)
{
T = (BSTree)malloc(sizeof(struct BSTNode));
T->Data = v;
T->flag = 0;
T->Left = NULL;
T->Right = NULL;
}
else
{
if (v > T->Data)
T->Right = Insert(T->Right, v);
else
T->Left = Insert(T->Left, v);
}
return T;
}
int Judge(BSTree T, int N) //判断是否匹配,匹配返回1
{
int v, flag = 0; // flag为不匹配标志位
scanf("%d", &v);
if (v != T->Data)
flag = 1;
else
T->flag = 1;
for (int i = 1; i < N; i++)
{
scanf("%d", &v);
if ((!flag) && (!check(T, v))) //存在不匹配的情况
flag = 1;
}
if (flag)
return 0;
else
return 1;
}
int check(BSTree T, ElementType X)
//在树T中搜索结点元素X,若所经过结点的flag标志为1,则继续向子树元素检查;若flag为0,且结点与x相等,则返回1
{
if (T->flag) //结点元素被访问过
{
if (X > T->Data)
return check(T->Right, X);
else if (X < T->Data)
return check(T->Left, X);
else
return 0;
}
else //结点元素没有被访问过
{
if (X == T->Data)
{
T->flag = 1;
return 1;
}
else
return 0;
}
}
void ResetT(BSTree T)
{
if (T->Left)
ResetT(T->Left);
if (T->Right)
ResetT(T->Right);
T->flag = 0;
}
void FreeTree(BSTree T)
{
if (T->Left)
FreeTree(T->Left);
if (T->Right)
FreeTree(T->Right);
free(T);
}
//测试输入:
// 4 2
// 3 1 4 2
// 3 4 1 2
// 3 2 4 1
// 2 1
// 2 1
// 1 2
// 0
//测试输出
// Yes
// No
// No
2.Root of AVL Tree
//输入一个序列,按照平衡二叉树原则进行插入,并找到它的根节点
//思路:每次插入一个结点,更新每个结点的平衡因子,找到“发现者”,并判断需要进行哪种处理。
#include <stdio.h>
#include <stdlib.h>
#define ElementType int
typedef struct AVLNode *Position;
typedef Position AVLTree; /* AVL树类型 */
struct AVLNode
{
ElementType Data; /* 结点数据 */
AVLTree Left; /* 指向左子树 */
AVLTree Right; /* 指向右子树 */
int Height; /* 树高 */
};
int Max(int a, int b);
AVLTree SingleLeftRotation(AVLTree A);
AVLTree SingleRightRotation(AVLTree A);
AVLTree DoubleLeftRightRotation(AVLTree A);
AVLTree DoubleRightLeftRotation(AVLTree A);
AVLTree Insert(AVLTree T, ElementType X);
int GetHeight(AVLTree BT);
int main(void)
{
int N, v; // N为输入结点个数,v表示每次输入数据。
scanf("%d", &N);
AVLTree T=NULL;
for (int i = 0; i < N; i++)
{
scanf("%d", &v);
T=Insert(T, v);
}
printf("%d\n", T->Data);
return 0;
}
int Max(int a, int b)
{
return a > b ? a : b;
}
AVLTree SingleLeftRotation(AVLTree A)
{ /* 注意:A必须有一个左子结点B */
/* 将A与B做左单旋,更新A与B的高度,返回新的根结点B */
AVLTree B = A->Left;
A->Left = B->Right;
B->Right = A;
A->Height = Max(GetHeight(A->Left), GetHeight(A->Right)) + 1;
B->Height = Max(GetHeight(B->Left), A->Height) + 1;
return B;
}
//右单旋,自己补充
AVLTree SingleRightRotation(AVLTree A)
{ /* 注意:A必须有一个右子结点B */
/* 将A与B做右单旋,更新A与B的高度,返回新的根结点B */
AVLTree B = A->Right;
A->Right = B->Left;
B->Left = A;
A->Height = Max(GetHeight(A->Left), GetHeight(A->Right)) + 1;
B->Height = Max(GetHeight(B->Left), A->Height) + 1;
return B;
}
AVLTree DoubleLeftRightRotation(AVLTree A)
{ /* 注意:A必须有一个左子结点B,且B必须有一个右子结点C */
/* 将A、B与C做两次单旋,返回新的根结点C */
/* 将B与C做右单旋,C被返回 */
A->Left = SingleRightRotation(A->Left);
/* 将A与C做左单旋,C被返回 */
return SingleLeftRotation(A);
}
//右-左双旋,自己补充
AVLTree DoubleRightLeftRotation(AVLTree A)
{ /* 注意:A必须有一个右子结点B,且B必须有一个左子结点C */
/* 将A、B与C做两次单旋,返回新的根结点C */
/* 将B与C做左单旋,C被返回 */
A->Right = SingleLeftRotation(A->Right);
/* 将A与C做左单旋,C被返回 */
return SingleRightRotation(A);
}
/*************************************/
/* 对称的右单旋与右-左双旋请自己实现 */
/*************************************/
AVLTree Insert(AVLTree T, ElementType X)
{ /* 将X插入AVL树T中,并且返回调整后的AVL树 */
if (!T)
{ /* 若插入空树,则新建包含一个结点的树 */
T = (AVLTree)malloc(sizeof(struct AVLNode));
T->Data = X;
T->Height = 0;
T->Right = NULL;
T->Left = NULL;
} /* if (插入空树) 结束 */
else if (X < T->Data)
{
/* 插入T的左子树 */
T->Left = Insert(T->Left, X);
/* 如果需要左旋 */
if (GetHeight(T->Left) - GetHeight(T->Right) == 2)
if (X < T->Left->Data)
T = SingleLeftRotation(T); /* 左单旋 */
else
T = DoubleLeftRightRotation(T); /* 左-右双旋 */
} /* else if (插入左子树) 结束 */
else if (X > T->Data)
{
/* 插入T的右子树 */
T->Right = Insert(T->Right, X);
/* 如果需要右旋 */
if (GetHeight(T->Left) - GetHeight(T->Right) == -2)
if (X > T->Right->Data)
T = SingleRightRotation(T); /* 右单旋 */
else
T = DoubleRightLeftRotation(T); /* 右-左双旋 */
} /* else if (插入右子树) 结束 */
/* else X == T->Data,无须插入 */
/* 别忘了更新树高 */
T->Height = Max(GetHeight(T->Left), GetHeight(T->Right)) + 1;
return T;
}
// 求二叉树的高度。
int GetHeight(AVLTree BT)
{
int HL, HR, MaxH;
if (BT)
{
HL = GetHeight(BT->Left); /*求左子树的深度*/
HR = GetHeight(BT->Right); /*求右子树的深度*/
MaxH = (HL > HR) ? HL : HR; /*取左右子树较大的深度*/
return (MaxH + 1); /*返回树的深度*/
}
else
return 0; /* 空树深度为0 */
}
//输入
// 7
// 88 70 61 96 120 90 65
//输出
// 88
3.Complete Binary Search Tree
//没写出来,等后面听完讲解再补充。
//2022.11.03补充
/*题意:给定一个整数序列,建立成为一个完全二叉搜索树CBST,并按照层序遍历的方法进行打印*/
/*思路:1.因为是完全二叉树形式,并且进行层序遍历,可以采用数组存储*/
/*2.将输入序列按照大小顺序排序,在CBST中,左子树结点值一定都小于根结点值,右子树结点值一定都大于根结点值*/
/*3.找到根结点的位置:根据元素个数n,计算层数和左子树节点个数,从而确定根结点位置,利用递归的方法得到完整的CBST*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define ElementType int
#define MaxSize 10000
int A[MaxSize]; /*保存输入的数据*/
int T[MaxSize]; /*保存完全二叉搜索树数据*/
int compare(const void *a, const void *b); /*对数字排序需要用到的程序*/
void solve(int ALeft, int ARight, int TRoot); /*输入树左右边界序号,及根结点序号,找出根结点元素,并递归*/
int GetLeftLength(int n); /*计算完全二叉树(结点数n)的左子树结点数目*/
int main(void)
{
int N, i, TRoot;
scanf("%d", &N);
for (i = 0; i < N; i++)
scanf("%d", &A[i]);
qsort(A, N, sizeof(int), compare);
solve(0, N - 1, 0);
/*打印层序遍历结果*/
for (i = 0; i < N - 1; i++)
{
printf("%d ", T[i]);
}
printf("%d", T[i]);
return 0;
}
int compare(const void *a, const void *b)
{ /*对数字排序需要用到的程序*/
return *(int *)a - *(int *)b;
}
void solve(int ALeft, int ARight, int TRoot)
{ /*输入树左右边界序号,及根结点序号,找出根结点元素,并递归;初始调用为 solve(0, N-1, 0) */
int n, L, LeftTRoot, RightTRoot;
n = ARight - ALeft + 1; /*当前序列长度*/
if (n == 0)
return;
L = GetLeftLength(n); /*计算完全二叉树(结点数n)的左子树结点数目*/
T[TRoot] = A[ALeft + L];
LeftTRoot = 2 * TRoot + 1;
RightTRoot = LeftTRoot + 1;
solve(ALeft, ALeft + L - 1, LeftTRoot);
solve(ALeft + L + 1, ARight, RightTRoot);
}
int GetLeftLength(int n)
{ /*计算完全二叉树(结点数n)的左子树结点数目*/
int i, count = 0;
for (i = 0; count < n;)
{
i++;
count = count + pow(2, i - 1);
}
if (count == n) /*树高为i,满二叉树*/
return pow(2, i - 1) - 1; /*左子树结点个数2^(i-1)-1*/
else if (count > n) /*树高为i,完全二叉树*/
{
int item; /*最后一层属于左子树的结点数*/
if ((n - (pow(2, i - 1) - 1)) > pow(2, i - 2)) /*最后一层结点多于一半*/
item = pow(2, i - 2);
else
item = n - (pow(2, i - 1) - 1);
return item + pow(2, i - 2) - 1; /*左满二叉子树层数为i-2*/
}
}
/*input test*/
// 10
// 1 2 3 4 5 6 7 8 9 0
/*output*/
// 6 3 8 1 5 7 9 0 2 4
注意:排序函数qsort的用法;
4.二叉搜索树的操作集
//二叉搜索树5种常用操作的实现
// 01插入元素
BinTree Insert(BinTree BST,ElementType X)
{
if (!BST) //如果结点为空,则申请空间存放要插入的元素X
{
BST = (BinTree)malloc(sizeof(struct TNode));
BST->Data = X;
BST->Left = NULL;
BST->Right = NULL;
}
//开始插入元素,X插入左子树,X插入右子树,X已经存在
else if (X < BST->Data)
BST->Left = Insert(BST->Left, X);
else if (X > BST->Data)
BST->Right = Insert(BST->Right, X);
return BST;
}
// 02二叉搜索树删除元素:情况1删除叶结点,直接删除,修改父结点指针;情况2删除只有一个孩子的结点,将其父结点指向该结点的孩子结点;
//情况3删除有两个孩子的结点,搜索其左子树的最大元素或右子树的最小元素,替代要删除的结点元素,并在左子树中删除该元素。
BinTree Delete(BinTree BST,ElementType X)
{
BinTree temp;
if (!BST)
printf("Not Found\n");
else if (X < BST->Data)
BST->Left=Delete(BST->Left, X); //左子树递归删除
else if (X > BST->Data)
BST->Right=Delete(BST->Right, X); //右子树递归删除
//找到要删除的结点元素
else if (BST->Left && BST->Right) //情况3左右子树都存在
{
temp = FindMin(BST->Right); //找到右子树中的最小元素
BST->Data = temp->Data;
BST->Right = Delete(BST->Right, temp->Data); //在右子树中删除该结点元素
}
else
{
temp = BST;
if (!BST->Left) //情况2没有左子树(只有右子树或没有子树)
{
// BST->Data = BST->Right->Data;
// BST->Left = BST->Right->Left;
// BST->Right = BST->Right->Right;
//不能这样用,BST指针存储当前要删除的结点的地址,而父结点保存的是当前结点的指针地址变量,即BST;
// 故可以直接更改BST指针所保存的内容,来实现更改删除该结点。
BST = BST->Right;
}
else if (!BST->Right) //情况2只有左子树
{
BST = BST->Left;
}
free(temp);
}
return BST;
}
// 03查找操作Find(递归实现)
Position Find(BinTree BST,ElementType X)
{
if (!BST)
return NULL;
if (X > BST->Data)
return Find(BST->Right,X); //在右子树中继续查找
else if (X < BST->Data)
return Find(BST->Left,X); //在左子树中继续查找
else
return BST; //查找成功,返回结点的找到结点的地址
}
// 04递归查找最小元素
Position FindMax(BinTree BST)
{
if (!BST)
return NULL; //空树,返回NULL
else if (!BST->Right)
return BST;
else
return FindMax(BST->Right);
}
// 05递归查找最小元素
Position FindMin(BinTree BST)
{
if (!BST)
return NULL; //空树,返回NULL
else if (!BST->Left)
return BST;
else
return FindMin(BST->Left);
}
结束
课程来源:浙江大学数据结构慕课MOOC