【数据结构与算法】通过层次遍历判断完全二叉树 C++实现（完全二叉树+二叉链表+层次遍历+循环队列）

判断完全二叉树

题目描述

给定一棵二叉树的后序遍历序列 post[s1..t1] 和中序遍历序列 in[s2..t2]，首先构造这棵二叉树，然后设计一个算法，判断这棵二叉树是否是完全二叉树。请使用层次遍历的方法解决。

输入格式

输入包括两行：

• 第一行为后序遍历序列 post[s1..t1]。
• 第二行为中序遍历序列 in[s2..t2]。

保证构成一棵唯一的二叉树。

输出格式

输出为一行，如果给定的二叉树是完全二叉树，输出 “YES”；否则，输出 “NO”。

样例 #1

样例输入 #1

DEBGFCA
DBEAFGC

样例输出 #1

NO

样例 #2

样例输入 #2

BCA
BAC

样例输出 #2

YES

提示

首先，后序遍历的最后一个元素是树的根。然后，你可以在中序遍历序列中找到这个根，这样就可以确定哪些元素在左子树，哪些在右子树。然后，你可以递归地构造左子树和右子树。

判断是否为完全二叉树，可以使用层次遍历。如果在遍历过程中，遇到一个节点，它没有左孩子但是有右孩子，那么这个二叉树就不是完全二叉树。如果遇到一个节点，它既没有左孩子也没有右孩子，那么它后面的节点必须都是叶子节点，否则这个二叉树就不是完全二叉树。

---

思路

首先，定义一个队列 Q，并调用 initQueue(Q) 对其进行初始化。然后，将根节点 T 入队。

接下来，定义一个布尔变量 isLeaf，初始值为0，用于标记是否已经遇到了叶子节点。

然后进入一个循环，只要队列不为空，就一直执行循环。在每一次循环中，首先取出队列的首元素，然后将其出队。如果 isLeaf 为真，并且当前节点有左孩子或右孩子，那么返回0，表示这不是一个完全二叉树。

然后，根据当前节点的左右孩子的情况，有四种可能：

1. 如果左右孩子都存在，那么将左右孩子都入队。
2. 如果只有左孩子，那么将左孩子入队，并将 isLeaf 设置为1，表示已经遇到了叶子节点。
3. 如果只有右孩子，那么返回0，表示这不是一个完全二叉树。
4. 如果左右孩子都不存在，那么将 isLeaf 设置为1，表示已经遇到了叶子节点。

最后，如果循环正常结束，那么返回1，表示这是一个完全二叉树。

算法分析

时间复杂度为 $O(n)$，因为每个节点最多被访问两次（一次入队，一次出队）。空间复杂度也为 $O(n)$，因为在最坏的情况下，队列中可能需要存储所有的节点。

---

AC代码

#include <algorithm>
#include <cstring>
#include <iostream>
#define AUTHOR "HEX9CF"
using namespace std;
using Status = int;
using ElemType = char;

const int N = 1e6 + 7;
const int M = 1e4 + 7;
const int TRUE = 1;
const int FALSE = 0;
const int OK = 1;
const int ERROR = 0;
const int INFEASIBLE = -1;
// const int OVERFLOW = -2;

int n;
ElemType a[N];

struct TreeNode {
	ElemType data;
	struct TreeNode *left, *right;
};
using BiTree = TreeNode *;

struct Queue {
	TreeNode **data;
	int front;
	int rear;
};

BiTree createBiTree(char *last, char *mid, int len) {
	if (len <= 0) {
		return NULL;
	}
	// 后序序列最后一个节点为根节点
	char root = last[len - 1];
	// 中序序列中找根节点
	int index = 0;
	while (mid[index] != root) {
		index++;
	}

	// 创建根节点
	BiTree T = (TreeNode *)malloc(sizeof(TreeNode));

	T->data = root;
	T->left = createBiTree(last, mid, index);
	T->right = createBiTree(last + index, mid + index + 1, len - index - 1);
	return T;
}

Status initQueue(Queue &Q) {
	Q.data = (TreeNode **)malloc(sizeof(TreeNode *) * M);
	if (!Q.data) {
		return ERROR;
	}
	Q.front = Q.rear = 0;
	return OK;
}

bool queueEmpty(Queue &Q) { return Q.front == Q.rear; }

bool queueFull(Queue &Q) { return (Q.rear + 1) % M == Q.front; }

Status push(Queue &Q, TreeNode *e) {
	if (queueFull(Q)) {
		return ERROR;
	}
	Q.data[Q.rear] = e;
	Q.rear++;
	Q.rear %= M;
	return OK;
}

TreeNode *front(Queue Q) { return Q.data[Q.front]; }

Status pop(Queue &Q) {
	if (queueEmpty(Q)) {
		return ERROR;
	}
	Q.front++;
	Q.front %= M;
	return OK;
}

bool check(BiTree T) {
	if (!T) {
		return 1;
	}

	Queue Q;
	initQueue(Q);

	push(Q, T);
	bool isLeaf = 0;
	while (!queueEmpty(Q)) {
		TreeNode *node = front(Q);
		pop(Q);
		if (isLeaf && (node->left || node->right)) {
			return 0;
		}
		if (node->left && node->right) {
			push(Q, node->left);
			push(Q, node->right);
		} else if (node->left) {
			push(Q, node->left);
			isLeaf = 1;
		} else if (node->right) {
			return 0;
		} else {
			isLeaf = 1;
		}
	}
	return 1;
}

int main() {
	char post[N], in[N];
	cin >> post >> in;

	BiTree T = createBiTree(post, in, strlen(post));

	cout << (check(T) ? "YES" : "NO") << "\n";
	return 0;
}