二叉树的非递归遍历与递归打印 先序遍历

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

#define max_size 20  //person姓名的大小
#define my_false 0
#define my_true 1

//栈
typedef struct StackNode
{
	struct StackNode* next;
}StackNode;

typedef struct StackList
{
	StackNode top;  //指向栈顶的指针
    int count;
}StackList;

StackList* init_stack()
{
	StackList * stack = (StackList*)malloc(sizeof(StackList));
	stack->count = 0;
	stack->top.next = NULL;
	return stack;
}

void push_stack(StackList* stack , StackNode* data) //入栈
{
	if(data == NULL)
	{
		return;
	}
	data->next = stack->top.next;
	stack->top.next = data;
	stack->count++;
}

void pop_stack(StackList* stack) //出栈
{
	if(stack == NULL)
	{
		return;
	}
	stack->top.next = stack->top.next->next;
	stack->count--;
}

StackNode* top_stack(StackList* stack)
{
	if(stack == NULL)
	{
		return NULL;
	}
	return stack->top.next;
}
//测试栈
typedef struct person
{
	StackNode node;
	char name[max_size];
	int age;
}Person;
//打印
void My_print(StackNode* data)
{
	person* p = (person*)data;
	printf("%s  %d\n" , p->name ,p->age);
}


//**********************************************************************************//
//二叉树
typedef struct BTNODE
{
	char ch;
	struct BTNODE* Lchild;
	struct BTNODE* Rchild;
}BTNode;
//因为栈是企业链表的形式，所以对二叉树进行封装
typedef struct BTNode_stack
{
	StackNode node;
	BTNode* root;   //二叉树的根节点
	int flag;       //用来表示true 和 flase
}BTNode_stack;

//创建结点
BTNode_stack* createBTNode_stack(BTNode* root ,int flag)
{
	BTNode_stack* newnode = (BTNode_stack*)malloc(sizeof(BTNode_stack));
	newnode->root = root;
	newnode->flag = flag;
	return newnode;
}
//二叉树的非递归遍历
void NonRecursion(BTNode* root)
{
	StackList* stack = init_stack();
	push_stack(stack,(StackNode*)createBTNode_stack(root,my_false)); //入栈
	while(stack->count > 0)
	{
		BTNode_stack* node = (BTNode_stack*)top_stack(stack);  //返回栈顶元素
		pop_stack(stack);                                      //出栈
		//判断弹出的树结点是否为空
		if(node->root == NULL)
		{
			continue;
		}
		if(node->flag == my_true)
		{
			printf("%c  ",node->root->ch);
		}
		else
		{ 
			push_stack (stack,(StackNode*)createBTNode_stack( node->root->Rchild ,my_false ));
			push_stack (stack,(StackNode*)createBTNode_stack( node->root->Lchild ,my_false ));
			node->flag = my_true;
			push_stack (stack,(StackNode*)node);
		}
	}
}
//二叉树的递归遍历
void Recursion(BTNode* root) //根结点
{
	if(root == NULL)
	{
	     return;
	}
	printf("%c  ",root->ch);
	//递归遍历
	Recursion(root->Lchild);
	Recursion(root->Rchild);
}
//创建树 A，B，C，D，E，F，G，H
void CreateBinaryTree()
{
	//创建结点
	BTNode node1 = {'A' ,NULL ,NULL };
	BTNode node2 = {'B' ,NULL ,NULL };
	BTNode node3 = {'C' ,NULL ,NULL };
	BTNode node4 = {'D' ,NULL ,NULL };
	BTNode node5 = {'E' ,NULL ,NULL };
	BTNode node6 = {'F' ,NULL ,NULL };
	BTNode node7 = {'G' ,NULL ,NULL };
	BTNode node8 = {'H' ,NULL ,NULL };
	//建立关系
	node1.Lchild = &node2;
	node1.Rchild = &node6;
	node2.Rchild = &node3;
	node3.Lchild = &node4;
	node3.Rchild = &node5;
	node6.Lchild = &node7;
	node7.Lchild = &node8;
	//非递归打印
	NonRecursion(&node1);
	printf("\n");
	//递归打印
	Recursion(&node1);
}


int main()
{
	CreateBinaryTree();
	printf("\n");

	//测试栈 与二叉树非递归遍历无关
	StackList* stack = init_stack();
	person p1 = { NULL ,"aaa",20 };
	person p2 = { NULL ,"bbb",21 };
	person p3 = { NULL ,"ccc",22 };
	push_stack(stack,(StackNode*)&p1);
	push_stack(stack,(StackNode*)&p2);
	push_stack(stack,(StackNode*)&p3);
	while(stack->count>0)
	{
		My_print(top_stack(stack));
		pop_stack(stack);
	} 
	
}