关于二叉树

二叉树的性质

1,若规定节点的层数为1, 则一颗非空二叉树的第i层上最多有2^(i-1)个节点

2,若规定根节点的层数为1,则深度为h的二叉树的最大节点数是2^h -1

3,对任何一颗二叉树,如果度为0其叶节点个数为n0,度为2的分支节点个数为n2
则有 n0=n2+1

4,若规定根节点的层数是1,具有n个节点的满二叉树的深度为
h= log2 (n+1) (log以2为底,n+1为对数)

5,对于具有n个节点的完全二叉树,如果按照从上到下从左到右的数组顺序排列对所有节点从0开始编号,则对于i:
若i>0,i位置节点的双亲序号为 (i-1)/2
若2i+1<n ,左孩子序号: 2i+1 2i+1>=n则无左孩子
若2i+2<n ,右孩子序号: 2i+2 2i+2>=n则无左孩子

具体代码:
BTree.h文件

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int 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);
// 二叉树销毁
void BinaryTreeDestory(BTNode* root);
// 二叉树节点个数
int BinaryTreeSize(BTNode* root);
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root);
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 二叉树前序遍历 
void BinaryTreePrevOrder(BTNode* root);
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root);
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root);
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root);
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root);
//树的高度
int TreeHight(BTNode* root);

//创建二叉树
BTNode* CreateBTree();

BTree.c文件

#define _CRT_SECURE_NO_WARNINGS 1

#include "BTree.h"
#include "Queue.h"
BTNode* BuyNode(char x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
	{
		perror("malloc");
		return NULL;
	}
	node->data = x;
	node->left = node->right = NULL;
}
//创建二叉树
BTNode* CreateBTree()
{
	BTNode* node1 = BuyNode(1);
	BTNode* node2 = BuyNode(2);
	BTNode* node3 = BuyNode(3);
	BTNode* node4 = BuyNode(4);
	BTNode* node5 = BuyNode(5);
	BTNode* node6 = BuyNode(6);

	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;

	return node1;
}
// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
{
	if (n > pi) 
	{
		if (a[(*pi)] == '#')
		{
			(*pi)++;
			return NULL;
		}
		BTNode* root = (BTNode*)malloc(sizeof(BTNode));
		root->data = a[(*pi)++];
		root->left = BinaryTreeCreate(a, n, pi);
		root->right = BinaryTreeCreate(a, n, pi);

		return root;
	}
}
// 二叉树销毁
void BinaryTreeDestory(BTNode* root)
{
	//assert(root);
	//free(root);
	//root->data = 0;
	//root->left = root->right = NULL;
	if (root == NULL)
		return;

	BinaryTreeDestory(root->left);
	BinaryTreeDestory(root->right);
	free(root);
}

// 二叉树节点个数
//int size = 0;//每次使用时要先置为0
//int BinaryTreeSize(BTNode* root)
//{
//	if (root == NULL)
//		return 0;
//	else
//		++size;
//
//	BinaryTreeSize(root->left);
//	BinaryTreeSize(root->right);
//
//	return size;
//}
//或者
int BinaryTreeSize(BTNode* root)
{
	return root == 0 ? 0 : 
		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);
}

//树的高度
int TreeHight(BTNode* root)
{
	if (root == NULL)
		return 0;
	
	int lefttree = TreeHight(root->left);
	int righttree = TreeHight(root->right);

	return lefttree > righttree ?
		lefttree + 1 : righttree + 1;
}
// 二叉树第k层节点个数
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 == NULL)
		return;

	if (root->data == x)
		return root;
	BTNode* ret1 = BinaryTreeFind(root->left,  x);
	if (ret1)
		return ret1;
	BTNode* ret2 = BinaryTreeFind(root->right,  x);
	if (ret2)
		return ret2;

	return NULL; 

}
// 二叉树前序遍历 
void BinaryTreePrevOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	printf("%d ", root->data);
	BinaryTreePrevOrder(root->left);
	BinaryTreePrevOrder(root->right);

}
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	BinaryTreeInOrder(root->left);
	printf("%d ", root->data);
	BinaryTreeInOrder(root->right);

}
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	BinaryTreePostOrder(root->left);
	BinaryTreePostOrder(root->right);
	printf("%d ", root->data);

}
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
		QueuePush(&q, root);

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		printf("%d", front->data);

		if(front->left)
			QueuePush(&q, root->left);

		if (front->right)
			QueuePush(&q, root->right);
	}

	QueueDestroy(&q);
}
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
		QueuePush(&q, root);

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		//当判断到空时,进行下一步判断
		if (front == NULL)
		{
			break;
		}
		QueuePush(&q, front->left);
		QueuePush(&q, front->right);
	}
	//若q中剩余的节点都是空则为完全二叉树,反之则不是
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		if (front)
		{
			QueueDestroy(&q);
			return -1;
		}
	}
	QueueDestroy(&q);
	return 1;
}