二叉树

【注：非递归遍历及层序遍历等引用栈和队列，实现过程见栈和队列及其应用】

BinaryTree.h

#pragma once

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

typedef char _BTDataType;

typedef struct BinaryTreeNode
{
	_BTDataType _data;
	struct BinaryTreeNode * _left;
	struct BinaryTreeNode * _right;
}BinaryTreeNode;

BinaryTreeNode * BuyBinaryNode(_BTDataType x);
BinaryTreeNode * CreateBinaryTree(_BTDataType * a, int n, int * pi);
void DestoryBinaryTree(BinaryTreeNode ** pptree);

BinaryTreeNode * FindBinaryTree(BinaryTreeNode * root, _BTDataType x);

int SizeBinaryTree(BinaryTreeNode * root);
int LeafSizeBinaryTree(BinaryTreeNode * root);
int LevelKSizeBinaryTree(BinaryTreeNode * root, int k);//第K层结点个数
int HeightBinaryTree(BinaryTreeNode * root);
int FullBinaryTree(BinaryTreeNode * root);
int CompleteBinaryTree(BinaryTreeNode * root);

void PrevOrderBinaryTree(BinaryTreeNode * root);
void InOrderBinaryTree(BinaryTreeNode * root);
void PostOrderBinaryTree(BinaryTreeNode * root);

//遍历的非递归
void PrevOrderBinaryTreeNonR(BinaryTreeNode * root);
void InOrderBinaryTreeNonR(BinaryTreeNode * root);
void PostOrderBinaryTreeNonR(BinaryTreeNode * root);
void LevelOrderBinaryTree(BinaryTreeNode * root);//层序遍历

BinaryTree.c

#include"BinaryTree.h"
#include"Queue.h"
#include"Stack.h"

BinaryTreeNode * BuyBinaryNode(_BTDataType x)
{
	BinaryTreeNode * node = (BinaryTreeNode *)malloc(sizeof(BinaryTreeNode));
	node->_data = x;
	node->_left = NULL;
	node->_right = NULL;
	return node;
}

BinaryTreeNode * CreateBinaryTree(_BTDataType * a, int n, int * pi)
{
	if (a[*pi] != '#')
	{
		BinaryTreeNode * root = BuyBinaryNode(a[*pi]);

		++(*pi);
		root->_left = CreateBinaryTree(a, n, pi);

		++(*pi);
		root->_right = CreateBinaryTree(a, n, pi);

		return root;
	}

	return NULL;
}

void DestoryBinaryTree(BinaryTreeNode ** pptree)
{
	BinaryTreeNode * root = *pptree;

	if (root == NULL)
		return;

	DestoryBinaryTree(&root->_left);
	DestoryBinaryTree(&root->_right);
	free(root);

	*pptree = NULL;
}

BinaryTreeNode * FindBinaryTree(BinaryTreeNode * root, _BTDataType x)
{
	BinaryTreeNode * ret;

	if (root == NULL || root->_data == x)
		return root;

	ret = FindBinaryTree(root->_left, x);
	if (ret)
		return ret;

	ret = FindBinaryTree(root->_right, x);
	if (ret)
		return ret;

	return NULL;
}

int SizeBinaryTree(BinaryTreeNode * root)
{
	if (root == NULL)
		return 0;

	return SizeBinaryTree(root->_left) + SizeBinaryTree(root->_right) + 1;
}

int LeafSizeBinaryTree(BinaryTreeNode * root)
{
	if (root == NULL)
		return 0;

	if (root->_left == NULL && root->_right == NULL)
		return 1;

	return LeafSizeBinaryTree(root->_left) + LeafSizeBinaryTree(root->_right);
}

int LevelKSizeBinaryTree(BinaryTreeNode * root, int k)
{
	if (root == NULL)
		return 0;

	if (k == 1)
		return 1;

	return LevelKSizeBinaryTree(root->_left, k - 1) + LevelKSizeBinaryTree(root->_right, k - 1);
}

int HeightBinaryTree(BinaryTreeNode * root)
{
	int left_height = 0, right_height = 0;

	if (root == NULL)
		return 0;

	left_height = HeightBinaryTree(root->_left) + 1;
	right_height = HeightBinaryTree(root->_right) + 1;

	return left_height > right_height ? left_height : right_height;
}

int FullBinaryTree(BinaryTreeNode * root)
{
	Queue q;
	InitQueue(&q);

	if (root)
		PushQueue(&q, root);

	while (isEmptyQueue(&q))
	{
		_QTdatatype front = FrontQueue(&q);

		if ((front->_left == NULL && front->_right == NULL) ||
			(front->_left != NULL && front->_right != NULL))
			PopQueue(&q);
		else
			return 0;

		if (front->_left)
			PushQueue(&q, front->_left);

		if (front->_right)
			PushQueue(&q, front->_right);
	}

	DestoryQueue(&q);
	return 1;
}

