【複習】手寫數據結構之二叉樹的非遞歸遍歷

邏輯：利用堆棧先進後出，實現二叉樹的非遞歸遍歷；

1.先將根結點放入堆棧，將其標籤設爲 false。

2、彈出堆棧頂端元素，判斷標籤；

1》若爲false設爲true，繼續放入堆棧；

2》若爲true 輸出此結點信息，再將此結點的右結點，左結點依次壓入堆棧；

3》若爲NULL 不執行任何操作；

3、重複執行步驟2 直到堆棧爲空；

 

代碼如下，可用企業鏈表進行改進；

 

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




typedef struct BINARYNODE
{
	char ch;
	struct BINARYNODE* lChild;
	struct BINARYNODE* rChild;
	int flag;
}BinaryNode;

typedef struct LINKNODE
{
	BinaryNode* data;
	struct LINKNODE* next;
} LinkNode;

typedef struct LINKSTACK
{
	LinkNode* head;
	LinkNode* rearNode;
	int size;
}LinkStack;


//棧的初始化
void* init_linkStack()
{
	LinkStack*  stack = (LinkStack*)malloc(sizeof(LinkStack));
	//stack->node.next = NULL;
	stack->head = (LinkNode*)malloc(sizeof(LinkNode));
	stack->head->next = NULL;
	stack->rearNode = stack->head;
	stack->size = 0;
	return stack;
}

//入棧
void pushBack_LinkStack(LinkStack* stack, BinaryNode* data)
{
	if (stack == NULL)
		return;
	if (data == NULL)
		return;

	if (stack->size == 0)
	{
		LinkNode* newNode = (LinkNode*)malloc(sizeof(LinkNode));
		stack->head->data = data;
		stack->size++;
	}
	else
	{
		LinkNode* newNode = (LinkNode*)malloc(sizeof(LinkNode));
		newNode->data = data;
		newNode->next = stack->head;
		stack->head = newNode;
		stack->size++;
	}
}


//返回棧頂元素；
BinaryNode* top_SeqStack(LinkStack* stack)
{
	if (stack == NULL)
		return NULL;
	return stack->head->data;
}

//出棧 
BinaryNode* pop_LinkStack(LinkStack* stack)
{
	LinkNode* tempNode = NULL;
	if (stack == NULL)
		return NULL;
	if (stack->size == 0)
		return NULL;
	if (stack->size == 1)
	{
		stack->size--;
		return stack->head->data;
	}
	else
	{
		tempNode = stack->head;
		stack->head = stack->head->next;
		stack->size--;
		return tempNode->data;
	}


}

//返回棧頂元素；
void* top_linkStack(LinkStack* stack)
{
	return stack->head->data;
}

void destorySpace_SeqStack(LinkStack* stack)
{
	if (stack != NULL)
	{
		free(stack);
		stack = NULL;
	}

}




void  recursion(BinaryNode* root, int* num)
{
	BinaryNode* recursionNode = root;

	if (root == NULL)
	{
		return;
	}

	if (recursionNode->lChild == NULL && recursionNode->rChild == NULL)
	{
		*num += 1;
		printf("%c", recursionNode->ch);
	}

	//printf("%c", recursionNode->ch);//先序

	if (recursionNode->lChild != NULL)
	{
		recursion(recursionNode->lChild, num);

	}

	if (recursionNode->rChild != NULL)
	{
		recursion(recursionNode->rChild, num);

	}
}
//計算深度；
int  caculateDepth(BinaryNode* root)
{
	BinaryNode* tempNode = root;
	if (root == NULL)
		return 0;

	//return 0  後 caculateDepth 不再執行；
	int l = caculateDepth(tempNode->lChild);
	int r = caculateDepth(tempNode->rChild);

	return r >= l ? r + 1 : l + 1;

}

//拷貝二叉樹
BinaryNode* copyTree(BinaryNode* root)
{
	if (root == NULL)
	{
		return NULL;
	}

	BinaryNode* lChild = copyTree(root->lChild);
	BinaryNode* rChild = copyTree(root->rChild);

	BinaryNode* newNode = (BinaryNode*)malloc(sizeof(BinaryNode));
	//這裏的鏈接是自下到上的；
	newNode->ch = root->ch;
	newNode->lChild = lChild;
	newNode->rChild = rChild;

	return newNode;
}

void  recursion1(BinaryNode* root)
{
	BinaryNode* recursionNode = root;

	if (root == NULL)
	{
		return;
	}

	printf("%c", recursionNode->ch);//先序

	if (recursionNode->lChild != NULL)
	{
		recursion1(recursionNode->lChild);

	}

	if (recursionNode->rChild != NULL)
	{
		recursion1(recursionNode->rChild);

	}
}

void destorySpace_BinaryNode(BinaryNode* root)
{
	if (root == NULL)
		return;

	destorySpace_BinaryNode(root->lChild);
	destorySpace_BinaryNode(root->rChild);

	free(root);
	//root = NULL;

}

void creatBitreeNode()
{
	

}

void main()
{
	//初始化堆棧；
	LinkStack* stack = init_linkStack();

	//創建結點；
	BinaryNode nodeA = { 'A', NULL, NULL ,0 };
	BinaryNode nodeB = { 'B', NULL, NULL, 0 };
	BinaryNode nodeC = { 'C', NULL, NULL, 0 };
	BinaryNode nodeD = { 'D', NULL, NULL, 0 };
	BinaryNode nodeE = { 'E', NULL, NULL, 0 };
	BinaryNode nodeF = { 'F', NULL, NULL, 0 };
	BinaryNode nodeG = { 'G', NULL, NULL, 0 };
	BinaryNode nodeH = { 'H', NULL, NULL, 0 };

	//創建樹；
	nodeA.lChild = &nodeB;
	nodeA.rChild = &nodeF;
	nodeB.lChild = NULL;
	nodeB.rChild = &nodeC;
	nodeC.lChild = &nodeD;
	nodeC.rChild = &nodeE;
	nodeF.lChild = NULL;
	nodeF.rChild = &nodeG;
	nodeG.lChild = &nodeH;
	nodeG.rChild = NULL;

	//--------------非遞歸遍歷----------------//
	//壓入根結點；
	pushBack_LinkStack(stack,&nodeA); 
	//彈出根結點；
	BinaryNode* node = pop_LinkStack(stack);
	node->flag = 1;
	pushBack_LinkStack(stack, &nodeA);
	printf("%c", node->ch);
	while (stack->size != 0)
	{ 
		//pushBack_LinkStack(stack, node->rChild);
		//pushBack_LinkStack(stack, node->lChild);

		BinaryNode* node = pop_LinkStack(stack);

		if (node == NULL)
			continue;
		else if (node->flag == 1)
		{
			printf("%c", node->ch);
			pushBack_LinkStack(stack, node->rChild);
			pushBack_LinkStack(stack, node->lChild);
		}
		else
		{
			node->flag = 1;
			pushBack_LinkStack(stack,node);
		}
		

	}

	printf("\n");
	 
	system("pause");
	return 0;
}