二叉树的遍历

二叉树的先序遍历，是先输出二叉树的根节点，再输出二叉树的左子树和右子树。当输出左右子树的时候，也是像上述一样处理，先输出根节点，再输出左右子树。

二叉树的中序遍历，是先输出二叉树的左子树，再输出二叉树的根节点和右子树。当输出左右子树的时候，也是像上述一样处理，先输出左子树，再输出根节点和右子树。

二叉树的后序遍历，是先输出二叉树的左子树，再输出二叉树的右子树和根节点。当输出左右子树的时候，也是像上述一样处理，先输出左子树，再输出右子树和根节点。

上图二叉树的

先序遍历：A B D C E F
中序遍历: B D A E C F
后序遍历: D B E F C A

二叉树的数据结构

template<class T>
struct Node
{
	T data;
	Node * left;
	Node *right;
};

初始化二叉树：

void Create(Node<T>* & t){//指针的引用
	char c;
	cin>>c;
	if(c=='#')
		t=NULL;
	else{
		t=new Node<T>;
		t->data=c;
		Create(t->left);
		Create(t->right);
	}
}

输入先序遍历序列A B # D # # C E # # F # #可以建立如上图的二叉树。#号代表空树。

二叉树的三种遍历：

void PreOrderTraverse(Node<T> * pRoot)
{
	if(pRoot == NULL)
		return;
	Visit(pRoot); // 访问根节点
	PreOrderTraverse(pRoot->left); // 前序遍历左子树
	PreOrderTraverse(pRoot->right); // 前序遍历右子树
}
template<class T>
void InOrderTraverse(Node<T> * pRoot)  
{  
	if(pRoot == NULL)  
		return;  
	InOrderTraverse(pRoot->left); // 中序遍历左子树  
	Visit(pRoot); // 访问根节点  
	InOrderTraverse(pRoot->right); // 中序遍历右子树  
} 
template<class T>
void PostOrderTraverse(Node<T> * pRoot)  
{  
	if(pRoot == NULL)  
		return;  
	PostOrderTraverse(pRoot->left); // 后序遍历左子树  
	PostOrderTraverse(pRoot->right); // 后序遍历右子树  
	Visit(pRoot); // 访问根节点  
}

二叉树的结点数，显而易见就是二叉树中的元素个数。

二叉树中结点根据其左右子树是不是空树，可分为三种情况

1、左右子树都为空，则该节点被称为叶子结点。

2、左右子树有一个为空，另外一个不为空，称为单结点

3、左右子树都不为空，称为双结点。

叶子结点个数：

int GetLeafNodeNum(Node<T> * pRoot)  //树的叶子结点数
{  
	if(pRoot == NULL) //递归出口 
		return 0;  
	else if(pRoot->left == NULL && pRoot->right == NULL)//左右子结点都为NULL
		return 1; 
	else
		return (GetLeafNodeNum(pRoot->left)+GetLeafNodeNum(pRoot->right));  
} 

单结点个数：

template <class T>
int GetSigleNodeNum(Node<T> * pRoot)  
{  
	if(pRoot == NULL)  
		return 0;  
	if(pRoot->left!= NULL&&pRoot->right== NULL)
		return 1+GetSigleNodeNum(pRoot->left);
	else if(pRoot->left== NULL&&pRoot->right!= NULL)  
		return 1+GetSigleNodeNum(pRoot->right); 
	else
		return GetSigleNodeNum(pRoot->left)+GetSigleNodeNum(pRoot->right);
}

双结点个数：

<pre name="code" class="html">template <class T>
int GetDoubleNodeNum(Node<T> * pRoot)  
{  
	if(pRoot == NULL)  
		return 0; 
	if(pRoot->left!=NULL&&pRoot->right!=NULL)//递归的次数多
		return GetDoubleNodeNum(pRoot->left)+GetDoubleNodeNum(pRoot->right)+1;
	else
		return GetDoubleNodeNum(pRoot->left)+GetDoubleNodeNum(pRoot->right);
}

测试程序：

int main()
{
	Node<char> *tree;
	Create(tree);

	cout<<"PreOrder:";
	PreOrderTraverse(tree);
	cout<<endl;

	cout<<"InOrder:";
	InOrderTraverse(tree);
	cout<<endl;

	cout<<"PostOrder:";
	PostOrderTraverse(tree);
	cout<<endl;

	cout<<"Depth："<<GetDepth(tree)<<endl;
	cout<<"NodeNum:  "<<GetNodeNum(tree)<<endl;
	cout<<"LeafNodeNum:  "<<GetLeafNodeNum(tree)<<endl;
	cout<<"SigleNodeNum:  "<<GetSigleNodeNum(tree)<<endl;
	cout<<"DoubleNodeNUm:  "<<GetDoubleNodeNum(tree)<<endl;

	return 0;
}

测试用例1：

A B # D # # C E # # F # #

结果1：

测试用例2：

#

测试结果2：