树3——二叉树的先序遍历

二叉树的先序非递归遍历
二叉树

这是同济大学的考研试题。算法实现：从二叉树的根结点开始，访问根结点，然后将根结点的指针入栈，重复执行以下步骤：
①如果该结点的左孩子结点存在，访问左孩子结点，则将左孩子结点指针入栈。重复执行操作直到结点的左孩子不存在；
②将栈顶的元素（指针）出栈，如果该指针指向的右孩子结点存在，则将当前指针指向右孩子结点。重复执行以上两个步骤，直到栈空为止。

如图所示的先序遍历序列为：A、B、C、D、E、F、G、H、I。
 

code

#include 
#include 
#include 
#include 
#include 
using namespace std;
typedef char DataType;
#define MAXSIZE 100

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

void CreateBitTree(BiTree *T, char str[]);
void TreePrint(BiTree T, int nLayer);
void PreOrderTraverse(BiTree T);
void DestroyBitTree(BiTree *T);

void main()
{
	BiTree root;
	cout << "根据广义表输入形式(A(B(C,D),E(F(,G),H(I))))建立二叉树:" << endl;
	CreateBitTree(&root, "(A(B(C,D),E(F(,G),H(I))))");
	cout << "树状显示二叉树：" << endl;
	TreePrint(root, 0);
	cout << "先序遍历二叉树：" << endl;
	PreOrderTraverse(root);
	cout << endl;
	DestroyBitTree(&root);
	system("pause");
}
void PreOrderTraverse(BiTree T)
{
	BiTree stack[MAXSIZE];
	int top;
	BitNode *p;
	top = 0;
	p = T;
	while (p != NULL || top > 0)
	{
		while (p!=NULL)
		{
			cout << setw(3) << p->data;
			stack[top++] = p;
			p = p->lchild;


		}
		if (top>0)
		{
			p = stack[--top];
			p = p->rchild;

		}
	}
}
void TreePrint(BiTree T, int nLayer)
{
	int i;
	if (T==NULL)
	{
		return;
	}
	TreePrint(T->rchild, nLayer + 1);
	for (i = 0; i < nLayer;i++)
	{
		printf("   ");
		
	}
	printf("%c\n", T->data);
	TreePrint(T->lchild, nLayer + 1);
}
void CreateBitTree(BiTree *T, char str[])
{
	char ch;
	BiTree stack[MAXSIZE];
	int top = -1;
	int flag, k;
	BitNode *p;
	*T = NULL, k = 0;
	ch = str[k];
	while (ch!='\0')
	{
		switch (ch)
		{
		case '(':
			stack[++top] = p;
			flag = 1;
			break;
		case ')':
			top--;
			break;
		case ',':
			flag = 2;
			break;
		default:
			p = (BiTree)malloc(sizeof(BitNode));
			p->data = ch;
			p->lchild = NULL;
			p->rchild = NULL;
			if (*T==NULL)
			{
				*T = p;
			} 
			else
			{
				switch (flag)
				{
				case 1:
					stack[top]->lchild = p;
					break;
				case 2:
					stack[top]->rchild = p;
					break;
				}
			}
		}

		ch = str[++k];
	}
}
void DestroyBitTree(BiTree *T)
{
	if (*T)
	{
		if ((*T)->lchild)
		{
			DestroyBitTree(&((*T)->lchild));

		}
		if ((*T)->rchild)
		{
			DestroyBitTree(&((*T)->rchild));
		}

		free(*T);
		*T = NULL;
	}
}

结果：