数据结构关于二叉树的操作

最新推荐文章于 2022-05-13 09:15:59 发布
Hao-World
最新推荐文章于 2022-05-13 09:15:59 发布
阅读量495
点赞数
分类专栏：数据结构文章标签：数据结构二叉树
本文链接：https://blog.csdn.net/u013610133/article/details/41907315
版权
数据结构专栏收录该内容
1 篇文章 0 订阅
订阅专栏
对于二叉树，首先你要搞明白它的存储结构，这里用二叉树的二叉链表来说一下二叉树的各种操作。。

<span style="font-family:Comic Sans MS;font-size:18px;">#include<stdio.h>
#include<stdlib.h>

#define MAX_STACK_SIZE 100
#define INCREACE 20

//二叉树的存储结构
typedef struct BTNode{
	char data;
	struct BTNode *lchild, *rchild;
}BTNode, *BiTree;

//链式的结点
typedef struct Node{
	BiTree bt;
	struct Node *next;
}Node, *pNode;

//栈的操作，首先你要搞明白栈里存放的是什么东西是指针呢，还是整型的数据呢，等等。。
//顺序栈的操作
//栈里存放的是一个指向二叉树结点的指针，所以此处要用到二级指针
typedef struct Stack{
	BiTree *base;//指向栈底元素
	BiTree *top;//指向栈顶元素
	int stacksize;//初始存储容量
}SqStack;


void InitStack(SqStack &S)
{//初始化一个栈
	S.base = (BiTree*)malloc(sizeof(BiTree)*MAX_STACK_SIZE);
	S.top = S.base;
	S.stacksize = MAX_STACK_SIZE;
}
int  GetTop(SqStack S, BiTree &p)
{//得到栈顶元素
	if (S.base == S.top) exit(0);
	p = *(S.top--);
}
void Push(SqStack &S, BiTree p)
{//入栈
	if (S.top - S.base > MAX_STACK_SIZE)
	{
		S.base = (BiTree*)realloc(S.base, sizeof(BiTree)*(INCREACE + S.stacksize));
		if (!S.base)exit(0);
		S.top = S.base + S.stacksize;
		S.stacksize += MAX_STACK_SIZE;
	}
	*S.top++ = p;
}
void Pop(SqStack &S, BiTree &p)
{//出栈
	if (S.base == S.top)exit(0);
	p = *--S.top;
}
bool EmptySatck(SqStack S)
{//判空
	if (S.base == S.top)
		return 1;
	else
		return 0;
}

//链栈的操作


typedef struct LStack{
	pNode ptop;
	pNode pbase;
}LStack, *pStack;

void InitStack1(LStack &S){
	//初始化栈
	S.pbase = S.ptop = (pNode)malloc(sizeof(Node));
	if (!S.pbase)exit(0);
	S.pbase->next = NULL;
}

void Push1(LStack &S, BiTree b)
{//入栈
	pNode pNew = (pNode)malloc(sizeof(Node));
	if (!S.pbase)exit(0);
	pNew->bt = b;
	pNew->next = S.ptop;
	S.ptop = pNew;
}
void Pop1(LStack &S, BiTree b)
{//出栈
	pNode p;
	if (S.pbase == S.ptop)
		exit(0);
	else
	{
		p = S.ptop;
		b = S.ptop->bt;
		S.ptop = S.ptop->next;
		delete(p);
	}
}

bool EmptyStack1(LStack S)
{
	if (S.pbase == S.ptop)
		return 1;
	else return 0;
}



//队列的操作


//循环队列
#define MAXSIZE 100
typedef struct Queue{
	BiTree *base;
	int front, rear;
}SqQueue;
void InitQueue(Queue &Q)
{
	Q.base = (BiTree*)malloc(sizeof(BiTree)*MAXSIZE);
	if (!Q.base)exit(0);
	Q.front = Q.rear = 0;
}
void EnQueue(Queue &Q, BiTree p)
{
	if ((Q.rear + 1) % MAXSIZE == Q.front)exit(0);
	Q.base[Q.rear] = p;
	Q.rear = (Q.rear + 1) % MAXSIZE;
}
void DeQueue(Queue &Q, BiTree &p)
{
	if (Q.front == Q.rear)exit(0);
	p = Q.base[Q.front];
	Q.front = (Q.front + 1) % MAXSIZE;
}
bool EmptyQueue(Queue Q)
{
	if ((Q.rear + 1) % MAXSIZE == Q.front)
		return true;
	else
		return false;
}
int LengthQueue(Queue Q)
{
	return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;
}
void GetHeadQueue(Queue Q,BiTree &bt)
{
	if (Q.front == Q.rear)exit(0);
	bt = Q.base[Q.front];
}

//链队列
struct LQueue{
    pNode front;
	pNode rear;
};

void InitQueue1(LQueue &Q)
{
	Q.front = Q.rear = (pNode)malloc(sizeof(Node));
	if (!Q.front)exit(0);
	Q.rear->next = NULL;
}
void EnQueue1(LQueue &Q, BiTree p)
{
	pNode pNew = (pNode)malloc(sizeof(Node));
	if (!pNew)exit(0);
	pNew->bt = p;
	pNew->next = NULL;
	Q.rear->next = pNew;
	Q.rear = pNew;
}
void DeQueue1(LQueue &Q, BiTree p)
{
	if (Q.rear == Q.front)exit(0);
	pNode pt = Q.front->next;
	p = pt->bt;
	Q.front->next = pt->next;
	if (Q.rear == pt)
		Q.rear = Q.front;
	free(p);
}
void GetFront(LQueue Q, BiTree &bt)
{
	if (Q.rear == Q.front)exit(0);
	pNode pt = Q.front->next;
	bt = pt->bt;
}
bool EmptyQueue1(LQueue Q)
{
	if (Q.rear == Q.front)
		return true;
	else
		return false;
}
int LengthQueue1(LQueue Q)
{
	return Q.rear - Q.front;
}


