文章目录
树与二叉树
二叉树
1.存储方式与构造二叉树
1-1. 顺序存储
#define Maxsize 100
struct TreeNode{
ElemType value;
bool Empty;
};
TreeNode t[Maxsize];
1-2. 链式存储
1-2-1.不带父指针
typedef struct BiTNode{
char element;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
1-2-2.带父指针
typedef struct BiTNode {
int data; // 数据域
struct BiTNode* lchild, * rchild;// 左右孩子指针
struct BiTNode* parent;// 父亲结点
}BiTNode, * BiTree;
2.创建二叉树
可以唯一确定一棵二叉树需要给出：
先序+中序 | | 后序+中序 | | 层序+中序
这里给出先序+中序建立二叉树的方法
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MaxArraySize 20
//根据先序和中序创建二叉树
BiTree CreateTree_Pre(char* preOrder, char* midOrder, int n)
{
BiTree tree = (BiTree)malloc(sizeof(struct BiTNode));
if (!tree)
return NULL;
tree->element = preOrder[0];
tree->lchild = NULL;
tree->rchild = NULL;
if (n == 1) //只剩下一个结点时，直接返回
return tree;
int midPtr, leftLength, rightLength;
midPtr = 0;
while (midOrder[++midPtr] != preOrder[0]) //找出中序遍历中根节点的位置
;
leftLength = midPtr; //左子树结点数
rightLength = n - leftLength - 1; //右子树结点数
tree->lchild = CreateTree_Pre(&preOrder[1], midOrder, leftLength); //注意左右子树在原数组中的位置
tree->rchild = CreateTree_Pre(&preOrder[leftLength + 1], &midOrder[leftLength + 1], rightLength);
return tree;
}
//打印后序遍历结果
void PrintPostOrder(BiTree t)
{
if (!t)
return;
PrintPostOrder(t->lchild);
PrintPostOrder(t->rchild);
printf("%c", t->element);
}
int main()
{
BiTree t = (BiTree)malloc(sizeof(struct BiTNode));
char pre[MaxArraySize], mid[MaxArraySize];
//LinkQueue Q;
printf("请输入先序遍历结果：");
gets(pre);
printf("请输入中序遍历结果：");
gets(mid);
printf("后序遍历结果为：");
t = CreateTree_Pre(pre, mid, strlen(pre));
PrintPostOrder(t);
printf("\n");
return 0;
}
3.遍历
3-1.前中后序遍历的递归实现
//创建根节点
bool Insert_RootNode(BiTree &btree,int e){
btree = (BiTree)malloc(sizeof(BiTNode));
btree->data=e;
btree->lchild=NULL;
btree->rchild=NULL;
return true;
}
//获取p结点的左孩子
BiTNode* Get_LeftChild(BiTree &p){
if(p==NULL||p->lchild==NULL)
return false;
return p->lchild;
}
//获取p结点的右孩子
BiTNode* Get_RightChild(BiTree &p){
if(p==NULL||p->rchild==NULL)
return false;
return p->rchild;
}
//获取p结点的父亲结点
BiTNode* Get_Parent(BiTree &p){
if(p==NULL||p->parent==NULL){
return NULL;
}
return p->parent;
}
//当前结点p插入一个左孩子
bool Insert_LeftChild(BiTree& p,int e){
BiTNode* t=(BiTNode*)malloc(sizeof(BiTNode));
t->data=e;
t->lchild=NULL;
t->rchild=NULL;
t->parent=p;
p->lchild=t;
return true;
}
//当前结点p插入一个右孩子
bool Insert_RightChild(BiTree& p,int e){
BiTNode* t=(BiTNode*)malloc(sizeof(BiTNode));
t->data=e;
t->lchild=NULL;
t->rchild=NULL;
t->parent=p;
p->rchild=t;
return true;
}
//删除p结点，同时删除p的左右子树，并释放空间
bool Delete_TreeNode(BiTree& p){
BiTNode* temp=p;
BiTNode* t;
while(temp != NULL){
t=temp->lchild;
if(t!=NULL){
temp=t->lchild;
}
else{
temp=NULL;
}
free(t);
}
temp=p;
while(temp!=NULL){
t=temp->rchild;
if(t!=NULL){
temp=t->rchild;
}
else{
temp=NULL;
}
free(t);
}
if(p->parent->lchild==p){
p->parent->lchild=NULL;
}
else{
p->parent->rchild=NULL;
}
free(p);
return true;
}
//判空
bool IsEmpty(BiTree& root){
if(root==NULL){
return true;
}
return false;
}
//先序遍历
void PreOrder(BiTree T){
if(T!==NULL){
visit(T);
PreOrder(T->lchild);
PreOrder(T->rchild);
}
}
//中序遍历
void InOrder(BiTree T){
if(T!=NULL){
InOrder(T->lchild);
visit(T);
InOrder(T->rchild);
}
}
//后序遍历
void PostOrder(BiTree T){
if(T!=NULL){
PostOrder(T->lchild);
PostOrder(T->rchild);
visit(T);
}
}
void visit(BiTree T){
printf("%d ",T->data);
}
3-2.前中后序遍历的非递归实现
/*完整可运行代码——头文件部分*/
/*
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
*/
#define MaxArraySize 20
#define MaxSize 50
//二叉树
typedef struct BiTNode{
char element;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
typedef struct{
BiTNode* data[MaxSize];
int top;
}SqStack;
/*完整可运行代码——创建二叉树部分*/
/*
BiTree CreateTree_Pre(char* preOrder, char* midOrder, int n)
{
BiTree tree = (BiTree)malloc(sizeof(struct BiTNode));
if (!tree)
return NULL;
tree->element = preOrder[0];
tree->lchild = NULL;
tree->rchild = NULL;
if (n == 1) //只剩下一个结点时，直接返回
return tree;
int midPtr, leftLength, rightLength;
midPtr = 0;
while (midOrder[++midPtr] != preOrder[0]) //找出中序遍历中根节点的位置
;
leftLength = midPtr; //左子树结点数
rightLength = n - leftLength - 1; //右子树结点数
tree->lchild = CreateTree_Pre(&preOrder[1], midOrder, leftLength); //注意左右子树在原数组中的位置
tree->rchild = CreateTree_Pre(&preOrder[leftLength + 1], &midOrder[leftLength + 1], rightLength);
return tree;
}
//打印后序遍历结果
void PrintPostOrder(BiTree t)
{
if (!t)
return;
PrintPostOrder(t->lchild);
PrintPostOrder(t->rchild);
printf("%c", t->element);
}
*/
/*完整可运行代码——非递归实现先序中序遍历代码逻辑部分*/
//初始化
void InitStack(SqStack &S){
S.top=-1; //初始化栈顶指针
}
//判栈空
bool StackEmpty(SqStack S){
if(S.top==-1)
return true;
else
return false;
}
//进栈
bool Push(SqStack &S,BiTree p){
if(S.top==MaxSize-1) //栈满报错
return false;
S.data[++S.top]=p; //指针先加1，再入栈
return true;
}
//出栈
bool Pop(SqStack &S,BiTree &p){
if(S.top==-1) //栈空，报错
return false;
p=S.data[S.top--]; //出栈，指针再减1
return true;
}
void visit(BiTree T){
printf("%c ",T->element);
}
void InOrder2(BiTree T){
SqStack S;
InitStack(S);
BiTree p=T;
while(p||!StackEmpty(S)){
if(p){
Push(S,p);
p=p->lchild;
}
else{
Pop(S,p);
visit(p);
p=p->rchild;
}
}
}
void PreOrder2(BiTree T){
SqStack S;
InitStack(S);
BiTree p=T;
while(p||!StackEmpty(S)){
if(p){
visit(p);
Push(S,p);
p=p->lchild;
}
else{
Pop(S,p);
p=p->rchild;
}
}
}
/*完整可运行代码——main函数部分*/
/*
int main()
{
BiTree t = (BiTree)malloc(sizeof(struct BiTNode));
char pre[MaxArraySize], mid[MaxArraySize];
//LinkQueue Q;
printf("请输入先序遍历结果：");
gets(pre);
printf("请输入中序遍历结果：");
gets(mid);
printf("后序遍历结果为：");
t = CreateTree_Pre(pre, mid, strlen(pre));
PrintPostOrder(t);
printf("\n");
printf("先序遍历的结果为：");
PreOrder2(t);
printf("\n");
printf("中序遍历的结果为：");
InOrder2(t);
return 0;
}*/
3-3.层序遍历
/*完整可运行代码——头文件部分*/
/*
#include<stdio.h>
#include<stdlib.h>
#include<string.h>*/
#define MaxArraySize 20
//二叉树
typedef struct BiTNode{
char element;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
//队列（层序遍历需要）
typedef struct LinkNode{ //链式队列结点
BiTNode* data;
struct LinkNode *next;
}LinkNode;
typedef struct{ //链式队列
LinkNode *front,*rear; //队列的队头和队尾指针
}LinkQueue;
/*完整可运行代码——层序遍历代码逻辑部分*/
//初始化
void InitQueue(LinkQueue &Q){
Q.front=Q.rear=(LinkNode*)malloc(sizeof(LinkNode));
Q.front->next=NULL;
}
//判断队空
bool isEmpty(LinkQueue Q){
if(Q.front==Q.rear) return true;
else return false;
}
//入队
void EnQueue(LinkQueue &Q,BiTree x){
LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
s->data=x;
s->next=NULL;
Q.rear->next=s;
Q.rear=s;
}
//出队
bool DeQueue(LinkQueue &Q,BiTree& x){
if(Q.front==Q.rear) return false;
LinkNode *p=Q.front->next;
x=p->data;
Q.front->next=p->next;
if(Q.rear==p)
Q.rear=Q.front;
free(p);
return true;
}
//打印队列元素
void PrintQueue(LinkQueue Q){
LinkNode *p=Q.front;
BiTNode* x;
while(p->next!=NULL){
p=p->next;
x=p->data;
printf("%c ",x->element);
}
printf("\n");
}
//层序遍历
void LevelOrder(BiTree T){
//printf("1\n");
LinkQueue Q;
InitQueue(Q);
BiTree p;
EnQueue(Q,T);
while(!isEmpty(Q)){
//printf("2\n");
DeQueue(Q,p);
printf("%c",p->element);
if(p->lchild!=NULL)
EnQueue(Q,p->lchild);
if(p->rchild!=NULL)
EnQueue(Q,p->rchild);
}
printf("\n");
}
/*完整可运行代码——二叉树构造部分*/
/*
//根据先序和中序创建二叉树
BiTree CreateTree_Pre(char* preOrder, char* midOrder, int n)
{
BiTree tree = (BiTree)malloc(sizeof(struct BiTNode));
if (!tree)
return NULL;
tree->element = preOrder[0];
tree->lchild = NULL;
tree->rchild = NULL;
if (n == 1) //只剩下一个结点时，直接返回
return tree;
int midPtr, leftLength, rightLength;
midPtr = 0;
while (midOrder[++midPtr] != preOrder[0]) //找出中序遍历中根节点的位置
;
leftLength = midPtr; //左子树结点数
rightLength = n - leftLength - 1; //右子树结点数
tree->lchild = CreateTree_Pre(&preOrder[1], midOrder, leftLength); //注意左右子树在原数组中的位置
tree->rchild = CreateTree_Pre(&preOrder[leftLength + 1], &midOrder[leftLength + 1], rightLength);
return tree;
}
//打印后序遍历结果
void PrintPostOrder(BiTree t)
{
if (!t)
return;
PrintPostOrder(t->lchild);
PrintPostOrder(t->rchild);
printf("%c", t->element);
}
*/
/*完整可运行代码——main函数部分*/
/*
int main()
{
BiTree t = (BiTree)malloc(sizeof(struct BiTNode));
char pre[MaxArraySize], mid[MaxArraySize];
LinkQueue Q;
printf("请输入先序遍历结果：");
gets(pre);
printf("请输入中序遍历结果：");
gets(mid);
printf("后序遍历结果为：");
t = CreateTree_Pre(pre, mid, strlen(pre));
PrintPostOrder(t);
printf("\n");
printf("层次遍历结果为：");
LevelOrder(t);
return 0;
}
*/
4.线索二叉树
4-1.土办法求前驱
以求中序前驱为例
/*完整可运行代码——头文件部分*/
/*#include<stdio.h>
#include<stdlib.h>
#include<string.h>*/
#define MaxArraySize 20
//二叉树
typedef struct BiTNode{
char element;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
//辅助全局变量，用于查找结点p的前驱
BiTNode *p; //p指向目标结点
BiTNode *pre=NULL; //指向当前访问结点的前驱
BiTNode *final=NULL; //用于记录最终结果
/*完整可运行代码——构造二叉树部分*/
/*
//根据先序和中序创建二叉树
BiTree CreateTree_Pre(char* preOrder, char* midOrder, int n)
{
BiTree tree = (BiTree)malloc(sizeof(struct BiTNode));
if (!tree)
return NULL;
tree->element = preOrder[0];
tree->lchild = NULL;
tree->rchild = NULL;
if (n == 1) //只剩下一个结点时，直接返回
return tree;
int midPtr, leftLength, rightLength;
midPtr = 0;
while (midOrder[++midPtr] != preOrder[0]) //找出中序遍历中根节点的位置
;
leftLength = midPtr; //左子树结点数
rightLength = n - leftLength - 1; //右子树结点数
tree->lchild = CreateTree_Pre(&preOrder[1], midOrder, leftLength); //注意左右子树在原数组中的位置
tree->rchild = CreateTree_Pre(&preOrder[leftLength + 1], &midOrder[leftLength + 1], rightLength);
return tree;
}
//打印后序遍历结果
void PrintPostOrder(BiTree t)
{
if (!t)
return;
PrintPostOrder(t->lchild);
PrintPostOrder(t->rchild);
printf("%c", t->element);
}*/
/*土办法求前驱代码逻辑部分*/
void visit(BiTNode *q){
if(pre!=NULL)
printf("点前结点为%c ，其前驱结点为%c \n",q->element,pre->element);
else
printf("点前结点为%c ，它没有前驱结点\n",q->element);
if(q==p) //当前访问的结点刚好是结点p
final = pre; //找到p的前驱
else
pre=q; //pre指向当前访问的结点
}
void InOrder(BiTree T){
if(T!=NULL){
InOrder(T->lchild);
visit(T);
InOrder(T->rchild);
}
}
/*完整代码——main函数部分*/
/*
int main()
{
BiTree t = (BiTree)malloc(sizeof(struct BiTNode));
char pre[MaxArraySize], mid[MaxArraySize];
//LinkQueue Q;
printf("请输入先序遍历结果：");
gets(pre);
printf("请输入中序遍历结果：");
gets(mid);
printf("后序遍历结果为：");
t = CreateTree_Pre(pre, mid, strlen(pre));
PrintPostOrder(t);
printf("\n");
InOrder(t);
return 0;
}
*/
4-2.中序线索化
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
#define MaxArraySize 20
typedef struct ThreadNode{
char element;
struct ThreadNode *lchild,*rchild;
int ltag,rtag;
}ThreadNode,*ThreadTree;
//全局变量pre指向当前访问结点的前驱
ThreadNode *pre=NULL;
//线索化处理
void visit(ThreadNode *q){
if(q->lchild==NULL){//左子树为空，建立前驱线索
q->lchild=pre;
q->ltag=1;
}
if(pre!=NULL&&pre->rchild==NULL){
pre->rchild=q; //建立前驱结点的后继线索
pre->rtag=1;
}
printf("当前结点为%c ",q->element);
if(q->lchild!=NULL&&q->ltag==1)
printf("它的左孩子为前驱%c ",q->lchild->element);
else if(q->lchild!=NULL&&q->ltag==0)
printf("它的左孩子为左孩子%c ",q->lchild->element);
printf("\n");
pre=q;
}
//中序遍历二叉树，一边遍历一边线索化
void InThread(ThreadTree T){
if(T!=NULL){
InThread(T->lchild); //中序遍历左子树
visit(T); //线索化根节点
InThread(T->rchild); //中序遍历右子树
}
}
//中序线索化二叉树T
void CreateInThread(ThreadTree T){
pre=NULL; //pre初始为NULL
if(T!=NULL){ //非空二叉树才能线索化
InThread(T); //中序线索化二叉树
if(pre->rchild==NULL){
pre->rtag=1; //处理遍历后的最后一个结点
}
}
}
ThreadTree CreateTree_Pre(char* preOrder, char* midOrder, int n)
{
ThreadTree tree = (ThreadTree)malloc(sizeof(struct ThreadNode));
if (!tree)
return NULL;
tree->element = preOrder[0];
tree->ltag=0;
tree->rtag=0;
tree->lchild = NULL;
tree->rchild = NULL;
if (n == 1) //只剩下一个结点时，直接返回
return tree;
int midPtr, leftLength, rightLength;
midPtr = 0;
while (midOrder[++midPtr] != preOrder[0]) //找出中序遍历中根节点的位置
;
leftLength = midPtr; //左子树结点数
rightLength = n - leftLength - 1; //右子树结点数
tree->lchild = CreateTree_Pre(&preOrder[1], midOrder, leftLength); //注意左右子树在原数组中的位置
tree->rchild = CreateTree_Pre(&preOrder[leftLength + 1], &midOrder[leftLength + 1], rightLength);
return tree;
}
//打印后序遍历结果
void PrintPostOrder(ThreadTree t)
{
if (!t)
return;
PrintPostOrder(t->lchild);
PrintPostOrder(t->rchild);
printf("%c", t->element);
}
int main()
{
ThreadTree t = (ThreadTree)malloc(sizeof(struct ThreadNode));
char pre[MaxArraySize], mid[MaxArraySize];
//LinkQueue Q;
printf("请输入先序遍历结果：");
gets(pre);
printf("请输入中序遍历结果：");
gets(mid);
printf("后序遍历结果为：");
t = CreateTree_Pre(pre, mid, strlen(pre));
PrintPostOrder(t);
printf("\n");
printf("中序线索化后为:\n");
CreateInThread(t);
return 0;
}
4-3.先序线索化
//先序遍历二叉树，一边遍历一边线索化
void PreThread(ThreadTree T){
if(T!=NULL){
visit(T); //先处理根节点
if(T->ltag==0)
PreThread(T->lchild); //lchild不是前驱线索
PreThread(T->rchild);
}
}
//先序线索化二叉树T
void CreatePreThread(ThreadTree T){
pre=NULL;
if(T!=NULL){
PreThread(T);
if(pre->rchild==NULL)
pre->rtag=1;
}
}
4-4.后序线索化
//后序遍历二叉树，一边遍历一边线索化
void PostThread(ThreadTree T){
if(T!=NULL){
PostThread(T->lchild);
PostThread(T->rchild);
visit(T);
}
}
//后序线索化二叉树T
void CreatePostThread(ThreadTree T){
pre=NULL;
if(T!=NULL){
PostThread(T);
if(pre->rchild==NULL)
pre->rtag=1;
}
}
树
1.存储结构
1-1.双亲表示法
#define MAX_TREE_SIZE 100
typedef struct{
ElemType data;
int parent; //双亲位置域
}PTNode;
typedef struct{
PTNode nodes[MAX_TREE_SIZE];
int node; //结点数
}PTree;
1-2.孩子表示法
struct CTNode{
int child; //孩子结点在数组中的位置
struct CTNode *next; //下一个孩子
};
typedef struct{
ElemType data;
struct CTNode *firstChild; //第一个孩子
}CTBox;
typedef struct{
CTBox nodes[MAX_TREE_SIZE];
int n,r; //结点数和根的位置
}CTree;
1-3.孩子兄弟表示法
typedef struct CSNode{
Elemtype data; //数据域
struct CSNode *firstchild,*nextsibling; //第一个孩子和右兄弟指针
}CSNode,*CSTree;
应用
1.二叉排序树
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
//二叉排序树结点
typedef struct BSTNode{
int key;
struct BSTNode *lchild,*rchild;
}BSTNode,*BSTree;
/*非递归实现：在二叉排序树中查找值为key的结点
BSTNode *BST_Search(BSTree T,int key){
while(T!=NULL&&key!=T->key){ //若树空或等于根结点值结束循环
if(key<T->key) T=T->lchild; //小于，则在左子树中查找
else T=T->rchild; //大于，则在右子树中查找
}
}*/
/*递归实现：在二叉排序树中查找值为key的结点*/
BSTNode *BSTSearch(BSTree T,int key){
if(T==NULL)
return NULL;
if(key==T->key)
return T;
else if(key<T->key)
return BSTSearch(T->lchild,key);
else
return BSTSearch(T->rchild,key);
}
//递归实现：在二叉排序树插入关键字为k的新结点，新插入一定是叶子结点
int BST_Insert(BSTree &T,int k){
if(T==NULL){ //原树为空，新插入的结点为根结点
T=(BSTree)malloc(sizeof(BSTNode));
T->key=k;
T->lchild=T->rchild=NULL;
return 1; //返回1，插入成功
}
else if(k==T->key) //树中存在相同关键字的结点，插入失败
return 0;
else if(k<T->key) //插入到T的左子树
return BST_Insert(T->lchild,k);
else //插入到T的右子树
return BST_Insert(T->rchild,k);
}
void Creat_BST(BSTree &T,int str[],int n){
T=NULL;
int i=0;
while(i<n){
BST_Insert(T,str[i]);
i++;
}
}
//中序遍历得到有序序列
void InOrder(BSTree T){
if(T!=NULL){
InOrder(T->lchild);
printf("%d ",T->key);
InOrder(T->rchild);
}
}
int main(){
int Arry[10]={9,7,8,4,6,3,1,2,5,10};
BSTree T;
T=(BSTree)malloc(sizeof(BSTNode));
Creat_BST(T,Arry,10);
InOrder(T);
return 0;
}
2637
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
