二叉树基本操作

#include "stdafx.h"
#include "malloc.h"
#define MaxSize 100
typedef char ElemType;
//二叉树的结构体
typedef struct node
{
	ElemType data;
	struct node *lchild;
	struct node *rchild;
}BTNode;  
// 创建二叉树，以广义数组表示
void CreateBTNode(BTNode *&b, char *str)
{
	// p是temp指针,St是栈,b是头结点（A,BTNode）指针。
	//St维护栈
	BTNode *St[MaxSize], *p = NULL;
	int top = -1, k, j = 0;
	char ch;
	b = NULL;
	ch = str[j];
	while (ch!='\0')
	{
		switch (ch)
		{
		case '(':
			top++;
			St[top] = p;
			k = 1;
			break;
		case ')':
			top--;
			break;
		case ',':
			k = 2;
			break;
		default:
			p = (BTNode *)malloc(sizeof(BTNode));
			p->data = ch;
			p->lchild = p->rchild = NULL;
			if (b == NULL)
			{
				b = p;
			}
			else
			{
				switch (k)
				{
				case 1:
					St[top]->lchild = p;
					break;
				case 2:
					St[top]->rchild = p;
					break;
				default:
					break;
				}
			}
			break;
		}
		j++;
		ch = str[j];
	}
}
BTNode * FindNode(BTNode *b, ElemType x)
{
	BTNode *p;
	if (b == NULL)
	{
		return NULL;
	}
	else if(b->data==x)
	{
		return b;
	}
	else
	{
		// 递归
		p = FindNode(b->lchild, x);
		if(p!=NULL){
			return p;
		}
		else {
			return FindNode(b->rchild, x);
		}
	}
}
BTNode *LchildNode(BTNode *p)
{
	return p->lchild;
}
BTNode * RchildNode(BTNode *p)
{
	return p->rchild;
}
// 二叉树的深度
int BTNodeDepth(BTNode *b)
{
	int lchilddep, rchilddep;
	if (b == NULL)
	{
		return 0;
	}
	else
	{
		lchilddep = BTNodeDepth(b->lchild);
		rchilddep = BTNodeDepth(b->rchild);
		return(lchilddep > rchilddep) ? (lchilddep + 1) : (rchilddep + 1);
	}
}
void DispBTNode(BTNode *b)
{
	if (b != NULL)
	{
		printf_s("%c", b->data);
		if (b->lchild != NULL || b->rchild != NULL)
		{
			printf_s("(");
			DispBTNode(b->lchild);
			if (b->rchild != NULL)
			{
				printf_s(",");
			}
			DispBTNode(b->rchild);
			printf_s(")");
		}
	}
}


// 二叉树的宽度
int BTWidth(BTNode *b)
{
	struct
	{
		int lno;
		BTNode *p;
	}Qu[MaxSize];

	int front, rear; //队列
	int lnum, max, i, n;
	front = rear = 0;
	if (b != NULL)
	{
		rear++;
		Qu[rear].p = b;
		Qu[rear].lno = 1; // 第一层根节点
		while (rear!=front)	// 队列 通过队头和队尾进行二叉树的遍历，添加lno标识层次
		{
			front++;
			b = Qu[front].p;
			lnum = Qu[front].lno;
			if (b->lchild != NULL)
			{
				rear++;
				Qu[rear].p = b->lchild;
				Qu[rear].lno = lnum + 1;
			}
			if (b->rchild != NULL)
			{
				rear++;
				Qu[rear].p = b->rchild;
				Qu[rear].lno = lnum + 1;
			}
		}
		// 循环队列获取最大层次
		max = 0;
		lnum = 1;
		i = 1;
		while (i<=rear)
		{
			n = 0;
			while (i<=rear && Qu[i].lno==lnum)
			{
				n++;
				i++;
			}
			lnum = Qu[i].lno;
			if (n > max) max = n;
		}
		return max;
	}
	else
	{
		return 0;
	}
}


// 二叉树的节点个数
int Nodes(BTNode *b)
{
	int num1, num2;
	if (b == NULL)
	{
		return 0;
	}
	else if (b->lchild == NULL && b->rchild == NULL)
	{
		return 1;
	}
	else
	{
		num1 = Nodes(b->lchild);
		num2 = Nodes(b->rchild);
		return (num1 + num2 + 1); // +1
	}
}
// 二叉树的叶子节点数
int LeafNodes(BTNode *b)
{
	int num1, num2;
	if (b == NULL)
	{
		return 0;
	}
	else if (b->lchild == NULL &&b->rchild == NULL)
	{
		return 1;
	}
	else
	{
		num1 = LeafNodes(b->lchild);
		num2 = LeafNodes(b->rchild);
		return (num1 + num2 );
	}
}

int main()
{
	int i = 0;
	BTNode *b, *p, *lp, *rp,*temp;
	CreateBTNode(b, "A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");
	// 输出二叉树
	DispBTNode(b);
	printf_s("\n");
	// 在二叉树中查找节点
	p = FindNode(b, 'H');
	if (p != NULL)
	{
		lp = LchildNode(p);
		if (lp != NULL)
		{
			printf_s("左孩子为：%c", lp->data);
		}
		else
		{
			printf_s("无左孩子");
		}

		rp = RchildNode(p);
		if (rp != NULL)
		{
			printf_s("右孩子为：%c", rp->data);
		}
		else
		{
			printf_s("无右孩子");
		}
	}
	printf_s("二叉树b的深度:%d\n", BTNodeDepth(b));
	printf_s("二叉树b的宽度:%d\n", BTWidth(b));
	printf_s("二叉树b的节点个数:%d", Nodes(b));
	printf_s("二叉树b的叶子节点个数:%d", LeafNodes(b));
	return 0;
}

　　

转载于:https://www.cnblogs.com/tuqunfu/p/8506000.html