树的基本操作，代码示例

先序输入树：
ABD*GEHCF**

运行结果：

Tree.h

#pragma once
#include <Windows.h>
#include <stdio.h>
#define MAX 100
#define OK 1
#define NO 0
typedef char ElemType_T;

//树的结构
typedef struct Node
{
	ElemType_T data; //数据域
	struct Node* Lchild; //左孩子
	struct Node* Rchild; //右孩子
}BNode, *BTree;

//队列结构
typedef struct SeqQueue
{
	BTree Elem[MAX];    //队列每一个元素都是指向结点的指针  指针数组 
	int front;             //队头
	int rear;              //队尾
}SeqQueue;

//初始化队列
void InitSeqQuue(SeqQueue* Q)
{
	Q->front = Q->rear = 0;
}
//进队列
void EnQueue(SeqQueue* Q, BTree e)
{
	if ((Q->rear + 1) % MAX == Q->front) return;
	Q->Elem[Q->rear] = e;
	Q->rear = (Q->rear + 1) % MAX;
}
//出队列
void DeQueue(SeqQueue* Q, BTree* e)
{
	if (Q->front == Q->rear) return;
	*e = Q->Elem[Q->front];
	Q->front = (Q->front + 1) % MAX;
}
//判断队列是否为空
int QueueEmpty(SeqQueue* Q)
{
	if (Q->front == Q->rear) return OK;
	else return NO;
}

//栈结构
typedef struct SeqStack
{
	BTree elem[MAX];
	int top;
}SeqStack;

//初始化栈
void InitStack(SeqStack* stack)
{
	stack->top = -1;
}
//入栈
void PushStack(SeqStack* stack, BTree e)
{
	if (stack->top == MAX - 1) return;
	stack->elem[++stack->top] = e;
}
//出栈
void PopStack(SeqStack* stack, BTree* p)
{
	if (stack->top == -1) return;
	(*p) = stack->elem[stack->top--];
}

//判单栈是否是空栈
int StackEmpty(SeqStack* stack)
{
	if (stack->top == -1) return OK;
	else return NO;
}

//创建一棵树
void CeateTree(BNode** root) {
	ElemType_T data;
	scanf("%c", &data);
	if (data == '*') (*root) = NULL;
	else {
		(*root) = (BTree)malloc(sizeof(BNode));
		(*root)->data = data;
		CeateTree(&(*root)->Lchild);
		CeateTree(&(*root)->Rchild);
	}
}

//先序遍历
void PreOrderTraverse(BTree root)
{
	if (root != NULL) {
		printf("%c ", root->data);
		PreOrderTraverse(root->Lchild);
		PreOrderTraverse(root->Rchild);
	}
}

//中序遍历
void InOrderTraverse(BTree root)
{
	if (root != NULL) {
		InOrderTraverse(root->Lchild);
		printf("%c ", root->data);
		InOrderTraverse(root->Rchild);
	}
}
//中序非递归遍历
void InOrderTraverseNO(BTree root)
{
	SeqStack S;
	BTree p = root;
	InitStack(&S); //初始化栈
	PushStack(&S, p);
	while (!StackEmpty(&S))
	{
		if (p != NULL) {
			if (p->Lchild != NULL) PushStack(&S, p->Lchild);
			p = p->Lchild;
		}
		else {
			PopStack(&S, &p);
			printf("%c ", p->data);
			if (p->Rchild != NULL) PushStack(&S, p->Rchild);
			p = p->Rchild;
		}
	}
}

//后序遍历
void PostOrderTraverse(BTree root)
{
	if (root != NULL)
	{
		PostOrderTraverse(root->Lchild);
		PostOrderTraverse(root->Rchild);
		printf("%c ", root->data);
	}
}

//层序遍历
void LevelOrderTraverse(BTree root)
{
	SeqQueue Q;
	BTree p = root;
	InitSeqQuue(&Q); //初始化队列
	if (p) {
		EnQueue(&Q, p);
	}
	while (!QueueEmpty(&Q)) {
		DeQueue(&Q, &p); //出队
		printf("%c ", p->data);
		if (p->Lchild != NULL)
			EnQueue(&Q, p->Lchild);
		if (p->Rchild != NULL)
			EnQueue(&Q, p->Rchild);
	}
}

//求叶子结点
void LeafPreOrderTraverse(BTree root)
{
	if (root != NULL) {
		if (root->Lchild == NULL && root->Rchild == NULL)
			printf("%c ", root->data);
		LeafPreOrderTraverse(root->Lchild);
		LeafPreOrderTraverse(root->Rchild);
	}
}

//求叶子结点个数
void LeafCount(BTree root, int* n) {
	if (root != NULL) {
		if (root->Lchild == NULL && root->Rchild == NULL)
			(*n)++;
		LeafCount(root->Lchild, n);
		LeafCount(root->Rchild, n);
	}
}

源.cpp

#include "Tree.h"
#include <stdio.h>

int main(int argc, char* argv[])
{
	//树根
	BTree root;
	//统计叶子个数
	int n = 0;
	//创建一棵树
	CeateTree(&root);

	//先序遍历
	printf("先序遍历:\n");
	PreOrderTraverse(root);

	//中序遍历
	printf("\n中序遍历:\n");
	InOrderTraverse(root);

	//中序非递归遍历
	printf("\n中序非递归遍历:\n");
	InOrderTraverseNO(root);

	//后序遍历
	printf("\n后序遍历:\n");
	PostOrderTraverse(root);

	//层序遍历
	printf("\n层序遍历:\n");
	LevelOrderTraverse(root);

	//求叶子结点
	printf("\n叶子结点:\n");
	LeafPreOrderTraverse(root);

	//求叶子结点个数
	printf("\n叶子结点个数:\n");
	LeafCount(root, &n);
	printf("%d", n);
	return 0;
}
/*
                  A
            B            C
        D       E    *        F
    *       G H    *        *   *
	       ** **
		 
		  
ABD*G**EH***C*F**
先序遍历:
A B D G E H C F
中序遍历:
D G B H E A C F
后序遍历:
G D H E B F C A
层序遍历:
A B C D E F G H
*/