初阶数据结构——二叉树

树的概念及结构

树的概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

• 有一个特殊的结点，称为根结点，根节点没有前驱结点，也就是没有父节点
• 除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继
• 因此，树是递归定义的。

注意：树形结构中，子树之间不能有交集，否则就不是树形结构

树的相关概念

节点层次的描述，一般是从第一层开始，跟数组不同

有些地方从0开始也是可以的，对于数组来说下标从0开始是因为
a[i] 本质上被转换成 -> *(a+i)
下标必须从0开始才能完成访问

推荐从1开始，
如果从1开始那么一个节点的高度是1，空树的高度是0
从0开始一个节点高度是0，空树高度是 -1

树的表示

树在实际中的运用

计算机的文件系统就是一个典型的树结构

二叉树概念及结构

一棵二叉树是结点的一个有限集合，该集合:

1. 或者为空
2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成

从上图可以看出

1. 二叉树不存在度大于2的结点

2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

特殊的二叉树

1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是2^k - 1 ，则它就是满二叉树。
2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。
   

二叉树的性质

小题练习：

某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（ ）
A 不存在这样的二叉树
B 200
C 198
D 199
答案：B

在具有 2n 个结点的完全二叉树中，叶子结点个数为（ ）
A n
B n+1
C n-1
D n/2
答案：A

一棵完全二叉树的节点数位为531个，那么这棵树的高度为（ ）
A 11
B 10
C 8
D 12
答案：B

代值确定范围

一个具有767个节点的完全二叉树，其叶子节点个数为（）
A 383
B 384
C 385
D 386
答案：B

二叉树的存储结构

二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。

1. 顺序存储
   顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储。
   二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。

2. 链式存储
   二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。链式结构又分为二叉链和三叉链，当前我们学习中一般都是二叉链，以后学到如红黑树等会用到三叉链。

二叉树的顺序结构及实现

二叉树的顺序结构

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

堆的概念及结构

将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

堆的实现

堆的本质是数组，那么底层实现堆的时候可以用数组来实现

堆的结构：

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;

初始化堆：

void HeapInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->size = 0;
	php->capacity = 0;
}

销毁堆：

void HeapDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->size = 0;
	php->capacity = 0;
}

插入数据：

void HeapPush(HP* php, HPDataType x)
{
	assert(php);
	//检查扩容
	if (php->size == php->capacity)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->a,sizeof(HPDataType)*newcapacity);
		if (tmp == NULL)
		{
			perror("malloc fail\n");
			return;
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}
	php->a[php->size++] = x;
	//为了插入数据后保持这个结构还是堆
    //向上调整算法
	AdjustUp(php->a, php->size-1);
}

向上调整算法：

向上调整的前提是保证前面是堆。

注意点：while条件不用parent>=0是因为parent在child=0的时候parent = (child - 1) / 2，
parent是int类型，整数后面的小数会被忽略，所以parent不会小于0

