#include
#include "stdio.h"
#include "stdlib.h"
typedef struct TNode *Position;
typedef Position BinTree; // 二叉树类型
typedef char ElementType;
// 树结点定义
struct TNode {
ElementType Data; // 结点数据
BinTree Left; // 指向左子树
BinTree Right; // 指向右子树
};
// 中序遍历 左->中->右
void InorderTraversal(BinTree BT) {
if (BT) {
InorderTraversal(BT->Left);
printf("%c\t", BT->Data);
InorderTraversal(BT->Right);
}
}
// 先序遍历 中->左->右
void PreorderTraversal(BinTree BT) {
if (BT) {
printf("%c\t", BT->Data);
PreorderTraversal(BT->Left);
PreorderTraversal(BT->Right);
}
}
// 后序遍历 左->右->中
void PostorderTraversal(BinTree BT) {
if (BT) {
PostorderTraversal(BT->Left);
PostorderTraversal(BT->Right);
printf("%c\t", BT->Data);
}
}
// 定义队列中结点
struct QueueNode {
BinTree Data;
struct QueueNode * Next;
};
typedef struct QueueNode * QNode;
// 定义队列
struct Queue{
QNode Front, Rear; // 队列头尾指针
};
typedef struct Queue *LinkedQueue;
bool IsEmpty(LinkedQueue Q){
return (Q->Front == Q->Rear);
}
bool CreatQueue(LinkedQueue Q){
QNode node = malloc(sizeof(struct QueueNode));
if(node == NULL) return 0;
Q->Front = Q->Rear = node;
return true;
}
bool AddQueue(LinkedQueue Q,BinTree X){
QNode newNode = malloc(sizeof (struct QueueNode));
newNode->Data = X;
Q->Rear->Next = newNode;
Q->Rear = newNode;
return true;
}
BinTree DeleteQueue(LinkedQueue Q){
BinTree e = Q->Front->Next->Data;
QNode node = Q->Front->Next;
if(Q->Front==Q->Rear) Q->Front=Q->Rear=NULL;
Q->Front->Next = Q->Front->Next->Next;
if(Q->Rear == node) Q->Rear = Q->Front;
free(node);
return e;
}
// 层次遍历 从上到下,从左到右
void LevelorderTraversal(BinTree BT) {
LinkedQueue queue; //先搞一个队列
queue = malloc(sizeof (struct Queue));
BinTree node;
if(!BT) return;
CreatQueue(queue);
AddQueue(queue,BT);
// printf("run");
while (IsEmpty(queue)==0) { //不断重复,直到队列空为止
node = DeleteQueue(queue); //出队一个元素,打印值
printf("%c\t", node->Data);
if(node->Left) //如果存在左右孩子的话
AddQueue(queue, node->Left);
if(node->Right)
AddQueue(queue, node->Right);
}
}
int main() {
BinTree A = malloc(sizeof(struct TNode));
A->Data = 'A';
BinTree B = malloc(sizeof(struct TNode));
B->Data = 'B';
BinTree C = malloc(sizeof(struct TNode));
C->Data = 'C';
BinTree D = malloc(sizeof(struct TNode));
D->Data = 'D';
BinTree E = malloc(sizeof(struct TNode));
E->Data = 'E';
BinTree F = malloc(sizeof(struct TNode));
F->Data = 'F';
A->Left = B;
A->Right = C;
B->Left = D;
B->Right = E;
C->Right = F;
C->Left = NULL;
D->Left = NULL;
D->Right = NULL;
E->Left = NULL;
E->Right = NULL;
F->Left = NULL;
F->Right = NULL;
printf("中序遍历: ");
InorderTraversal(A);
printf("\n");
printf("先序遍历: ");
PreorderTraversal(A);
printf("\n");
printf("后序遍历: ");
PostorderTraversal(A);
printf("\n");
printf("层次遍历: ");
LevelorderTraversal(A);
}
// 输出叶结点
// 在先序遍历的基础上加上判断语句
void PreorderPrintLeaves(BinTree BT){
if(BT){
// 没有左子树和右子树的结点——叶子节点
if(BT->Left==NULL&&BT->Right==NULL){
printf("%c\t",BT->Data);
}
PreorderPrintLeaves(BT->Left);
PreorderPrintLeaves(BT->Right);
}
}
树的高度 = 左右子树中最高的再加一
左子树的高度 = 左右子树中最高的加一
右子树的高度 = 左右子树中最高的加一
// 输出树的高度
int GetHeight(BinTree BT){
int HL , HR , MaxH=0;
if(BT){
HL = GetHeight(BT->Left); // 左子树高度
HR = GetHeight(BT->Right); // 右子树高度
MaxH = HL>HR?HL:HR;
return (MaxH+1);
} else{
return 0; // 树为空
}
}
二叉搜索树满足以下性质
// 二叉搜索树查找(递归)
Position Find1(BinTree BST, ElementType X){
if(BST == NULL) return 0;
if(X>BST->Data)
return Find1(BST->Right,X);
else if(X<BST->Data)
return Find1(BST->Left,X);
else if(X==BST->Data)
return BST; // 查找成功,返回当前结点的地址
}
// 二叉搜索树查找(循环)
Position Find2(BinTree BST, ElementType X){
while(BST){
if(X>BST->Data)
BST = BST->Right;
else if (X<BST->Data)
BST = BST->Left;
else if (X == BST->Data)
break;
}
return BST;
}
// 二叉搜索树的插入
BinTree Insert(BinTree BST, ElementType X){
if(!BST){
BST = (BinTree) malloc(sizeof (struct TNode));
BST->Data = X;
BST->Right = NULL;
BST->Left = NULL;
} else{
if(X>BST->Data) BST->Right = Insert(BST->Right,X);
else if(X<BST->Data) BST->Left = Insert(BST->Left,X);
}
return BST;
最大值:最右分支的端结点上
最小值:最左分支的端结点上
// 二叉搜索树查找最小值
Position FindMin(BinTree BST){
if(BST){
while(BST->Left)
BST = BST->Left;
return BST;
}
}
// 二叉搜索树查找最大值
Position FindMax(BinTree BST){
if(BST){
while(BST->Right)
BST = BST->Right;
return BST;
}
}
考虑三种情况
BinTree Delete(BinTree BST, ElementType X){
Position tmp;
if(BST == NULL) printf("未找到删除元素");
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){ // 删除的结点有左右子树
tmp = FindMin(BST->Right);
BST->Data = tmp->Data;
BST->Right = Delete(BST->Right,BST->Data); // 从右子树删除最小元素
} else{ // 被删除的结点有一个或无子结点
tmp = BST;
if(!BST->Left)
BST = BST->Right;
else
BST = BST->Right;
free(tmp);
}
}
return BST;
}
}