二叉树操作

对二叉树操作，必须现有个树，先递归创建二叉树 代码如下：

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

void CreateBiTree(BiTNode** root)
{
	char ch;
	cin>> ch;
	if('#'==ch)
		(*root)=NULL;
	else
	{
		(*root)=(BiTree)malloc(sizeof(BiTNode));
		(*root)->data=ch;
		cout << "input   " << ch << "   leftChild" <<endl;
		CreateBiTree(&((*root)->lchild));
		cout << "input   " << ch << "   rightChild" <<endl;
		CreateBiTree(&((*root)->rchild));
	}
}

之所以用指针的指针指针传递无法改变其值，或者用指针的指针或者用指针的引用。

1，非递归前序遍历  2 非递归中序遍历 3，非递归后序遍历 4，非递归层次遍历

非递归前序遍历的思想是①curr不为空，②curr为空。借用了一个栈，指针curr指向将要入栈的结点，每次入栈前打印出data，然后入栈（待时用），然后继续搜索左子树入栈，一直到空。

当curr为空时候，这时候结点出栈（不打印了，而是使用该节点找到其右子树）。找到后curr指向该树。重复①。代码：

void PreOrder(BiTNode* T)
{
	BiTree curr=T;
	stack<BiTree> s;

	while (curr||!s.empty())
	{
		while (curr)
		{
			cout << curr->data <<" ";
			s.push(curr);
			curr=curr->lchild;
		}
		{
			curr=s.top();
			s.pop();
			curr=curr->rchild;
		}
	}
}

中序遍历的思想与先序遍历类似，只是输出的代码有区别，代码如下：

void InOrder(BiTNode* T)
{
	BiTree curr=T;
	stack<BiTree> s;

	while(curr||!s.empty())
	{
		while(curr)
		{	s.push(curr);
			curr=curr->lchild;
		}
		
		{
			curr=s.top();
			s.pop();
			cout << curr->data << " ";
			curr=curr->rchild;
		}
	}
}

3，后序比起前两个有点难度。

void PostOrder(BiTNode* T)
	{
		BiTree curr=T;
		stack<BiTree> s;

		BiTree previous;
		while (curr||!s.empty())
		{
			while(curr)
			{
				s.push(curr);
				curr=curr->lchild;
			}
			curr=s.top();
			if (curr->rchild==NULL||curr->rchild==previous)
			{
				cout << curr->data << " ";//当判断栈内的该节点是输出节点的时候，才能删除。如果不是呆在栈里，节点右节点入栈，待审
				previous=curr;
				s.pop();
				curr=NULL;
			}else
			{curr=curr->rchild;}
		}
	}

</pre><pre>

访问顺序是 左->右->根。在访问跟的时候要做判断，根节点的右子树或者是空，或者是刚输出的那个。这时候才能访问根节点。

4，层次访问，这个很简单接住了队列  

void LevelOrder(BiTNode* T)
{
	queue<BiTree> q;
	BiTree curr=T;

	q.push(curr);
	while(!q.empty())
	{
		curr=q.front();//每次指针指向队首
		cout << curr->data <<" ";// 输出队首元素
		q.pop();//删除队首元素
		if (curr->lchild)
		{
			q.push(curr->lchild);//指针所指元素左子树不为空，入队
		}
		if (curr->rchild)
		{
			q.push(curr->rchild);//指针所指元素右子树不为空，入队
		}
	}

}

所有代码如下：

#include <iostream>
#include <stack>
#include <queue>
using namespace std;

//定义二叉树的结构体类型
typedef struct BiTNode
{
	char data;
	struct BiTNode* lchild,*rchild;
}BiTNode,*BiTree;

void CreateBiTree(BiTNode** root)
{
	char ch;
	cin>> ch;
	if('#'==ch)
		(*root)=NULL;
	else
	{
		(*root)=(BiTree)malloc(sizeof(BiTNode));
		(*root)->data=ch;
		cout << "input   " << ch << "   leftChild" <<endl;
		CreateBiTree(&((*root)->lchild));
		cout << "input   " << ch << "   rightChild" <<endl;
		CreateBiTree(&((*root)->rchild));
	}
}
//NoRecursion preorder  Traversal
void PreOrder(BiTNode* T)
{
	BiTree curr=T;
	stack<BiTree> s; 

	while (curr||!s.empty())
	{
		while (curr)
		{
			cout << curr->data <<" ";
			s.push(curr);
			curr=curr->lchild;
		}
		{
			curr=s.top();
			s.pop();
			curr=curr->rchild;
		}
	}
	cout<< endl;
}

//no recursion inorder traversal

void InOrder(BiTNode* T)
{
	BiTree curr=T;
	stack<BiTree> s;

	while(curr||!s.empty())
	{
		while(curr)
		{
			s.push(curr);
			curr=curr->lchild;
		}
		{
			curr=s.top();
			s.pop();
			cout << curr->data << " ";
			curr=curr->rchild;
		}
	}
	cout<< endl;
}

//postorder no recursion traversal
void PostOrder(BiTNode* T)
{
	BiTree curr=T;
	stack<BiTree> s;

	BiTree previous;
	while (curr||!s.empty())
	{
		while(curr)
		{
			s.push(curr);
			curr=curr->lchild;
		}
		curr=s.top();
		if (curr->rchild==NULL||curr->rchild==previous)
		{
			cout << curr->data << " ";
			s.pop();
			previous=curr;curr=NULL;
		}
		else
		{
			curr=curr->rchild;
		}
	}
	cout<< endl;
}
//level traversal
void LevelOrder(BiTNode* T)
{
	BiTree curr=T; 
	queue<BiTree> q;
	q.push(curr);
	while(!q.empty())
	{
		curr=q.front();//每次指针指向队首
		cout << q.front()->data <<" ";// 输出队首元素
		q.pop();//删除队首元素
		if (curr->lchild)
		{
			q.push(curr->lchild);//指针所指元素左子树不为空，入队
		}
		if (curr->rchild)
		{
			q.push(curr->rchild);//指针所指元素右子树不为空，入队
		}
	}
	cout<< endl;
}
int main()
{
	BiTNode* root;
	CreateBiTree(&root);
	cout << "preorder traversal " <<endl;
//	PreOrder(root);cout << "inorder traversal" <<endl;
//	InOrder(root);cout << "postorder traversal" <<endl;
	//PostOrder(root);cout << "level traversal" <<endl;
	LevelOrder(root);
	return 0;
}

</pre><pre>

求树的深度：

int depth(BiTNode *T)   //树的深度    
{ 
	if (!T)
		return 0;
	int a,b;
	a=depth(T->lchild);
	b=depth(T->rchild);
	return (a>b?a:b) +1;
}

求树的节点数

int countNode(BiTNode* T)
{
	if (!T)
	return 0;
	int a,b;
	a=countNode(T->lchild);
	b=countNode(T->rchild);
	return a+b+1;
	//return countNode(T->lchild)+countNode(T->rchild)+1;
}