void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;

    //条件不用parent>=0是因为parent在child=0的时候parent = (child - 1) / 2，
	//parent是int类型，整数后面的小数会被忽略，所以parent不会小于0
	while (child > 0)
	{
		//建小堆，则child比parent小的话就交换

		if (a[parent] > a[child])
		{
			Swap(&a[parent], &a[child]);
			child = parent;
			parent= (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

删除堆顶数据：

如果直接挪动覆盖，那么原来的兄弟关系就可以变成父子关系，兄弟关系之间没有联系，父子关系之间有联系，只能重新建堆才能保证这是堆，所以挪动覆盖删除不可取

交换首尾数据再删除，现在需要把移动到堆顶的元素放到它正确的位置，那么就需要向下调整算法

void HeapPop(HP* php)
{
    assert(php);
	assert(!HeapEmpty(php));
	
	//让堆顶元素和最后一个元素交换
	//然后size--
	//进行向下调整
	Swap(&php->a[php->size - 1], &php->a[0]);
	php->size--;
	AdjustDown(php->a, php->size, 0);
}

向下调整算法：

向下调整的前提是左子树和右子树是大堆/小堆

void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
void AdjustDown(HPDataType* a,int n, int parent)//n表示的是数据个数
{
	int child = parent * 2 + 1;//默认左孩子要和父亲比较
	while (child < n)
	{
		//child没有越界，但是不确定child+1会不会越界，所以要判定一下
		if (child+1<n && a[child + 1] < a[child])
		{
			child++;
		}
		if (a[parent] > a[child])
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

堆的数据个数：

HPDataType HeapSize(HP* php)
{
	assert(php);
	return php->size;
}

堆的判空：

bool HeapEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

插入和删除的时间复杂度

插入的最大消耗是向上调整
删除的最大消耗是向下调整

向上、向下调整最坏调整高度次

所以他们的时间复杂度是log N

将数据有序打印

想让数组成为一个堆的一种方式是往堆里插入然后向上调整
向上调整的前提是保证前面是堆。

想把数据有序打印，可以在堆顶拿到最值，然后打印，
删除掉堆顶的数据(交换，向下调整)，选出次大/次小值

int main()
{
	HP hp;
	HeapInit(&hp);
	int a[] = { 65,100,70,32,50,60 };
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
	{
		HeapPush(&hp,a[i]);
	}
	while (!HeapEmpty(&hp))
	{
		int top = HeapTop(&hp);
		HeapPop(&hp);
		printf("%d\n", top);
	}
	return 0;
}

这样可以把数据变成有序的打印，但还不是堆排序
这不是把内存中的数据变有序，而是把堆顶的数据取出来打印。

堆排序

在实际解决问题时堆可以作为一个数据结构，在实际中想排序的话：

有一堆数据，我们想把它排成有序
如果现在对数组排序，可以用刚才写的堆的数据结构来解决
把数组中数据插入到堆里，然后取到堆顶数据后依次拷贝回数组

void HeapSort(int* a, int n)
{
	HP hp;
	HeapInit(&hp);
	// N*logN
	for (int i = 0; i < n; ++i)
	{
		HeapPush(&hp, a[i]);
	}

	// N*logN
	int i = 0;
	while (!HeapEmpty(&hp))
	{
		int top = HeapTop(&hp);
		a[i++] = top;
		HeapPop(&hp);
	}

	HeapDestroy(&hp);
}

用这种方式排序是不好的，弊端：1、先有一个堆,太麻烦。2、空间复杂度+拷贝数据

能不能直接把数组弄成堆？
数组可能不是堆，但它是一个完全二叉树。
那么要排序的第一步是建堆

可以向上调整建堆，也可以向下调整建堆

向上调整的前提是：前面是堆

这种情况下不能对数组的末尾元素进行向上调整

那么模拟插入的过程，把第一个数看作堆里的，然后把第二个，第三个…向上调整

    //建堆--向上调整建堆
	for (int i = 1; i < n; i++)
	{
		AdjustUp(a, i);
	}

向下调整的前提是：左子树和右子树是大堆/小堆

从5开始调整，然后3，8，7
根据下标 i 的移动来确定要调整的位置

for (int i = (n-1-1)/2; i >= 0; --i)//n是个数
	{
		AdjustDown(a, n, i);
	}

如果要排升序，建大堆还是小堆？

建小堆应该是排降序

void HeapSort(int* a, int n)
{
	// 升序 -- 建大堆
	// 降序 -- 建小堆


	// 建堆--向上调整建堆
	for (int i = 1; i < n; i++)
	{
		AdjustUp(a, i);
	}

	// N*logN
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);

		// 再调整，选出次小的数
		AdjustDown(a, end, 0);

		--end;
	}
}

swap之后不先 - - end再调整的原因是：end在swap之后对AdjustDown来说相当于传的是数据个数

建堆的时间复杂度

向下建堆 O(N)：

向下调整的特点是：
节点多，向下调整的次数少，
节点少，向下调整的次数多。
也就是 多 * 少 + 少 * 多

向上建堆O (N*logN) ：

向上调整的特点是：
节点少，向上调整的次数少，
节点多，向上调整次数多。
也就是 多 * 多 + 少 * 少 的情况，是比向下建堆吃亏的地方

堆排序的时间复杂度

O(N*logN)

TOP-K问题

文件中要读取整数可以用fread和fwrite，但是二进制的写进去是看不懂的
用fprintf和fscanf更好，可以看到写进去的数是什么

void CreateNDate()
{
	// 造数据
	int n = 10000;
	srand(time(0));
	const char* file = "data.txt";
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen error");
		return;
	}

	for (size_t i = 0; i < n; ++i)
	{
		int x = rand() % 1000000;
		fprintf(fin, "%d\n", x);
	}

	fclose(fin);
}

void PrintTopK(int k)
{
	const char* file = "data.txt";
	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen error");
		return;
	}

	int* kminheap = (int*)malloc(sizeof(int) * k);
	if (kminheap == NULL)
	{
		perror("malloc error");
		return;
	}

	for (int i = 0; i < k; i++)
	{
		fscanf(fout, "%d", &kminheap[i]);
	写的时候是%d\n,但读的时候不用加\n
	值和值之间默认空格或换行间隔
默认scanf读数据的时候空格换行直接就是多项数据之间的分割，所以读的时候不用加\n
	}

	// 建小堆
	for (int i = (k-1-1)/2; i >= 0; i--)
	{
		AdjustDown(kminheap, k, i);
	}

	int val = 0;
	while (!feof(fout))
	{
		fscanf(fout, "%d", &val);//文件指针是自动移动的，所以不是从头开始读
		if (val > kminheap[0])
		{
			kminheap[0] = val;
			AdjustDown(kminheap, k, 0);
		}
	}

	for (int i = 0; i < k; i++)
	{
		printf("%d ", kminheap[i]);
	}
	printf("\n");
}

int main()
{
	//createNDate();
	PrintTopk(5);
	return 0;
}

如果两个函数同时调用，屏幕上虽然打印出了五个值，但没办法确认是不是n个随机数中最大的。
所以不能每次都调用createNDate，每次调用都会产生新的随机数，先创建n个随机数，然后打开文件让其中k个随机数变大(注意不要溢出)

二叉树链式结构的实现

需要一棵树，但现在没有增删查改，可以手动构建一棵树

typedef int BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

BTNode* BuyNode(BTDataType x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
	{
		perror("malloc fail\n");
		return NULL;
	}

	node->data = x;
	node->left = NULL;
	node->right = NULL;

	return node;
}

BTNode* CreatBinaryTreeNode()
{
	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;
}

二叉树的前中后序遍历

void PrveOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	printf("%d ", root->data);
	PrveOrder(root->left);
	PrveOrder(root->right);
}

