数据结构--二叉树

1. 树
一种非线性的数据结构，由n（n>=0）个有效结点组成的一个具有层次关系的集合。
树的特点：
（1）有一个特殊的结点，称为根结点，根结点没有前驱结点；
（2）每棵子树的根结点有且只有一个前驱，可以有0个或多个后继；
（3）树是递归定义的。
2.二叉树
一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。
二叉树的特点：
（1）每个结点最多有两棵子树，即二叉树不存在度大于2的结点；
（2）二叉树的子树有左右之分，其子树的次序不能颠倒。
二叉树的性质
（1） 对任何一棵二叉树, 如果度为0其叶结点个数为 n0, 度为2的分支结点个数为 n2,则有n0＝n2＋1
（2）对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：

1. 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
2. 若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子
3. 若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子

3.满二叉树和完全二叉树

4.二叉树链式结构遍历
（1）前序遍历：根–左子树–右子树；
（2）中序遍历：左子树–根--右子树；
（3）后序遍历：左子树–右子树–根。
5. 二叉树的操作（创建、销毁、结点个数、叶子结点个数、第k层结点个数、查找数据、前序遍历、中序遍历、后序遍历、层次遍历）

#include<stdlib.h>
#include<stdio.h>

typedef char BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType _data;
	struct BinaryTreeNode* _left;
	struct BinaryTreeNode* _right;
}BTNode;

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
{
	if (a[*pi] == '#' || *pi >= n)
	{
		(*pi)++;
		return NULL;//空树
	}
	//当前树的根结点
	BTNode* root = (BTNode*)malloc(sizeof(BTNode));
	root->_data = a[*pi];
	(*pi)++;
	root->_left = BinaryTreeCreate(a,n,pi);
	root->_right = BinaryTreeCreate(a, n, pi);
	return root;
}
// 二叉树销毁
void BinaryTreeDestory(BTNode** root)
{
	if (*root)
	{
		BinaryTreeDestory(&(*root)->_left);
		BinaryTreeDestory(&(*root)->_right);
		free(*root);
		*root = NULL;
	}
}
// 二叉树节点个数  左子树个数+右子树个数+当前结点
int BinaryTreeSize(BTNode* root)
{
	if (root == NULL)
		return 0;
	return BinaryTreeSize(root->_left) + BinaryTreeSize(root->_right) + 1;
}
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{
	//空树
	if (root == NULL)
		return 0;
	//叶子结点
	if (root->_left == NULL && root->_right == NULL)
		return 1;
	//非叶子
	return BinaryTreeLeafSize(root->_left) + BinaryTreeLeafSize(root->_right);
}
// 二叉树第k层节点个数 左右子树k-1层结点个数之和
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	//空树
	if (root == NULL)
		return 0;
	if (k == 1)
		return 1;
	return BinaryTreeLevelKSize(root->_left, k - 1) + BinaryTreeLevelKSize(root->_right, k - 1);
}
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root)
	{
		BTNode* node;
		if (root->_data == x)
			return root;
		node = BinaryTreeFind(root->_left, x);
		if (node)
			return node;
		else
			return BinaryTreeFind(root->_right, x);
	}
	else
		return NULL;
}
// 二叉树前序遍历  根 左子树  右子树
void BinaryTreePrevOrder(BTNode* root)
{
	if (root)
	{
		printf("%c ", root->_data);
		BinaryTreePrevOrder(root->_left);
		BinaryTreePrevOrder(root->_right);
	}
}
// 二叉树中序遍历  左子树  根  右子树
void BinaryTreeInOrder(BTNode* root)
{
	if (root)
	{
		BinaryTreeInOrder(root->_left);
		printf("%c ", root->_data);
		BinaryTreeInOrder(root->_right);
	}
}
// 二叉树后序遍历  左子树  右子树  根
void BinaryTreePostOrder(BTNode* root)
{
	if (root)
	{
		BinaryTreePostOrder(root->_left);
		BinaryTreePostOrder(root->_right);
		printf("%c ", root->_data);
	}
}

