数据结构：树

树

#pragma warning(disable:4996)
#include<stdio.h>
#include<stdlib.h>

#define QUEUE_MAXSIZE 50

#define MAXSIZE 100

typedef char DATA;


//顺序存储结构
typedef DATA SeqBinTree[MAXSIZE];
SeqBinTree SBT;

//链式存储结构
typedef struct ChainTree {
	DATA data;
	struct ChainTree *left;
	struct ChainTree *right;
}ChainBinTree;
ChainBinTree *root = NULL;

typedef struct ChainTree1 {
	DATA data;
	struct ChainTree *left;
	struct ChainTree *right;
	struct ChainTree *parent;
}ChainTreeType;
//ChainTreeType *root = NULL;

//typedef struct DATA {
//	char name[10];
//	int age[10];
//}DATA;

ChainBinTree *BinTreeInit(ChainBinTree *node) {
	//初始化二叉树根节点
	if (node != NULL) {
		return node;
	}
	else {
		return NULL;
	}
}

int BinTreeAddNode(ChainBinTree *bt, ChainBinTree *node, int n) {
	//添加数据到二叉树
	//bt为父节点，node为子杰点，n=1表示添加左子树，n=2表示添加右子树
	if (bt == NULL) {
		printf("父节点不存在，请先设置父节点！\n");
		return 0;
	}
	switch (n) {
	case 1:
		if (bt->left) {
			printf("左子树节点不为空!\n");
			return 0;
		}
		else {
			bt->left = node;
		}
		break;
	case 2:
		if (bt->right) {
			printf("右子树节点不为空!\n");
			return 0;
		}
		else {
			bt->right = node;
		}
		break;
	default:
		printf("参数错误!\n");
		return 0;
	}
	return 1;
}

ChainBinTree *BinTreeLeft(ChainBinTree *bt) {
	if (bt) {
		return bt->left;
	}
	else {
		return NULL;
	}
}
ChainBinTree *BinTreeRight(ChainBinTree *bt) {
	if (bt) {
		return bt->right;
	}
	else {
		return NULL;
	}
}

int BinTreeIsEmpty(ChainBinTree *bt) {
	//判断二叉树是否为空
	if (bt) {
		return 0;
	}
	else {
		return 1;
	}
}
int BinTreeDepth(ChainBinTree *bt) {
	//求二叉树深度
	int dep1, dep2;
	if (bt == NULL) {
		return 0;
	}
	else {
		dep1 = BinTreeDepth(bt->left);
		dep2 = BinTreeDepth(bt->right);
		if (dep1 > dep2) {
			return dep1 + 1;
		}
		else {
			return dep2 + 1;
		}
	}
}

ChainBinTree *BinTreeFint(ChainBinTree *bt, DATA data) {
	//在二叉树中查找值为data的节点
	ChainBinTree *p;
	if (bt == NULL) {
		return NULL;
	}
	else {
		if (bt->data == data) {
			return bt;
		}
		else {
			if (p = BinTreeFind(bt->left, data)) {
				return p;
			}
			else if (p = BinTreeFind(bt->right, data)) {
				return p;
			}
			else {
				return NULL;
			}
		}
	}
}
void BinTreeClear(ChainBinTree *bt) {
	//清空二叉树，使之变为一颗空树
	if (bt) {
		BinTreeClear(bt->left);//清空左子树
		BinTreeClear(bt->right);//清空右子树
		free(bt);
		bt = NULL;
	}
	return;
}