void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}

void PostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->data);
}

递归由子问题和返回条件构成
递归如果没有返回条件，就会栈溢出，因为递归会不断建立栈帧

不管是前中后序，访问这棵树的时间复杂度是O(N)
一共n个节点，累计起来

空间复杂度是O(h)
h是高度，h范围[ log N , N ]

二叉树节点个数

递归是在不同栈帧中，如果定义一个size，每个栈帧中都有size，++size是不可以的。

因为是静态变量，递归调用的时候不会再定义一个size，会自动跳过static int size=0；这句代码，因为size不在栈帧中，而是在静态区，可以通过打印地址和数值观察。

程序是对的，但拿不到size，size生命周期是全局的，但它的作用域在当前函数，那么想拿到size可以把size定义成全局变量

如果想用return拿到size会有些问题，用了第二次的时候size就不会重0开始了

int BTreeSize(BTNode* root)
{
	static int size = 0;

	//printf("%p,%d\n", &size, size);

	if (root == NULL)
		return size;

	++size;

	BTreeSize(root->left);
	BTreeSize(root->right);

	return size;
}

如果想每用一次就置0，那也是不行的，因为只有在函数内部才能访问size

要用变量计数的方法还是得用全局变量，记得在第二次使用前把size置成0

//遍历计数
int size = 0;
void BTreeSize(BTNode* root)
{
	if (root == NULL)
		return;

	++size;

	BTreeSize(root->left);
	BTreeSize(root->right);
}

