二叉树的基础问题

先给定一个二叉树的图作为样例：

图中下边没有给出的表示为空，图画的不好，将就着看吧。

下面的代码中分别给出了二叉树的前中后的递归遍历和非递归遍历，最后还给出层次遍历。

#include<iostream>
#include<deque>
#include<stack>
using namespace std;
#define NIL '#'
typedef struct tree_node{
	char data;
	struct tree_node *lchild,*rchild;
}BiTNode,*BiTree;
void create_tree(BiTree *T) {
	char ch; 
	scanf("%c", &ch);
	if(ch == NIL){
		*T = NULL;
	} else {
		*T = (BiTNode*)malloc(sizeof(BiTNode));
		(*T)->data = ch;
		create_tree(&(*T)->lchild);
		create_tree(&(*T)->rchild);
	}
}
void pre_order_traverse_recursive(BiTree T) { //前根递归遍历
	if(T) {
		cout << T->data << " ";
		pre_order_traverse_recursive(T->lchild);
		pre_order_traverse_recursive(T->rchild);
	}
}

void pre_order_traverse_iterative(BiTree T) {  //前根非递归遍历
	stack<BiTNode *> m_stack;
	m_stack.push(T);
	BiTNode *p;
	while(!m_stack.empty()) {
		while((p = m_stack.top()) != NULL) {
			cout << p->data << " ";
			m_stack.push(p->lchild);
		}
		
		m_stack.pop();

		if(!m_stack.empty()) {
			p = m_stack.top();
			m_stack.pop();
			m_stack.push(p->rchild);
		}
	}
}
void in_order_traverse_recursive(BiTree T) { //中根递归遍历
	if(T) {
		in_order_traverse_recursive(T->lchild);
		cout << T->data << " ";
		in_order_traverse_recursive(T->rchild);
	}
}
void in_order_traverse_iterative(BiTree T) { //中根非递归遍历
	stack<BiTNode*> m_stack;
	m_stack.push(T);
	BiTNode *p;

	while(!m_stack.empty()) {
		while((p = m_stack.top()) != NULL) 
			m_stack.push(p->lchild);

		m_stack.pop();

		if(!m_stack.empty()) {
			p = m_stack.top();
		    m_stack.pop();
			cout << p->data << " ";
			m_stack.push(p->rchild);
		}
	}
}

void post_order_traverse_recursive(BiTree T) { //后根递归遍历
	if(T) {
		post_order_traverse_recursive(T->lchild);
		post_order_traverse_recursive(T->rchild);
		cout << T->data << " ";
	}
}

void post_order_traverse_iterative(BiTree T) { //后根非递归遍历
	stack<BiTNode*> m_stack;
	BiTNode *p;
	BiTNode *r;
	p = T;
	while(p || !m_stack.empty()) {
		if(p) {
			m_stack.push(p);
			p = p->lchild;
		} else {
			p = m_stack.top();
			if(p->rchild && p->rchild != r) {
				p = p->rchild;
				m_stack.push(p);
				p = p->lchild;
			} else {
				p = m_stack.top();
				m_stack.pop();
				cout << p->data << " ";
				r = p;
				p = NULL;
			}
		}
	}
}

void horizontal_traverse(BiTree T) {
	deque<BiTNode *> m_deque;
	m_deque.push_back(T);
	while(!m_deque.empty()) {
		BiTNode *temp = m_deque.front();
		m_deque.pop_front();
		cout << temp->data << " ";
		if(temp->lchild)
			m_deque.push_back(temp->lchild);
		if(temp->rchild)
			m_deque.push_back(temp->rchild);
	}
}
void main() {
	BiTree T = NULL;
	create_tree(&T);

	//先根遍历
	cout << "pre_order_traverse_recursive:";
	pre_order_traverse_recursive(T);
	cout << endl;

	cout << "pre_order_traverse_iterative:";
	pre_order_traverse_iterative(T);
	cout << endl;

	//中根遍历
	cout << "in_order_traverse_recursive:";
	in_order_traverse_recursive(T);
	cout << endl;

	cout << "in_order_traverse_iterative:";
	in_order_traverse_iterative(T);
	cout << endl;

	//后根遍历
	cout << "post_order_traverse_iterative:";
	post_order_traverse_recursive(T);
	cout << endl;

	cout << "post_order_traverse_iterative:";
	post_order_traverse_iterative(T);
	cout << endl;
	// 水平遍历
	cout <<  "horizontal traverse:";
	horizontal_traverse(T);
	cout << endl;
	
}