二叉树的非递归中序遍历以及层序遍历实现

代码”Types.h“：

/*Types.h*/
#ifndef _TYPES_H
#define _TYPES_H

typedef char ElemType;
typedef struct BTNode
{
	ElemType data;
	BTNode * lChild;
	BTNode * rChild;
}BTNode,*BTree;


typedef BTree Item;

typedef struct STNode
{
	Item data;
	STNode *link;	
}STNode,*LinkStack;


typedef struct QNode *pQNode;
typedef struct QNode
{
	Item data;
	QNode *link;	
}QNode;

typedef struct Queue
{
	pQNode front;
	pQNode rear;
}Queue,*LinkQueue;

void CopyElem(ElemType *dest,ElemType *src);
void CopyItem(Item *dest,Item *src);

#endif

代码”Types.cpp“：

/*Types.cpp*/
#include "Types.h"

void CopyElem(ElemType *dest,ElemType *src)
{

	*dest = *src;
}

void CopyItem(Item *dest,Item *src)
{
	*dest = *src;
}

/*LinkStack.h*/：

/*LinkStack.h*/
#ifndef __LINK_STACK__H
#define __LINK_STACK__H
 

#include "Types.h"


void Copy(Item *dest,Item *src);

void InitStack(LinkStack *T);
void Push(LinkStack *T,Item item);
void Pop(LinkStack *T,Item *item);
Item Top(LinkStack T);
bool Isempty(LinkStack T);
void Destroy(LinkStack *T);
void PrintStack(LinkStack T);

#endif

/*LinkStack.cpp*/：

/*LinkStack.cpp*/
#include "LinkStack.h" 
#include <iostream>

using namespace std;
void Copy(Item *dest,Item *src)
{
	CopyItem(dest,src);	
}

void InitStack(LinkStack *T)
{
	*T = NULL;
} 
bool Isempty(LinkStack T)
{
	return (T == NULL);	
}
void Push(LinkStack *T,Item item)
{
	
	STNode *p = new STNode;
	Copy(&(p->data),&item);
	p->link = NULL;//cannot be missed
	if(Isempty(*T))
	{		
		*T = p;
	}
	else{
		p->link = *T;
		*T = p;
	}
		
} 
void Pop(LinkStack *T,Item *item)
{
	if(Isempty(*T))
	{
		/*Item v = NULL;
		Copy(item,&v);*/
		Item v = NULL;
		Copy(item,&v);
		return;
	}
	STNode *tmp = (*T);
	Copy(item,&(tmp->data));
	*T = (*T)->link;
	delete tmp;
} 
Item Top(LinkStack T)
{
	if(!Isempty(T))
		return T->data;
} 

void Destroy(LinkStack *T)
{
	if(!Isempty(*T))
	{
		STNode *tmp = *T;
		*T = (*T)->link;
		delete tmp;
	}
}

void PrintStack(LinkStack T)
{
	STNode *tmp = T;
	while(tmp)
	{
		cout<<"node : "<<tmp->data<<endl;
		tmp = tmp->link; 
	}
}

/*LinkQueue.h*/：

/*LinkQueue.h*/
#ifndef _LINKQUEUE_H
#define _LINKQUEUE_H

#include "Types.h"

void CopyQueueItem(Item *dest,Item *src); 
void InitQueue(LinkQueue* Q);
void Enqueue(LinkQueue Q,Item item);
void Dequeue(LinkQueue Q,Item *item);
Item Front(LinkQueue Q);
bool Isempty(LinkQueue Q);
void Clear(LinkQueue *Q);
void PrintQueue(LinkQueue Q);



#endif

/*LinkQueue.cpp*/：

/*LinkQueue.cpp*/
#include "LinkQueue.h"
#include <iostream>

using namespace std;

void CopyQueueItem(Item *dest,Item *src)
{
	CopyItem(dest,src);
}
void InitQueue(LinkQueue* Q)
{
	*Q = new Queue;
	(*Q)->front = NULL;
	(*Q)->rear = NULL;
}
void Enqueue(LinkQueue Q,Item item)
{
	pQNode p = new QNode;
	CopyQueueItem(&(p->data),&item);
	p->link = NULL;
	if(Q->rear == NULL)
	{
		Q->front = Q->rear = p;
	}
	else
	{
		Q->rear->link = p;
		Q->rear = p;
	}
}
void Dequeue(LinkQueue Q,Item *item)
{
	if(!Isempty(Q))
	{
		pQNode p = Q->front;
		CopyQueueItem(item,&(p->data));
		if (Q->front == Q->rear)
			Q->front = Q->rear = NULL;
		else
			Q->front = Q->front->link;
		delete p;
	}
	else
		*item = NULL;

}
Item Front(LinkQueue Q)
{
	return Q->front->data;
}
bool Isempty(LinkQueue Q)
{
	return Q == NULL || Q->rear == NULL;
}
void Clear(LinkQueue *Q)
{
	pQNode  p = (*Q)->front;
	pQNode tmp; 
	while(p)
	{
		tmp = p->link;
		delete p;
		p = tmp;
	}
	delete (*Q);
	(*Q) = NULL;
}
void PrintQueue(LinkQueue Q)
{
	pQNode p = Q->front;
	cout<<"Queue currently Start:"<<endl;
	while(p)
	{
		cout<<"Qnode : "<<p->data<<endl;
		p = p->link;
	}
	cout<<"Queue End."<<endl;
}