int CompleteBinaryTree(BinaryTreeNode * root)
{
	Queue q;
	InitQueue(&q);

	if (root)
		PushQueue(&q, root);

	while (isEmptyQueue(&q))
	{
		BinaryTreeNode * front = FrontQueue(&q);
		PopQueue(&q);

		if (front)
		{
			PushQueue(&q, front->_left);
			PushQueue(&q, front->_right);
		}
		else
			break;
	}
	while (isEmptyQueue(&q))
	{
		BinaryTreeNode * front = FrontQueue(&q);

		if (front)
			return 0;
		PopQueue(&q);
	}

	DestoryQueue(&q);
	return 1;
}

void PrevOrderBinaryTree(BinaryTreeNode * root)
{
	if (root == NULL)
		return;
	printf("%c ",root->_data);
	PrevOrderBinaryTree(root->_left);
	PrevOrderBinaryTree(root->_right);
}

void InOrderBinaryTree(BinaryTreeNode * root)
{
	if (root == NULL)
		return;
	InOrderBinaryTree(root->_left);
	printf("%c ",root->_data);
	InOrderBinaryTree(root->_right);
}

void PostOrderBinaryTree(BinaryTreeNode * root)
{
	if (root == NULL)
		return;
	PostOrderBinaryTree(root->_left);
	PostOrderBinaryTree(root->_right);
	printf("%c ", root->_data);
}

void PrevOrderBinaryTreeNonR(BinaryTreeNode * root)
{
	_STDataType cur = root;
	Stack s;
	InitStack(&s);

	while (cur || isEmptyStack(&s))
	{
		//访问左路节点，左路节点入栈
		while (cur)
		{
			printf("%c ", cur->_data);
			PushStack(&s, cur);
			cur = cur->_left;
		}

		//栈里面出来的节点，表示左数已经访问过了
		_STDataType top = TopStack(&s);
		PopStack(&s);

		//子问题方式访问右子树
		cur = top->_right;
	}

	DestoryStack(&s);
}

void InOrderBinaryTreeNonR(BinaryTreeNode * root)
{
	_STDataType cur = root;
	Stack s;
	InitStack(&s);

	while (cur || isEmptyStack(&s))
	{
		while (cur)
		{
			PushStack(&s, cur);
			cur = cur->_left;
		}

		_STDataType top = TopStack(&s);
		printf("%c ", top->_data);
		PopStack(&s);

		cur = top->_right;
	}

	DestoryStack(&s);
}

void PostOrderBinaryTreeNonR(BinaryTreeNode * root)
{
	_STDataType cur = root;
	_STDataType prev = NULL;
	Stack s;
	InitStack(&s);

	while (cur || isEmptyStack(&s))
	{
		while (cur)
		{
			PushStack(&s, cur);
			cur = cur->_left;
		}

		_STDataType top = TopStack(&s);

		//右子树为空 || 上一个访问的节点是我右子树的根
		if (top->_right == NULL || top->_right == prev)
		{
			printf("%c ", top->_data);
			prev = top;
			PopStack(&s);
		}
		else
			cur = top->_right;
	}

	DestoryStack(&s);
}

void LevelOrderBinaryTree(BinaryTreeNode * root)
{
	Queue q;
	InitQueue(&q);

	if (root)
		PushQueue(&q, root);

	while (isEmptyQueue(&q))
	{
		_QTdatatype front = FrontQueue(&q);
		printf("%c ", front->_data);
		PopQueue(&q);

		if (front->_left)
			PushQueue(&q, front->_left);

		if (front->_right)
			PushQueue(&q, front->_right);
	}

	DestoryQueue(&q);
}

Test.c

#include"BinaryTree.h"

void testBinaryTree()
{

	int i = 0;
	BinaryTreeNode * ret;
	//char array[] = {'A','B','D','#','#','#','C','E','#','#','F','#','G','#','#'};
	char array[] = { 'A','B','D','#','#','E','#','#','C','F','#','#','G','#','#' };

	BinaryTreeNode * tree = CreateBinaryTree(array, sizeof(array) / sizeof(_BTDataType), &i);
	
	PrevOrderBinaryTree(tree);
	printf("\n");

	InOrderBinaryTree(tree);
	printf("\n");

	PostOrderBinaryTree(tree);
	printf("\n");

	PrevOrderBinaryTreeNonR(tree);
	printf("\n");

	InOrderBinaryTreeNonR(tree);
	printf("\n");

	PostOrderBinaryTreeNonR(tree);
	printf("\n");

	LevelOrderBinaryTree(tree);
	printf("\n");

	ret = FindBinaryTree(tree, 'E');
	printf("'E'	%p\n", ret);
	ret = FindBinaryTree(tree, 'X');
	printf("'X'	%p\n", ret);

	printf("SizeBinaryTree		%d\n", SizeBinaryTree(tree));
	printf("LeafSizeBinaryTree	%d\n", LeafSizeBinaryTree(tree));
	printf("LevelKSizeBinaryTree	%d\n", LevelKSizeBinaryTree(tree,2));
	printf("HeightBinaryTree	%d\n", HeightBinaryTree(tree));
	printf("FullBinaryTree		%d\n", FullBinaryTree(tree));
	printf("CompleteBinaryTree	%d\n", CompleteBinaryTree(tree));

	DestoryBinaryTree(&tree);

}

int main()
{
	testBinaryTree();
	return 0;
}