二叉树先序遍历递归和非递归实现

1、递归算法：思路较为简单

// recursive travel 递归遍历
 void recur_pre_travel(bnode *node)
 {
 	if(node != NULL)
 	{
 		printf("%d ", node->data);
 		recur_pre_travel(node->lchild);
 		recur_pre_travel(node->rchild);
 	}
 }

2、先序遍历非递归：

循环过程：父节点出栈并访问，再右孩子节点入栈（如果存在），然后再左孩子节点入栈（如果存在），直到栈空为止。

启动点：根节点入栈。

 void non_recur_pre(bnode *node)
{
	bnode *top_node;
	if(node == NULL)
		return;
	stack_push(node);
	while(!stack_empty())
	{
		stack_pop(&top_node);
		printf("%d ", top_node->data);
		if(top_node->rchild)
			stack_push(top_node->rchild);
		if(top_node->lchild)
			stack_push(top_node->lchild);
	}
}

3、完整程序：

为了能够进行测试，我构造了一棵随机的排序二叉树、实现了栈结构。完整程序如下。有兴趣的可以去试试。

（1）主程序preorder_travel.c

#include <stdio.h>
#include <stdlib.h>
#include "creat_btree.h"
#include "stack.h"

// recursive travel 递归遍历
 void recur_pre_travel(bnode *node)
 {
 	if(node != NULL)
 	{
 		printf("%d ", node->data);
 		recur_pre_travel(node->lchild);
 		recur_pre_travel(node->rchild);
 	}
 }

//非递归先序遍历
 //主要思想就是先将根结点压入栈，然后根结点出栈并访问根结点，
 //而后依次将根结点的右孩子、左孩子入栈，直到栈为空为止
 void non_recur_pre(bnode *node)
{
	bnode *top_node;
	if(node == NULL)
		return;
	stack_push(node);
	while(!stack_empty())
	{
		stack_pop(&top_node);
		printf("%d ", top_node->data);
		if(top_node->rchild)
			stack_push(top_node->rchild);
		if(top_node->lchild)
			stack_push(top_node->lchild);
	}
}

 void main(void)
 {
 	bnode *btree = create_btree();        //随机生成排序二叉树
 	printf("-------recur_preorder_travel---------\n");
 	recur_pre_travel(btree);
	printf("\n");
 	printf("-------non_recur_preorder_travel---------\n");
 	non_recur_pre(btree);
	printf("\n");
 }

(2) 二叉树构造create_btree.c/create_btree.h

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "creat_btree.h"

static void insert_node(bnode *root, data_type data);
static bnode *create_node(data_type data);

typedef bnode *bnode_t;

//构造二叉排序树
bnode *create_btree(void)
{
	int i, m, data;
	bnode *root = NULL;
	srand( (unsigned)time( NULL ) );
	m = rand()%20;
	
	printf("random source data:");
	for(i=1; i<=m; i++)
	{
		data = rand()%20;;
		printf("%d ",data);
          		insert_node(&root, data);
	}
	printf("\n");
	return root;
}

//构成排序二叉树
//思路：用while循环判断新节点需要挂在哪个节点下面
static void insert_node(bnode_t *root, data_type data)
{
	bnode *node;
	bnode *new_node = NULL;
	if(*root == NULL)
	{
		*root = create_node(data);
		return;
	}

	node = *root;
	while(node->lchild || node->rchild)
	{
		if(node->data > data && node->lchild) 
			node = node->lchild;
		else if(node->data <= data && node->rchild) 
			node = node->rchild;
		else break;
	}
	new_node = create_node(data);
	if(node->data > data) 
		node->lchild = new_node;
	else
		node->rchild = new_node;
}


static bnode *create_node(data_type data)
{
	bnode *new_node = (bnode *) malloc(sizeof(bnode));
	if(new_node)
	{
		new_node->data = data;
		new_node->lchild = NULL;
		new_node->rchild = NULL;
	}
	return new_node;
}

#ifndef __CREAT_BTREE_H__
#define __CREAT_BTREE_H__

typedef int data_type;

typedef struct node
{
	data_type data;
	struct node *lchild;
	struct node *rchild;
}bnode;

bnode *create_btree(void);


#endif    //__CREAT_BTREE_H__

(3)构造栈：stack.c/stack.h

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

//使用全局变量维护栈顶
static stack_node *root = NULL;    //初始化栈为空

stack_node *create_stack_node(item_type x)
{
	stack_node *new_node = (stack_node *) malloc(sizeof(stack_node));
	if(new_node)
	{
		new_node->item = x;
		new_node->next = NULL;
	}
	return new_node;
}


void stack_push(item_type x)
{	
	stack_node *new_node;
	if(root == NULL)                  //首个元素入栈
	{
		root = create_stack_node(x);
		return;
	}
	//非首个元素陆栈
	new_node = create_stack_node(x);
	new_node->next = root;
	root =	new_node;
}

void stack_pop(item_type *x)
{
	stack_node *tmp;
	if(root != NULL)
	{
		tmp = root;
		*x = root->item;
		root = root->next;
		free(tmp);
	}
}

int stack_empty(void)
{
	if (root == NULL)
		return 1;
	return 0;
}

#ifndef __STACK_H__
#define __STACK_H__
#include "creat_btree.h"
typedef bnode *item_type;

typedef struct stack{
	item_type item;
	struct stack *next;
}stack_node;

typedef struct  stack_node *stack_node_t;


void stack_push(item_type x);
void stack_pop( item_type *x);
int stack_empty(void);

#endif