void BinTree_DLR(ChainBinTree *bt, void (*oper)(ChainBinTree *p)) {
	//先序遍历，根，左，右
	if (bt) {
		oper(bt);
		BinTree_DLR(bt->left, oper);
		BinTree_DLR(bt->right, oper);

	}
	return;
}
void BinTree_LDR(ChainBinTree *bt, void(*oper)(ChainBinTree *p)) {
	//中序遍历，左，根，右
	if (bt) {
		BinTree_LDR(bt->left, oper);
		oper(bt);
		BinTree_LDR(bt->right, oper);
	}
	return;

}
void BinTree_LRD(ChainBinTree *bt, void(*oper)(ChainBinTree *p)) {
	//后序遍历，左，右，根
	if (bt) {
		BinTree_LRD(bt->left, oper);
		BinTree_LRD(bt->right, oper);
		oper(bt);
	}
	return;
}
void BinTree_Level(ChainBinTree *bt, void(*oper)(ChainBinTree *p)) {
	//按层遍历
	ChainBinTree *p;
	ChainBinTree *q[QUEUE_MAXSIZE];
	int head = 0, tail = 0;
	if (bt) {
		tail = (tail + 1) % QUEUE_MAXSIZE;//计算循环队列队尾序号
		q[tail] = bt;
	}
	while (head != tail) {
		head = (head + 1) % QUEUE_MAXSIZE;//计算循环队列的队首的序号
		p = q[head];
		oper(p);
		if (p->left != NULL) {
			tail = (tail + 1) % QUEUE_MAXSIZE;//计算循环队列的队尾序号
			q[tail] = p->left;
		}
		if (p->right != NULL) {
			tail = (tail + 1) % QUEUE_MAXSIZE;//计算循环队列的队尾序号
			q[tail] = p->right;
		}
	}
	return;
}
void oper(ChainBinTree *p) {
	//操作二叉树节点的数据
	printf("%c", p->data);
	return;
}
ChainBinTree *InitRoot() {
	//初始化二叉树
	ChainBinTree *node;
	if (node = (ChainBinTree *)malloc(sizeof(ChainBinTree))) {
		printf("\n输入根节点数据：");
		scanf("%s", &node->data);
		node->left = NULL;
		node->right = NULL;
		return node;
	}
	return NULL;
}
void AddNode(ChainBinTree *bt) {
	//添加子节点
	ChainBinTree *node, *parent;
	DATA data;
	char select;
	if (node = (ChainBinTree *)malloc(sizeof(ChainBinTree))) {
		printf("\n输入二叉树节点数据：");
		fflush(stdin);
		scanf("%s", &node->data);
		node->left = NULL;
		node->right = NULL;
		printf("输入父节点数据");
		fflush(stdin);
		scanf("%s", &data);

		parent = BinTreeFind(bt, data);

		if (!parent) {
			printf("未找到父节点！\n");
			free(node);
			return;
		}
		printf("1.添加到左子树\n2.添加到右子树\n");
		do {
			select = getch();
			select -= '0';
			if (select == 1 || select == 2) {
				BinTreeAddNode(parent, node, select);
			}
		} while (select != 1 && select != 2);
	}
	return;
}
ChainBinTree *BinTreeFind(ChainBinTree *bt, DATA data) {
	ChainBinTree *p;
	if (bt == NULL) {
		return NULL;
	}
	else {
		if (bt->data == data) {
			return bt;
		}
		else {
			if (p = BinTreeFind(bt->left, data)) {
				return p;
			}
			else if (p = BinTreeFind(bt->right, data)) {
				return p;
			}
			else {
				return NULL;
			}
		}
	}
	return;
}

int main() {
	ChainBinTree *root = NULL;
	char select;
	void(*oper1)();
	oper1 = oper;
	do {
		printf("\n1.设置二叉树根元素        2.添加二叉树节点\n");
		printf("3.先序遍历       4.中序遍历\n");
		printf("5.后序遍历       6.按层遍历\n");
		printf("7.二叉树深度     0.退出\n");
		select = getch();
		switch (select) {
		case '1':
			root = InitRoot();
			break;
		case '2':
			AddNode(root);
			break;
		case '3':
			printf("\n先序遍历的结果：");
			BinTree_DLR(root, oper1);
			printf("\n");
			break;
		case '4':
			printf("\n中序遍历的结果：");
			BinTree_LDR(root, oper1);
			printf("\n");
			break;
		case '5':
			printf("\n后序遍历的结果：");
			BinTree_LRD(root, oper1);
			printf("\n");
			break;
		case '6':
			printf("\n按层遍历的结果：");
			BinTree_Level(root, oper1);
			printf("\n");
			break;
		case '0':
			break;
		}
	} while (select != '0');
	BinTreeClear(root);
	root = NULL;
	
	getch();
	return 0;
}