//（1）采用下列方法之一建立二叉树的二叉链表：
void CreatBiTree1(BiTree &bt)
{//①输入完全二叉树的先序序列，用#代表虚结点（空指针），如ABD###CE##F##，建立二叉树的二叉链表。
	char ch;
	ch = getchar();
	if (ch == '#')
		bt = NULL;
	else{
		bt = (BiTree)malloc(sizeof(BTNode));
		if (!bt)exit(0);
		bt->data = ch;
		CreatBiTree1(bt->lchild);
		CreatBiTree1(bt->rchild);
	}

}

void CreatBiTree2(BiTree &bt, char pre[], char in[], int n)
{//② 已知二叉树的先序遍历序列和中序遍历序列，或者已知二叉树的中序遍历序列和后序遍历序列，建立二叉树的二叉链表。
	char prel[20], prer[20], inl[20], inr[20];
	int i, j, l, r;
	if (n < 1)
	{
		bt = NULL;
		return;
	}
	else
	{
		bt = (BiTree)malloc(sizeof(BTNode));
		bt->data = pre[0];
		bt->lchild = bt->rchild = NULL;
		i = 0;
		while (in[i] != pre[0])
			i++;
		l = i; r = n - i - 1;
		for (j = 0; j <i; j++)
		{
			prel[j] = pre[j + 1];
			inl[j] = in[j];
		}

		for (j = i + 1; j < n; j++)
		{
			prer[j - i - 1] = pre[j];
			inr[j - i - 1] = in[j];
		}

		if (l < 1)
			bt->lchild = NULL;
		else
			CreatBiTree2(bt->lchild, prel, inl, l);
		if (r < 1)
			bt->rchild = NULL;
		else
			CreatBiTree2(bt->rchild, prer, inr, r);
	}
}

//二叉树的顺序存储结构
#define  TREE_MAX_SIZE 20
typedef char SqBiTree[TREE_MAX_SIZE + 1];//1号单元存储根结点
void CreatBiTree3(BiTree bt, SqBiTree ST, int i, int n)
{//③ 将一棵二叉树的所有结点存储在一维数组中，虚结点用#表示，利用二叉树的性质5，建立二叉树的二叉链表
	if (ST[i] == '#')bt = NULL;
	else{
		bt = (BiTree)malloc(sizeof(BTNode));
		bt->data = ST[i];
	}
	int j = 2 * i;
	if (j <= n)
		CreatBiTree3(bt->lchild, ST, j, n);
	else
		bt->lchild = NULL;
	j++;
	if (j <= n)
		CreatBiTree3(bt->rchild, ST, j, n);
	else
		bt->rchild = NULL;
}

//2.写出对用二叉链表存储的二叉树进行先序、中序和后序遍历的递归和非递归算法

void PreOrderTraverse1(BiTree bt)
{//先序遍历的递归算法
	if (!bt)
	{
		printf("%3d", bt->data);
		PreOrderTraverse1(bt->lchild);
		PreOrderTraverse1(bt->rchild);
	}
}
void PreOrderTraverse2(BiTree bt)
{//先序遍历二叉树  非递归算法（一）
	SqStack S;//利用的顺序栈
	BiTree p;
	InitStack(S);
	Push(S, bt);
	while (!EmptySatck(S))
	{
		while (GetTop(S, p) && p)
		{
			printf("%3d", p->data);
			Push(S, p->lchild);
		}
		Pop(S, p);
		if (!EmptySatck(S))
		{
			Pop(S, p);
			Push(S, p->rchild);
		}
	}
}

void InOrderTraverse1(BiTree bt)
{//中序遍历的递归算法
	if (!bt)
	{
		InOrderTraverse1(bt->lchild);
		printf("%3d", bt->data);
		InOrderTraverse1(bt->rchild);
	}
}

void InOrderTraverse2(BiTree bt)
{//中序遍历的非递归算法（方法一）
	SqStack S;
	BiTree p;
	while (!EmptySatck(S))
	{
		InitStack(S);
		Push(S, bt);
		while (!EmptySatck(S))
		{
			while (GetTop(S, p) && p)
				Push(S, p->lchild);
			Pop(S, p);
			if (!EmptySatck(S))
			{
				Pop(S, p);
				printf("%3d", p->data);
				p = p->rchild;
			}

		}
	}

}

void PostOrderTraverse1(BiTree bt)
{//后序遍历的递归算法
	if (!bt)
	{
		PostOrderTraverse1(bt->lchild);
		PostOrderTraverse1(bt->rchild);
		printf("%3d", bt->data);
	}
}

void PostOrderTraverse2(BiTree bt)
{//后序遍历的非递归算法

}


//3.写出对用二叉链表存储的二叉树进行层次遍历算法

void LevelOrderTraverse(BiTree bt)
{
	Queue Q;
	BiTree p;
	if (bt)
	{
		InitQueue(Q); EnQueue(Q, bt);
		while (!EmptyQueue(Q))
		{
			DeQueue(Q, p);
			printf("&3d", p->data);
			if (p->lchild)EnQueue(Q, p->lchild);
			if (p->rchild)EnQueue(Q, p->rchild);

		}
	}
}</span>