二叉树 — 层次/先序遍历/广义表创建、递归/非递归遍历输出，求深度、求结点/叶子结点数

#include<iostream>
#include<queue>
#include<stack>
#include<string.h> 
#include<malloc.h>
using namespace std;

typedef char DataType;

typedef struct BiTNode {
	DataType data;
	struct BiTNode* lchild, * rchild;
}BiTNode, * BiTree;

//广义表建立二叉树，输入：A(B(D,E(G,)),C(,F))
void CreateBinTree(BiTree& Root, char* str)
{
	stack<BiTree> s;
	Root = NULL;
	BiTree p = NULL, t = NULL;
	int k, i = 0;
	while (str[i])
	{
		switch (str[i])
		{
		case '(': s.push(p); k = 1; break;
		case ')': t = s.top(); s.pop(); break;
		case ',': k = 2; break;
		default:
			p = new BiTNode();
			p->data = str[i];
			if (Root == NULL) Root = p;
			else if (k == 1)
			{
				t = s.top(); t->lchild = p;
			}
			else
			{
				t = s.top(); t->rchild = p;
			}
		}
		i++;
	}
}

void CreateBiTree_line(BiTree& root, int length, char str[]) {	//层次创建二叉树，空孩子用 # 代替
	int i = 0;
	queue<BiTree>Q;
	BiTree Temp;
	while (i < length)
	{
		char elem;
		elem = str[i];
		if (i == 0)
		{
			root = new BiTNode();		//创建，相当于 root = (BiTree)malloc(sizeof(BiTNode))
			root->data = elem;
			i++;
			Q.push(root);
			continue;
		}

		Temp = Q.front();		//每次循环都将队头赋值给，将要建立的结点的祖先结点
		if (elem == '#')		//当元素为空时
		{
			if (i % 2 == 1)		//奇—左
				Temp->lchild = NULL;
			if (i % 2 == 0)		//偶—右
			{
				Temp->rchild = NULL;
				Q.pop();		//右孩子是NULL，则其孩子已经遍历完，其可出队
			}
			i++;
		}
		else
		{
			BiTree TMP;
			TMP = new BiTNode();
			TMP->data = elem;
			if (i % 2 == 1)		//左
			{
				Temp->lchild = TMP;
			}
			if (i % 2 == 0)		//右
			{
				Temp->rchild = TMP;
				Q.pop();		//建完右结点，其祖先结点就没用了，出队列
			}
			Q.push(TMP);		//将建立的结点入队列，elem=‘#’的空结点不用入
			i++;
		}
	}
}

BiTree CreateBiTree() {           //创建二叉树（先序创建）
	BiTree T;
	char ch;
	cin >> ch;
	if (ch == '#') T = NULL;  //以‘#’表示该位置为空
	else {
		T = (BiTree)malloc(sizeof(BiTNode));
		T->data = ch;
		T->lchild = CreateBiTree();
		T->rchild = CreateBiTree();
	}
	return T;                //返回根节点
}

void PreOrderTraverse(BiTree T)		//先序遍历输出二叉树
{
	if (!T) {
		cout << "#";
		return;
	}

	cout << T->data;
	PreOrderTraverse(T->lchild);	//递归遍历左子树
	PreOrderTraverse(T->rchild);	//递归遍历右子树
}

void InOrderTraverse(BiTree T)		//中序遍历输出二叉树
{
	if (!T) return;

	InOrderTraverse(T->lchild);
	cout << T->data;
	InOrderTraverse(T->rchild);
}

void RearOrderTraverse(BiTree T)	//后序遍历输出二叉树
{
	if (!T) return;

	RearOrderTraverse(T->lchild);
	RearOrderTraverse(T->rchild);
	cout << T->data;
}

void RearOrderTraverse_N(BiTree T) {		//后序非递归遍历输出二叉树
	BiTree p = T, r = NULL;
	stack<BiTree> s;
	while (p || !s.empty()) {
		if (p) {//走到最左边
			s.push(p);
			p = p->lchild;
		}
		else {
			p = s.top();
			if (p->rchild && p->rchild != r)	//右子树存在，未被访问
				p = p->rchild;
			else {
				cout << p->data;
				s.pop();
				r = p;		//记录最近访问过的节点
				p = NULL;	//节点访问完后，重置p指针
			}
		}
	}
}

int TreeDepth(BiTree T) {		//二叉树深度
	int hl, hr, h;
	if (T != NULL)
	{
		hl = TreeDepth(T->lchild);
		hr = TreeDepth(T->rchild);
		h = hl > hr ? hl : hr;
		return h + 1;
	}
	return 0;
}

int Size(BiTree T) {			//二叉树结点数量
	if (T == NULL) return 0;
	return 1 + Size(T->lchild) + Size(T->rchild);
}

int main()
{
	BiTree T;
	T = new BiTNode();
	char str[1000] = {};
	cin >> str;
	int length = strlen(str);
	CreateBiTree_line(T, length, str);
	cout << TreeDepth(T) + 1 << endl;
	cout << 2 * Size(T) + 1 << endl;
	cout << Size(T) + 1 << endl;
	for (int i = 1; i <= Size(T) + 1; i++) {
		cout << "# ";
	}
	return 0;
}

题目：

测试结果：