二叉树遍历堆栈方式实现

前序遍历：根->左->右

中序遍历：左->根->右

后序遍历：左->右->根

//二叉树遍历堆栈方式实现
//2018.11.15 青春如诗
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define MaxSize 10
typedef struct TreeNode *BinTree;
typedef BinTree Position;
typedef char ElementType_;
typedef BinTree ElementType;
struct TreeNode
{
	ElementType_ Data;
	BinTree Left;
	BinTree Right;
};
typedef struct SNode *Stack;
struct SNode
{
	ElementType Data[MaxSize];
	int Top;
};
void Push(Stack PtrS, ElementType item)
{
	if (PtrS->Top == MaxSize - 1)
	{
		printf("堆栈满"); return;
	}
	else
	{
		PtrS->Data[++PtrS->Top] = item;
		return;
	}
}
ElementType Pop(Stack PtrS)
{
	if (PtrS->Top == -1)
	{
		printf("堆栈空\n"); return NULL;
	}
	else
	{
		return PtrS->Data[PtrS->Top--];
	}
}
bool IsEmpty(Stack S)
{
	return S->Top == -1;
}

ElementType Top(Stack PtrS)
{
	if (PtrS->Top == -1)
	{
		printf("堆栈空\n"); return NULL;
	}
	else
	{
		return PtrS->Data[PtrS->Top];
	}
}
//判断二叉树是否为空
bool IsEmpty(BinTree BT)
{
	return BT == NULL;
}
//创建节点
BinTree CreateTreeNode(char ch)
{
	BinTree BT = (BinTree)malloc(sizeof(struct TreeNode));
	BT->Data = ch;
	BT->Left = NULL;
	BT->Right = NULL;
	return BT;
}
//创建二叉树
BinTree CreateBinTree()
{
	BinTree BT = CreateTreeNode('A');

	BT->Left = CreateTreeNode('B');

	BT->Right = CreateTreeNode('C');

	BT->Left->Left = CreateTreeNode('D');
	BT->Left->Right = CreateTreeNode('F');
	BT->Right->Left = CreateTreeNode('G');
	BT->Right->Right = CreateTreeNode('I');
	BT->Left->Right->Left = CreateTreeNode('E');
	BT->Right->Left->Right = CreateTreeNode('H');
	return BT;
}
void DeleteTree(BinTree BT)
{
	if (BT)
	{
		DeleteTree(BT->Left);
		DeleteTree(BT->Right);
		BT = NULL;
		free(BT);
	}
}

void DeleteTree(BinTree *BT)
{
	if (*BT)
	{
		DeleteTree(&((*BT)->Left));
		DeleteTree(&((*BT)->Right));
		*BT = NULL;
		free(*BT);
	}
}

//先序遍历
void PreOrderTraversal(BinTree BT)
{
	BinTree T = BT;
	Stack S = (Stack)malloc(sizeof(SNode));
	S->Top = -1;
	while (T || !IsEmpty(S))
	{
		while (T)	//一直向左，并将沿途节点压入堆栈
		{
			Push(S, T);
			printf("%C", T->Data);
			T = T->Left;
		}
		if (!IsEmpty(S))
		{
			T = Pop(S);
			T = T->Right;
		}
	}
	free(S);
}
//中序遍历

void InOrderTraversal(BinTree BT)
{
	BinTree T = BT;
	Stack S = (Stack)malloc(sizeof(SNode));
	S->Top = -1;
	while (T || !IsEmpty(S))
	{
		while (T)	//一直向左，并将沿途节点压入堆栈
		{
			Push(S, T);
			T = T->Left;
		}
		if (!IsEmpty(S))
		{

			T = Pop(S);
			printf("%C", T->Data);
			T = T->Right; 
		}
	}
	free(S);
}
//后序遍历

void PostOrderTraversal(BinTree BT)
{
	BinTree T = BT;
	Stack S = (Stack)malloc(sizeof(SNode));

	Stack OutPut = (Stack)malloc(sizeof(SNode));
	S->Top = -1;
	OutPut->Top = -1;
	while (T || !IsEmpty(S))
	{
		while (T)	//一直向左，并将沿途节点压入堆栈
		{
			Push(S, T);
			Push(OutPut, T);
			T = T->Right;
		}
		if (!IsEmpty(S))
		{
			T = Pop(S);
			T = T->Left;
		}
	}
	while (OutPut->Top != -1)
	{
		printf("%c", Pop(OutPut)->Data);
	}
	free(S);
	free(OutPut);
}

int main()
{
	BinTree BT = CreateBinTree();
	printf("先序遍历：\n");
	PreOrderTraversal(BT);
	printf("\n后序遍历:\n");
	InOrderTraversal(BT);
	printf("\n后序遍历:\n");
	PostOrderTraversal(BT);
	DeleteTree(&BT);
	return 0;
}