要求节点个数，就去找左树和右树，然后把左右树的结果汇总
主要不为空就要去调用下一层

int BTreeSize(BTNode* root)
{
	return root == NULL ? 0 : 
	BTreeSize(root->left) + BTreeSize(root->right) + 1;
}

二叉树叶子节点个数

int BTreeLeafSize(BTNode* root)
{
	if (root == NULL)//肯定不是叶子
		return 0;

	//接下来判定是叶子还是分支
	if (root->left == NULL
		&& root->right == NULL)
		return 1;//叶子
	else
		return BTreeLeafSize(root->left) + BTreeLeafSize(root->right);//分支
}

二叉树高度

这种写法不算错，但是有点多此一举，就像要上报最高人的身高，两个人说了身高之后，我判断出了哪个人高，但是忘记了具体的身高是多少，于是找那个高的人又报了一次他的高度。可怕的是忘记不只是忘记一次

不仅仅是两倍关系
等比数列的增长很可怕

改进：

int BTreeHeight(BTNode* root)
{
	if (root == NULL)
		return 0;

	int leftHeight = BTreeHeight(root->left);
	int rightHeight = BTreeHeight(root->right);

	return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}

int Max(int p1, int p2)
{
	return p1 > p2 ? p1 : p2;
}

//求二叉树的高度
int BTreeHeight(BTNode* root)
{
	if (root == NULL)
		return 0;

	return Max(BTreeHeight(root->left),BTreeHeight(root->right))+1;
}

二叉树第k层节点个数

思路：

int BinaryTreeLevelKSize(BTNode* root, int k)
{
    assert(k > 0);
    
	if (root == NULL)
		return 0;
	if (k == 1)
		return 1;
	else
		return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}

二叉树查找值为x的节点

思路：
前序查找
先根，然后左子树，右子树

BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
		return NULL;
	if (root->data == x)
		return root;

	//BTNode* L1 = BinaryTreeFind(root->left,x);
	//BTNode* L2 = BinaryTreeFind(root->right,x);
	//return L1 == NULL ? L2 : L1;
	//有点多此一举了，在左数L1如果已经找到就不用再递归调用L2了，应该直接返回L1

	BTNode* L1 = BinaryTreeFind(root->left, x);
	if (L1)
		return L1;
	BTNode* L2 = BinaryTreeFind(root->right, x);
	if (L2)
		return L2;

	return NULL;
}

层序遍历

队列中不能存1，存1就不能找到left和right，应该存节点的指针

typedef BTNode* QDataType;
是不行的，因为.h文件在typedef BTNode的上面

void LevelOrder(BTNode* root)
{
	//创建一个堆，通过先进先出的特性实现一层出带下一层入
	Queue pq;
	QueueInit(&pq);

	if(root)
	QueuePush(&pq, root);
	while (!QueueEmpty(&pq))
	{
		QDataType front = QueueFront(&pq);//出的数据是树节点的指针
		printf("%d ", front->data);
		QueuePop(&pq);

		if(front->left)
		QueuePush(&pq, front->left);
		if (front->right)
		QueuePush(&pq, front->right);
	}
	QueueDestroy(&pq);
}

Pop删的是队列的节点，但是树节点还是可以去访问

完整代码：

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

typedef struct BinaryTreeNode* QDataType;

//链表队列
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;

//为了方便尾插头插和个数的记录
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

