1. 遞迴前序遍歷

二叉樹的建立就是遞迴的思想，每個結點都可以看作一個樹。前序遍歷是根->左->右的順序，先列印根結點，分別將根的左右結點遞迴列印

#include <stdio.h>
#include<stdlib.h>
typedef struct node
{

	int value;
	struct node *pLeft;
	struct node *pRight;

}BinaryTree;

void RPreTraversal(BinaryTree * br)
{
	if(br==NULL)
		return;
	printf("%d\n",br->value);
	RPreTraversal(br->pLeft);
	RPreTraversal(br->pRight);

}
 

2.非遞迴前序遍歷

藉助輔助棧來進行非遞迴的前序遍歷

• 結點非空，列印，入棧向左遍歷（迴圈）
• 彈出棧頂元素
• 判斷元素的的右結點，進入迴圈，執行第一步

//輔助棧
#include<stdio.h>
#include <stdlib.h>
#include<stdbool.h>
typedef struct node
{

	int value;
	struct node *pLeft;
	struct node *pRight;

}BinaryTree;
typedef struct Node
{
	BinaryTree* nValue;
	struct Node *pNext;
}Mystack;
typedef struct StackNode
{
	Mystack *pTop;
	int length;//棧元素長度
	bool flag;//棧標誌
}StackInt;
void Myinit(StackInt**s)
{
	*s=(StackInt*)malloc(sizeof(StackInt));
	if(*s == NULL)
	{
		printf("create stack failed");
		return;
	}
	(*s)->pTop = NULL;
	(*s)->length =0;
	(*s)->flag =true;

}
void listpush(StackInt *s,BinaryTree *n)
{
	if(s->flag==false)
		return;
	Mystack*pTemp = NULL;
	pTemp = (Mystack*)malloc(sizeof(Mystack));
	pTemp->nValue =n;
	pTemp->pNext = s->pTop;
	s->pTop = pTemp;
	s->length++;

}
BinaryTree* listpop(StackInt *s)
{
	if(s->flag == false)
		return NULL;
	if(s->pTop == NULL)
		return NULL;
	else
	{
		BinaryTree* n;
		Mystack*pTemp =NULL;
		pTemp =s->pTop;
		n=(s->pTop)-> nValue;
		s->pTop=(s->pTop)->pNext;
		s->length--;
		free(pTemp);
		pTemp = NULL;
		return n;
	}
}
void ClearStack(StackInt *s)
{
	if(s->flag == false)
		return;
	while(s->pTop!=NULL)
	{
		listpop(s);

	}


}
void DestoryStack(StackInt **s)
{
	ClearStack(*s);
	(*s)->flag=false;
	free(*s);
	(*s) =NULL;
	printf("stack destorystack!");

}
BinaryTree* GetTop(StackInt *s)
{
	BinaryTree* n;
	if(s->pTop == NULL)
	{
		printf("Top is null");
		return NULL;

	}
	n=(s->pTop)->nValue;
	return n;
}
int Getcount(StackInt *s)
{

	if(s == NULL ||s->pTop == NULL)
	{
		printf("stack is null");
		return -1;

	}
	return (s->length);
}
int isEmpty(StackInt *s)
{
	if(s== NULL||s->pTop == NULL)
		return 1;
	else
	{
		return 0;
	}

}
 

void URPreTraversal(BinaryTree *tree)
{
	if(tree ==NULL)
		return;
	//申請棧
	StackInt *s = NULL;
	Myinit(&s);
	//節點非空，列印，入棧，
	while(1)
	{
		while (tree!=NULL)
		{
			printf("%d ",tree->value);
			listpush(s,tree);
			tree=tree->pLeft;
		}
		//彈出
		tree =listpop(s);
		//判斷是否為空，當棧內元素為空時，結束迴圈
		if(tree == NULL)
			break;
		//向右遍歷
		tree = tree->pRight;

	}


}
 

3.遞迴中序遍歷

中序遍歷的順序是左->根->右

void RInorderTraversal(BinaryTree *br)
{
	if(br == NULL)
		return;
	RInorderTraversal(br->pLeft);
	printf("%d\n",br->value);
	RInorderTraversal(br->pRight);
}

4.非遞迴中序遍歷

void URInorderTraversal(BinaryTree *tree)
{
	if(tree ==NULL)
		return;
	StackInt *s = NULL;
	Myinit(&s);
	while(1)
	{
		while(tree !=NULL)
		{
			listpush(s,tree);
			tree =tree->pLeft;

		}
		tree =listpop(s);
		if(tree== NULL)
			break;
		printf("%d ",tree->value);
		tree=tree->pRight;
	}
}

5.遞迴後序遍歷

後序遍歷的順序是左->右->根

void RPostTraversal(BinaryTree *br)
{
	if(br == NULL)
		return;
	RPostTraversal(br->pLeft);
	RPostTraversal(br->pRight);
	printf("%d\n",br->value);
}

6.非遞迴後序遍歷

‘非遞迴後序遍歷不能直接彈出根節點，因為要通過根節點去找他的右結點，當根結點的右結點為空或者右結點為棧內剛剛上一次彈出的結點，就可以彈出根節點。

void URPostTraversal(BinaryTree *tree)
{
	if(tree==NULL)
		return;
	StackInt *s =NULL;
	Myinit(&s);
	BinaryTree *p = NULL;
	while(1)
	{
		while(tree !=NULL)
		{
			listpush(s,tree);
			tree=tree->pLeft;

		}
		if(s->pTop ==NULL)
			break;
		if(s->pTop->nValue->pRight==NULL||s->pTop->nValue->pRight==p)
		{
			p=listpop(s);
			printf("%d ",p->value);

		}
		else
			tree =s->pTop->nValue->pRight;
	}
}