/*BinTree.h*/：

/*BinTree.h*/
#ifndef _BINTREE_H
#define _BINTREE_H

#include "Types.h" 
#include "BinTree.h"
#include "LinkStack.h"
#include "LinkQueue.h"



void InitBTree(BTree *T);
void CreateBTree(BTree *T);
void DestroyBTree(BTree *T);
void PreOrderTraverse(BTree T);
void InOrderTraverse(BTree T);
void PostOrderTraverse(BTree T);


void InOrder2(BTree T);
void LevelOrder(BTree T);

#endif

/*BinTree.cpp*/：

/*BinTree.cpp*/
#include "BinTree.h"
#include <iostream>

using namespace std;

void InitBTree(BTree *T)
{
	*T = NULL;
}

void CreateBTree(BTree *T)
{
	ElemType item;
	cin>>item;
	if(item=='#')
	{
		*T = NULL;
	}
	else {
		*T = new BTNode;
		CopyElem(&((*T)->data),&item);
		CreateBTree(&((*T)->lChild));
		CreateBTree(&((*T)->rChild));
	}
}
void DestroyBTree(BTree *T)
{
	if(*T)
	{
		DestroyBTree(&((*T)->lChild));
		DestroyBTree(&((*T)->rChild));
		delete (*T);
		*T = NULL;
	}	
} 
void PreOrderTraverse(BTree T)
{
	if(T)
	{
		cout<<"node : "<<T->data<<endl;
		PreOrderTraverse(T->lChild);
		PreOrderTraverse(T->rChild);
	}
} 
void InOrderTraverse(BTree T)
{
	if(T)
	{
		InOrderTraverse(T->lChild);
		cout<<"node : "<<T->data<<endl;
		InOrderTraverse(T->rChild);
	}
} 
void PostOrderTraverse(BTree T)
{
	if(T)
	{
		PostOrderTraverse(T->lChild);
		PostOrderTraverse(T->rChild);
		cout<<"node : "<<T->data<<endl;
	}
} 

void InOrder2(BTree T)
{
	LinkStack s;
	InitStack(&s);
	for(;;)
	{
		for(;T;T=T->lChild)
			Push(&s,T);
		Pop(&s,&T);
		if(!T)
			break;
		cout<<"Node : "<<T->data<<endl;
		T = T->rChild;
		
	}
	Destroy(&s);
	
}

void LevelOrder(BTree T)
{
	if(!T)
		return;
	LinkQueue Q ;
	InitQueue(&Q);
	Enqueue(Q,T);
	BTree ptr;
	for(;;)
	{
		Dequeue(Q,&ptr);
		if(ptr)
		{
			cout<<"Node : "<<ptr->data<<endl;
			if(ptr->lChild)
				Enqueue(Q,ptr->lChild);
			if(ptr->rChild)
				Enqueue(Q,ptr->rChild);
		}
		else
			break;
	}


}

测试主程序：

*/
#include <iostream>
#include "BinTree.h"
#include "LinkStack.h"
#include "LinkQueue.h"

using namespace std;

int main()
{ 
	BTree tree;
	InitBTree(&tree);
	CreateBTree(&tree);
	cout<<"Pre Order:"<<endl;
	PreOrderTraverse(tree);
	
	cout<<"In Order:"<<endl;
	InOrderTraverse(tree);
	
	cout<<"Post Order:"<<endl;
	PostOrderTraverse(tree);
	
	cout<<"In Order 2(using stack):"<<endl;
	InOrder2(tree);
	
	cout<<"Pre Order:"<<endl;
	PreOrderTraverse(tree);

	cout<<"Level Order:"<<endl;
	LevelOrder(tree);

	DestroyBTree(&tree);

}

输入：

ABD##E##CF###

输出：

Pre Order:
node : A
node : B
node : D
node : E
node : C
node : F
In Order:
node : D
node : B
node : E
node : A
node : F
node : C
Post Order:
node : D
node : E
node : B
node : F
node : C
node : A
In Order 2(using stack):
Node : D
Node : B
Node : E
Node : A
Node : F
Node : C
Pre Order:
node : A
node : B
node : D
node : E
node : C
node : F
Level Order:
Node : A
Node : B
Node : C
Node : D
Node : E
Node : F