二叉树的基本操作

最新推荐文章于 2025-06-06 23:57:26 发布

fishing0001

最新推荐文章于 2025-06-06 23:57:26 发布

阅读量225

点赞数

分类专栏： c语言笔记文章标签： c语言数据结构二叉树

本文链接：https://blog.youkuaiyun.com/fishing0001/article/details/86700448

版权

c语言笔记专栏收录该内容

4 篇文章

订阅专栏

本文深入探讨了二叉树的基本操作，包括插入、删除、遍历等，详细阐述了每种操作的实现原理，并提供了使用C语言的示例代码，为理解和应用二叉树数据结构提供了清晰的指导。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/*树结构定义和操作声明*/
typedef int TElemtype;
typedef struct _TNode {
	TElemtype tdata;
	struct _TNode * left, *right;
}TNode, *BiTree;
bool InitTree(BiTree *T);
bool TreeEmpty(BiTree T);
bool CreatTree(BiTree *T);
bool PreTraverse(BiTree T);
bool PreTraverse2(BiTree T);
bool InTraverse(BiTree T);
bool InTraverse2(BiTree T);
bool PostTraverse(BiTree T);
bool PostTraverse2(BiTree T);
void PrintTNode(TNode *p);
bool LevelTraverse(BiTree T);
TNode * LinkLeaf(BiTree *T);//将所有叶子结点从左至右连接起来
TNode * LinkLeaf2(BiTree *T);
void PrintLinkLeaf(TNode * head);

/*栈结构定义和操作声明*/
typedef struct {
	TNode* ptr;
	int mark;
}SElemtype;
typedef struct _SNode {
	SElemtype sdata;
	struct _SNode *next;
}SNode;
typedef struct {
	SNode * top;
	SNode * base;
}LinkStack;
bool InitStack(LinkStack *S);
bool StackEmpty(LinkStack S);
bool Push(LinkStack *S, BiTree * p);
bool Pop(LinkStack *S, BiTree *p);
SElemtype GetTop(LinkStack S);
bool PrintStack(LinkStack S);

/*队列结构定义和操作声明*/
typedef BiTree QElemType;
typedef struct _QNode {
	QElemType qdata;
	struct _QNode * next;
}QNode;
typedef struct {
	QNode * front;
	QNode *rear;
}QueueLink;

bool InitQueue(QueueLink *Q);
bool QueueEmpty(QueueLink Q);
bool EnQueue(QueueLink *Q,QElemType *q);
bool DeQueue(QueueLink *Q, QElemType *q);

bool IsTreeEqualStackTop(LinkStack S, TNode * treep)
{
	return treep == ((S.top)->next->sdata).ptr;
}

bool MarkTop(LinkStack *S, int mark)
{
	if (StackEmpty(*S))
		return false;
	(S->top->next->sdata).mark = mark;
	return true;
}

/*以下是对栈的具体操作*/
bool InitStack(LinkStack *S)
{
	if (S == NULL)
		return false;
	S->base = (SNode *)malloc(sizeof(SNode));
	if (NULL == S->base)
		return false;
	memset(S->base, 0, sizeof(SNode));
	S->top = S->base;
	return true;
}
bool StackEmpty(LinkStack S)
{
	return S.top == S.base;
}
bool Push(LinkStack *S, BiTree *p)
{
	if (S == NULL)
	{
		printf("stack doesnot exist\n");
		return false;
	}
	S->top->sdata.ptr = *p;
	S->top->sdata.mark = 0;
	SNode *tmp;
	tmp = (SNode *)malloc(sizeof(SNode));
	if (tmp == NULL)
		return false;
	memset(tmp, 0, sizeof(SNode));
	tmp->next = S->top;
	S->top = tmp;
	return true;
}//将指针push，mark位置零
bool Pop(LinkStack *S, BiTree *p)
{
	if (S == NULL || p == NULL || StackEmpty(*S))
		return false;
	if (S == NULL || StackEmpty(*S))
		return false;
	*p = ((S->top->next->sdata).ptr);
	SNode *tmp = S->top;
	S->top = S->top->next;
	free(tmp);
	return true;
}
SElemtype GetTop(LinkStack S)
{
	if (StackEmpty(S))
		return;
	return S.top->next->sdata;
}
bool PrintStack(LinkStack S)
{
	if (StackEmpty(S))
	{
		printf("emptystack\n");
		return false;
	}
	SNode *p = S.top->next;
	while (p)
	{
		printf("%5d", (p->sdata).ptr->tdata);
		p = p->next;
	}
	printf("\n");
	return true;

}

/*以下是队列的操作*/
bool InitQueue(QueueLink *Q)
{
	if (Q == NULL)
		return false;
	QNode *p = (QNode*)malloc(sizeof(QNode));
	if (NULL == p)
		return false;
	memset(p, 0, sizeof(QNode));
	Q->rear = Q->front = p;
	return true;
}
bool QueueEmpty(QueueLink Q)
{
	return Q.rear == Q.front;
}
bool EnQueue(QueueLink *Q, QElemType *q)
{
	if (Q == NULL || q == NULL)
		return false;
	QNode *tmp = (QNode*)malloc(sizeof(QNode));
	if (tmp == NULL)
		return false;
	memset(tmp, 0, sizeof(QNode));
	tmp->next = NULL;
	tmp->qdata = *q;
	Q->rear->next = tmp;
	Q->rear = tmp;
	return true;
}
bool DeQueue(QueueLink *Q, QElemType *q)
{
	if (QueueEmpty(*Q) || q == NULL || Q == NULL)
		return false;
	*q = Q->front->next->qdata;
	QNode *tmp = Q->front;
	Q->front = Q->front->next;
	free(tmp);
	tmp = NULL;
	return true;
}
void PrintQueue(QueueLink Q)
{
	if (QueueEmpty(Q))
		return;
	QNode *tmp = Q.front->next;
	while (tmp != Q.rear)
	{
		printf("%5d", tmp->qdata->tdata);
		tmp = tmp->next;
	}
	printf("%5d\n", tmp->qdata->tdata);
}

