程式碼包含如下幾個檔案：

下面一一貼出來：

Stack.h檔案：

#ifndef STACK_H_
#define STACK_H_

#include "BinaryTree.h"
#include <stdbool.h>
#define STACK_INIT_SZIE 20
#define STACK_INCREMENT_SIZE 10

typedef struct {
	int size;/** 棧的容量 */
	BiTreeNode** base;/** 棧底指標，注意這裡是指向二叉樹節點指標的指標 */
	BiTreeNode** top;/** 棧頂指標 */
}Stack;

Stack *InitStack();/** 初始化棧 */
void Push(Stack *stack, BiTreeNode* node);/** 入棧 */
BiTreeNode* GetTop(Stack *stack);/** 獲取棧頂資料 */
BiTreeNode* Pop(Stack *stack);/** 棧頂元素出棧 */
bool isStackEmpty(Stack* stack);/** 判斷棧是否為空 */

#endif 
 

Stack.c檔案：

#include<stdio.h>
#include <stdlib.h>
#include "Stack.h"
#include "BinaryTree.h"

/** 初始化棧 */
Stack *InitStack()
{
	Stack *stack = (Stack*)malloc(sizeof(Stack));
	//下面這句遇到坑了，stack->base應該申請sizeof(BiTreeNode) * STACK_INIT_SZIE的空間，開始忘了*STACK_INIT_SZIE，導致一直出錯
	stack->base = (BiTreeNode**)malloc(sizeof(BiTreeNode) * STACK_INIT_SZIE);
	stack->top = stack->base;
	stack->size = STACK_INIT_SZIE;
	return stack;
}

/** 入棧 */
void Push(Stack *stack, BiTreeNode* node)
{
	if (stack->top - stack->base >= stack->size)//棧滿，重新分配更大的空間
	{
		stack->base = (BiTreeNode**)realloc(stack->base, sizeof(BiTreeNode) * (stack->size + STACK_INCREMENT_SIZE));
		if (!stack->base)//分配空間失敗
		{
			printf("stack increment size error!\n");
			exit(0);
		}
		stack->top = stack->base + stack->size;//修改棧頂指標
		stack->size += STACK_INCREMENT_SIZE;//修改新的棧容量大小
		//printf("stack increment size 10, now stack size is %d\n", stack->size);
	}
	if(node)
		*(stack->top) = node;
	else//入棧的是空節點，則用值為#的節點代替空節點
	{
		BiTreeNode* emptyNode = (BiTreeNode*)malloc(sizeof(BiTreeNode));
		emptyNode->val = '#';
		emptyNode->left = NULL;
		emptyNode->right = NULL;
		*(stack->top) = emptyNode;
	}
	(stack->top)++;
	//printf("push node %c to stack, now stack has %d elements, stack size is %d\n", node->val, stack->top - stack->base, stack->size);
}

/** 獲取棧頂元素 */
BiTreeNode* GetTop(Stack *stack)
{
	if (stack->base == stack->top)//棧空
		return NULL;
	//printf("get stack top: %c\n", (stack->top - 1)->val);
	return *(stack->top - 1);
}

/** 出棧 */
BiTreeNode* Pop(Stack *stack)
{
	if (stack->base == stack->top)//棧空
		return NULL;
	--(stack->top);
	//printf("stack pop: %c\n", stack->top->val);
	return *stack->top;
}

/** 判斷棧是否為空 */
bool isStackEmpty(Stack* stack)
{
	if(stack) 
		return stack->base == stack->top;
	return true;
}
 

#ifndef BINARY_TREE_H_
#define BINARY_TREE_H_
#include <stdbool.h>

typedef struct Node{
	struct Node *left;/** 左孩子 */
	struct Node *right;/** 右孩子 */
	char val;/** 節點中的資料 */
	bool isPrintOut;/** 後序非遞迴遍歷時用到，為false表示該節點未輸出，為true表示該節點已輸出 */
}BiTreeNode;

BiTreeNode* CreateBinaryTree();/** 建立二叉樹，使用先序建立 */
void PreOrderBiTree(BiTreeNode*);/** 先序遍歷遞迴 */
void PreOrderBiTree1(BiTreeNode*);/** 先序遍歷非遞迴 */
void InOrderBiTree(BiTreeNode*);/** 中序遍歷遞迴 */
void InOrderBiTree2(BiTreeNode*);/** 中序遍歷非遞迴1 */
void InOrderBiTree3(BiTreeNode*);/** 中序遍歷非遞迴2 */
void PostOrderBiTree(BiTreeNode*);/** 後序遍歷遞迴 */
void PostOrderBiTree1(BiTreeNode*);/** 後序遍歷非遞迴 */
bool IsChildsAllPrintOut(BiTreeNode*);/** 判斷某個節點的孩子節點是否全部輸出 */

#endif
 

#include <stdio.h>
#include <stdlib.h>
#include "BinaryTree.h"
#include "Stack.h"

/** 先序建立二叉樹，使用遞迴的方式建立 */
BiTreeNode* CreateBinaryTree()
{
	char c;
	scanf("%c", &c);
	BiTreeNode* node;
	if (c == '#')
		node = NULL;
	else
	{
		node = (BiTreeNode*)malloc(sizeof(BiTreeNode));
		node->val = c;
		node->left = CreateBinaryTree();
		node->right = CreateBinaryTree();
		node->isPrintOut = false;
	}
	return node;
}