//队尾入队，队头出队

typedef QDataType;

typedef struct QNode
{
	struct QNode* _next;
	QDataType _data;
}QNode;

// 队列的结构
typedef struct Queue
{
	//头尾指针
	QNode* _head;
	QNode* _tail;
	int _size;
}Queue;
struct QNode* creatNode(QDataType val)
{
	struct QNode* node = (QNode*)malloc(sizeof(QNode));
	node->_data = val;
	node->_next = NULL;
}
//初始化
void initQueue(Queue* q)
{
	//空队列
	if (q == NULL)
		return;
	q->_head = q->_tail = NULL;
	q->_size = 0;
}
void queuePush(Queue* q, QDataType val)
{
	struct	QNode* node = creatNode(val);
	if (q->_head == NULL)
		q->_head = q->_tail = node;
	else {
		q->_tail->_next = node;
		q->_tail = node;
	}
	++q->_size;
}
void queuePop(Queue* q)
{
	if (q == NULL || q->_head == NULL)
		return;
	struct QNode* next = q->_head->_next;
	free(q->_head);
	q->_head = next;
	if (q->_head == NULL)
		q->_tail = NULL;
	--q->_size;
}
QDataType queueFront(Queue* q)
{
	if (q == NULL)
		return NULL;
	return q->_head->_data;
}
int queueEmpty(Queue* q)
{
	return q->_head == NULL;
}

void queueDestroy(Queue* q)
{
	QNode* cur = q->_head;
	while (cur)
	{
		QNode* next = cur->_next;
		free(cur);
		cur = q->_head;
	}
}
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
	Queue q;
	BTNode* node;
	initQueue(&q);
	queuePush(&q, root);
	while (!queueEmpty(&q))
	{
		node = queueFront(&q);
		printf("%c ", node->_data);
		if (node->_left)
		{
			queuePush(&q, node->_left);
		}
		if (node->_right)
		{
			queuePush(&q, node->_right);
		}
		queuePop(&q);
	}
	queueDestroy(&q);
}
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root)
{
	Queue q;
	initQueue(&q);
	if (root)
		queuePush(&q, root);
	while (!queueEmpty(&q))
	{
		//获取队头元素
		BTNode* node = queueFront(&q);
		queuePop(&q);
		//左右孩子入队
		if (node)
		{
			queuePush(&q, node->_left);
			queuePush(&q, node->_right);
		}
		else
			break;
	}
	while (!queueEmpty(&q))
	{
		BTNode* node = queueFront(&q);
		if (node)
			return 0;
	}
	return 1;
}

void test()
{
	char a[] = "ABD##E#H##CF##G##";
	int pi = 0;
	int n = sizeof(a) / sizeof(a[0]);
	BTNode* root = BinaryTreeCreate(a, n, &pi);
	printf("size:%d\n", BinaryTreeSize(root));
	printf("leafsize:%d\n",BinaryTreeLeafSize(root));
	printf("ksize:k=%d: %d\n", 5, BinaryTreeLevelKSize(root, 5));
	printf("ksize:k=%d: %d\n", 4, BinaryTreeLevelKSize(root, 4));
	printf("ksize:k=%d: %d\n", 3, BinaryTreeLevelKSize(root, 3));
	printf("ksize:k=%d: %d\n", 2, BinaryTreeLevelKSize(root, 2));
	printf("ksize:k=%d: %d\n", 1, BinaryTreeLevelKSize(root, 1));
	BTNode* node;
	node = BinaryTreeFind(root, 'E');

	BinaryTreePrevOrder(root);
	printf("\n");
	BinaryTreeInOrder(root);
	printf("\n");
	BinaryTreePostOrder(root);
	printf("\n");
	BinaryTreeLevelOrder(root);
	BinaryTreeComplete(root);
	BinaryTreeDestory(&root);
}
int main()
{
	test();
	return 0;
}