/*以下是对树的操作*/
bool InitTree(BiTree *T)
{
	if (T == NULL)
		return false;
	(*T) = (TNode *)malloc(sizeof(TNode));
	if (*T == NULL)
		return false;
	memset(*T, 0, sizeof(TNode));
	(*T)->left = NULL;
	(*T)->right = NULL;
	return true;
}
bool TreeEmpty(BiTree T)
{
	return T == NULL;
}
bool CreatTree(BiTree *T)
{
	if (T == NULL)
		return false;
	TElemtype tmp;
	printf("input a num\n");
	scanf("%d", &tmp);
	if (tmp<0)
		return true;
	InitTree(T);
	(*T)->tdata = tmp;
	printf("left of%d\n", tmp);
	CreatTree(&(*T)->left);
	printf("right of %d\n", tmp);
	CreatTree(&(*T)->right);
	return true;


}
bool PreTraverse(BiTree T)
{
	if (T == NULL)
		return false;
	printf("%5d", T->tdata);
	if (T->left)
		PreTraverse(T->left);
	if (T->right)
		PreTraverse(T->right);
	return true;
}
bool PreTraverse2(BiTree T)
{
	LinkStack S;
	InitStack(&S);
	TNode *p = T;
	do {
		if (p)
		{
			printf("%5d", p->tdata);			
			if (p->right)
				Push(&S, &(p->right));
			p = p->left;
		}
		else if (!p)
		{
			Pop(&S, &p);
		}
	} while (!StackEmpty(S)||p);
	return true;
}
bool InTraverse(BiTree T)
{
	if (T == NULL)
		return true;
	if (T->left)
		InTraverse(T->left);
	printf("%5d", T->tdata);
	if (T->right)
		InTraverse(T->right);
	return true;
}
bool InTraverse2(BiTree T)
{
	TNode *p = T;
	LinkStack S;
	InitStack(&S);
	//Push(&S, p);
	do
	{
		if (StackEmpty(S))
			Push(&S, &p);
		if (p)
		{
			Push(&S, &p);
			if (p->left)
			{
				p = p->left;
				//Push(&S, p);
			}
			else if (p->right)
			{
				//Pop(&S, &p);
				printf("%5d", p->tdata);
				p = p->right;
			}
			else
			{
				printf(" % 5d", p->tdata);
				Pop(&S, &p);
			}
		}
		else if (!p)
			Pop(&S, &p);
	} while (!StackEmpty(S));
	return true;
}
bool PostTraverse(BiTree T)
{
	if (T == NULL)
		return false;
	if (T == NULL)
		return false;
	if (T->left)
		PostTraverse(T->left);
	if (T->right)
		PostTraverse(T->right);
	printf("%5d", T->tdata);
	return true;
}
bool PostTraverse2(BiTree T)
{
	if (T == NULL)
		return false;
	TNode *p =T;
	LinkStack S;
	InitStack(&S);
	do
	{
		if (StackEmpty(S))
		{
			Push(&S, &p);
			p = p->left;
		}
		if (p)
		{
			if (p != GetTop(S).ptr)
			{
				Push(&S, &p);
				p = p->left;
			}
			else if (p == GetTop(S).ptr)
			{
				if (GetTop(S).mark == 0)
				{
					MarkTop(&S, 1);
					p = (GetTop(S).ptr)->right;
				}
				else if (GetTop(S).mark == 1)
				{
					printf("%5d", (GetTop(S).ptr)->tdata);
					Pop(&S, &p);
					p = GetTop(S).ptr;
				}
			}
		}
		else if (!p)
		{
			p = GetTop(S).ptr;
		}			
	} while (!StackEmpty(S));
	return true;
}
bool LevelTraverse(BiTree T)
{
	if (T == NULL)
		return false;
	TNode * p = T;
	TNode *tmp = NULL;
	QueueLink Q;
	InitQueue(&Q);
	EnQueue(&Q, &p);
	while (!QueueEmpty(Q))
	{
		DeQueue(&Q, &tmp);
		printf("%5d", tmp->tdata);
		if (tmp->left)
			EnQueue(&Q, &tmp->left);
		if (tmp->right)
			EnQueue(&Q, &tmp->right);
	}
	return true;
}


TNode * LinkLeaf(BiTree *T)//将所有叶子结点从左至右连接起来
{
	if (T == NULL||*T==NULL)
		return NULL;
	static TNode *head = NULL;
	static TNode *cur = NULL;
	LinkLeaf(&((*T)->left));
	if (!(*T)->left && !(*T)->right) 
	{
		if (cur == NULL)
		{
			head = *T;
			cur = *T;
		}
		else
		{
			cur->right = *T;
			cur = *T;
		}
	}
	LinkLeaf(&(*T)->right);
	return head;	
}

TNode * LinkLeaf2(BiTree *T)
{

}
void PrintLinkLeaf(TNode * head)
{
	TNode *cur = head;
	while (cur)
	{
		printf("%5d", cur->tdata);
		cur = cur->right;
	}
	printf("\n");
}
void PrintTNode(TNode *p)
{
	printf("%5d", p->tdata);
}