/** 先序遍歷，遞迴 */
void PreOrderBiTree(BiTreeNode* root)
{
	if (root)
	{
		printf("%c ", root->val);
		PreOrderBiTree(root->left);
		PreOrderBiTree(root->right);
	} 
}

/** 先序遍歷，非遞迴 */
void PreOrderBiTree1(BiTreeNode* root)
{
	BiTreeNode* p = root;
	Stack* stack = InitStack();
	while (p || !isStackEmpty(stack))
	{
		if (p)
		{
			printf("%c ", p->val);
			Push(stack, p);
			p = p->left;
		}
		else 
		{
			p = Pop(stack);
			p = p->right;
		}
	}
}

/** 中序遍歷，遞迴 */
void InOrderBiTree(BiTreeNode* root)
{
	if (root)
	{
		InOrderBiTree(root->left);
		printf("%c ", root->val);
		InOrderBiTree(root->right);
	}
}

/** 中序遍歷，非遞迴方法一 */
void InOrderBiTree2(BiTreeNode* root)
{
	Stack *stack = InitStack();
	Push(stack, root);
	BiTreeNode* p;
	while (!isStackEmpty(stack))
	{
		while ((p = GetTop(stack))->val != '#')
			Push(stack, p->left);
		Pop(stack);
		if (!isStackEmpty(stack))
		{
			BiTreeNode* node = Pop(stack);
			if (node)
			{
				printf("%c ", node->val);
				Push(stack, node->right);
			}
		}
	}
}

/** 中序遍歷，非遞迴方法二 */
void InOrderBiTree3(BiTreeNode* root)
{
	Stack* stack = InitStack();
	BiTreeNode* p = root;
	while (p || !isStackEmpty(stack))
	{
		if (p)
		{
			Push(stack, p);
			p = p->left;
		}
		else
		{
			p = Pop(stack);
			printf("%c ", p->val);
			//printf("中序非遞迴遍歷遇到節點%c，指標地址為%ld\n", p->val, p);
			p = p->right;
		}
	}
}

/** 後序遍歷，遞迴 */
void PostOrderBiTree(BiTreeNode* root)
{
	if (root)
	{
		PostOrderBiTree(root->left);
		PostOrderBiTree(root->right);
		printf("%c ", root->val);
	}
}

/** 後序遍歷，非遞迴 */
void PostOrderBiTree1(BiTreeNode* root)
{
	Stack* stack = InitStack();
	BiTreeNode* p = root;
	while (p || !isStackEmpty(stack))
	{
		if (p)
		{
			Push(stack, p);
			p = p->left;
		}
		else
		{
			p = GetTop(stack);
			if (IsChildsAllPrintOut(p))
			{
				printf("%c ", p->val);
				/** 輸出一個節點，就把該節點的isPrintOut設定為true */
				p->isPrintOut = true;
				p = Pop(stack);
				p = NULL;
			}
			else
				p = p->right;
		}
	}
}

/** 判斷一個節點的所有孩子節點是否都輸出了 */
bool IsChildsAllPrintOut(BiTreeNode* node)
{ 
	bool leftPrintOut = false;
	bool rightPrintOut = false;
	if (!node->left)//節點為空則認為該節點已輸出
		leftPrintOut = true;
	else
		leftPrintOut = node->left->isPrintOut;
	if (!node->right)
		rightPrintOut = true;
	else
		rightPrintOut = node->right->isPrintOut;
	return leftPrintOut && rightPrintOut;
}

#include<stdio.h>
#include <stdlib.h>
#include "Stack.h"

void printResult(char *msg, void(*p)(BiTreeNode*), BiTreeNode* node)
{
	printf("\n---------%s---------\n", msg);
	p(node);
	printf("\n---------%s---------\n", msg);
}

int main()
{
	printf("使用先序建立二叉樹，#表示空節點，請輸入二叉樹的資料：\n");
	BiTreeNode* root = CreateBinaryTree();

	printResult("先序遍歷遞迴演算法", PreOrderBiTree, root);
	printResult("先序遍歷非遞迴演算法", PreOrderBiTree1, root);
	printResult("中序遍歷遞迴演算法", InOrderBiTree, root);
	printResult("中序遍歷非遞迴演算法1", InOrderBiTree2, root);
	printResult("中序遍歷非遞迴演算法2", InOrderBiTree3, root);
	printResult("後序遍歷遞迴演算法", PostOrderBiTree, root);
	printResult("後序遍歷非遞迴演算法", PostOrderBiTree1, root);

	return 0;
}

程式碼執行結果如下圖：

總結：

在實現這幾個演算法的過程中，遇到了一些坑：
（1）首先是棧的初始化，在為棧底指標分配記憶體空間時，忘了乘以棧容量，導致後來測試一直不對
（2）然後是棧的資料結構定義，棧中儲存的應該是指向二叉樹節點指標的指標，開始我直接定義的指向二叉樹節點的指標，導致在後序非遞迴演算法中一直出問題，修改了某個節點的isPrintOut值後，再取出來發現值沒有變，問題出在Push節點到棧，如果棧中存的是二叉樹節點的指標，則入棧時程式碼是下面這樣的：