//初始化队列
void QueueInit(Queue* pq);
//入队列，尾插
void QueuePush(Queue* pq, QDataType x);
//出队列，头删
void QueuePop(Queue* pq);
//销毁
void QueueDestroy(Queue* pq);
//检测队列是否为空
bool QueueEmpty(Queue* pq);
//取队头元素
QDataType QueueFront(Queue* pq);

//初始化队列
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;

	pq->size = 0;
}
//入队列，尾插
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* tmp = (QNode*)malloc(sizeof(QNode));
	if (tmp == NULL)
	{
		perror("malloc fail\n");
		return;
	}
	tmp->data = x;
	tmp->next = NULL;

	if (pq->tail == NULL)
	{
		pq->head = pq->tail = tmp;
	}
	else
	{
		pq->tail->next = tmp;
		pq->tail = tmp;
	}
	pq->size++;
}
//出队列，头删
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}

	pq->size--;
}
//销毁
void QueueDestroy(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}
//检测队列是否为空
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->head == NULL && pq->tail==NULL;
}
//取队头元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

typedef int BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

BTNode* BuyNode(BTDataType x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
	{
		perror("malloc fail\n");
		return NULL;
	}

	node->data = x;
	node->left = NULL;
	node->right = NULL;

	return node;
}

BTNode* CreatBinaryTreeNode()
{
	BTNode* node1 = BuyNode(1);
	BTNode* node2 = BuyNode(2);
	BTNode* node3 = BuyNode(3);
	BTNode* node4 = BuyNode(4);
	BTNode* node5 = BuyNode(5);
	BTNode* node6 = BuyNode(6);
	BTNode* node7 = BuyNode(7);

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

	return node1;
}

void LevelOrder(BTNode* root)
{
	//创建一个堆，通过先进先出的特性实现一层出带下一层入
	Queue pq;
	QueueInit(&pq);

	if(root)
	QueuePush(&pq, root);
	while (!QueueEmpty(&pq))
	{
		QDataType front = QueueFront(&pq);//出的数据是树节点的指针
		printf("%d ", front->data);
		QueuePop(&pq);

		if(front->left)
		QueuePush(&pq, front->left);
		if (front->right)
		QueuePush(&pq, front->right);
	}
	QueueDestroy(&pq);
}

int main()
{
	BTNode* root = CreatBinaryTreeNode();
	LevelOrder(root);
	return 0;
}

小题两道：

二叉树的先序遍历和中序遍历如下：先序遍历：EFHIGJK;中序遍历：HFIEJKG.则二叉树根结点为（）
A. E
B. F
C. G
D .H

设一课二叉树的中序遍历序列：badce，后序遍历序列：bdeca，则二叉树前序遍历序列为____。
A adbce
B decab
C debac
D abcde

前序和后序可以帮助我们确立根，中序能分出左右区间

二叉树销毁

// 二叉树销毁
void BTreeDestory(BTNode* root)
{
	if (root == NULL)
		return;

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

判断二叉树是否是完全二叉树

bool BinaryTreeComplete(BTNode* root);

思路：
层序遍历，进队列的时候NULL也要进，出队列的时候如果遇到NULL就出循环，然后再遍历队列，如果有非空就说明不是完全二叉树

代码：

bool BinaryTreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
		QueuePush(&q, root);
	while (!QueueEmpty(&q))
	{
		QDataType front = QueueFront(&q);
		QueuePop(&q);
		if (front == NULL)
			break;

		QueuePush(&q, front->left);
		QueuePush(&q, front->right);

	}
	while (!QueueEmpty(&q))
	{
		QDataType front = QueueFront(&q);
		QueuePop(&q);
		if (front != NULL)
		{
			QueueDestroy(&q);
			return false;
		}
	}
	QueueDestroy(&q);
	return true;
}

int main()
{
	BTNode* root = CreatBinaryTreeNode();
	bool tmp = BinaryTreeComplete(root);
	if (tmp == true)
		printf("true\n");
	else
		printf("false\n");
	return 0;
}