二叉树的先序、中序和后序的非递归遍历（C语言实现）

1、顺序栈的声明

#ifndef _seq_stack_h#define _seq_stack_h#include "binary_tree.h"#define STACK_INIT_SIZE 5#define STACK_INCR_SIZE 2typedef bitree_node * stack_elem_type;//typedef int stack_elem_type;typedef struct seq_stack{stack_elem_type * base;stack_elem_type * top;int size;}seq_stack;void init_stack_sq( seq_stack * stack );void free_stack_sq( seq_stack * stack );stack_elem_type get_top_sq( seq_stack stack );void pop_elem_sq( seq_stack * stack );void push_elem_sq( seq_stack * stack, stack_elem_type e );int stack_empty_sq( seq_stack stack );int stack_length_sq( seq_stack stack );void trav_stack_sq( seq_stack stack );#endif

2、顺序栈的实现

#include <stdlib.h>#include <stdio.h>#include <assert.h>#include "seq_stack.h"void init_stack_sq( seq_stack * stack ){stack->size = STACK_INIT_SIZE;stack->base = stack->top = ( stack_elem_type * )malloc( STACK_INIT_SIZE * sizeof( stack_elem_type ) );assert( stack->base != NULL );}void free_stack_sq( seq_stack * stack ){stack->size = 0;free( stack->base );stack->base=  stack->top = NULL;}void push_elem_sq( seq_stack * stack, stack_elem_type e ){stack_elem_type * base = NULL, * p = NULL, * q = NULL;if( stack->top - stack->base >= stack->size ){stack->size += STACK_INCR_SIZE;base = ( stack_elem_type * )malloc( sizeof( stack_elem_type ) * stack->size );assert( base != NULL );p = base; q = stack->base;while( q < stack->top )*p++ = *q++;free( stack->base );stack->base = base;stack->top = stack->base + ( stack->size - STACK_INCR_SIZE );}*stack->top++ = e;}stack_elem_type get_top_sq( seq_stack stack ){return stack_empty_sq( stack ) ? NULL : *( stack.top - 1 );}void pop_elem_sq( seq_stack * stack ){assert( stack->top > stack->base );--stack->top;}int stack_length_sq( seq_stack stack ){return stack.top - stack.base;}int stack_empty_sq( seq_stack stack ){return stack.base == stack.top;}void trav_stack_sq( seq_stack stack ){stack_elem_type * p = stack.base;while( p < stack.top )printf( "%c ", (*p++)->data );printf( "\n" );}

3、循环队列的声明

#ifndef _circ_queue_h#define _circ_queue_h#include "binary_tree.h"typedef bitree_node * queue_elem_type;typedef struct circ_queue {queue_elem_type * buffer;int front, rear;int size;}circ_queue;void init_circ_queue( circ_queue * cq );void clear_circ_queue( circ_queue * cq );void free_circ_queue( circ_queue * cq );void trav_circ_queue( circ_queue cq );int push_elem_cq( circ_queue * cq, queue_elem_type e );queue_elem_type get_front_elem_cq( circ_queue cq );void pop_elem_cq( circ_queue * cq );int circ_queue_length( circ_queue cq );int circ_queue_empty( circ_queue cq );#endif

4、循环队列的实现

#include <stdlib.h>#include <stdio.h>#include <assert.h>#include "circ_queue.h"void init_circ_queue( circ_queue * cq ){cq->size = 10;cq->buffer = ( queue_elem_type * )malloc( sizeof( queue_elem_type ) * cq->size );assert( cq->buffer );cq->front = cq->rear = 0;}void clear_circ_queue( circ_queue * cq ){cq->front = cq->rear = 0;}void free_circ_queue( circ_queue * cq ){cq->size = 0;free( cq->buffer );cq->front = cq->rear = 0;}int circ_queue_empty( circ_queue cq ){return cq.front == cq.rear;}int circ_queue_full( circ_queue cq ){return ( cq.rear + 1 ) % cq.size == cq.front;}void trav_circ_queue( circ_queue cq ){int i;if( ! circ_queue_empty( cq ) ){i = cq.front;while( i % cq.size != cq.rear ){printf( "%c ", cq.buffer[i++]->data );}}}int push_elem_cq( circ_queue * cq, queue_elem_type e ){int res = -1;if( ! circ_queue_full( *cq ) ){cq->buffer[cq->rear++] = e;cq->rear %= cq->size;res = 0;}return res;}queue_elem_type get_front_elem_cq( circ_queue cq ){return circ_queue_empty( cq ) ? NULL : cq.buffer[cq.front];}void pop_elem_cq( circ_queue * cq ){assert( ! circ_queue_empty( *cq ) );cq->front = ( cq->front + 1 ) % cq->size;}int circ_queue_length( circ_queue cq ){return ( cq.rear - cq.front + cq.size ) % cq.size;}

5、用于后序遍历的顺序栈类型声明

#ifndef _post_order_seq_stack_h#define _post_order_seq_stack_h#include "binary_tree.h"#define STACK_INIT_SIZE 5#define STACK_INCR_SIZE 2typedef enum visit_flag { LR, RR }visit_tag;typedef struct po_stack_elem_type{bitree_node * ptr;visit_tag tag;}po_stack_elem_type;typedef struct po_seq_stack{po_stack_elem_type * base;po_stack_elem_type * top;int size;}po_seq_stack;void init_stack_posq( po_seq_stack * stack );void free_stack_posq( po_seq_stack * stack );po_stack_elem_type get_top_posq( po_seq_stack stack );void pop_elem_posq( po_seq_stack * stack );void push_elem_posq( po_seq_stack * stack, po_stack_elem_type e );int stack_empty_posq( po_seq_stack stack );int stack_length_posq( po_seq_stack stack );#endif

6、二叉树类型声明

#ifndef _binary_tree_h#define _binary_tree_htypedef char elem_type;typedef struct bitree_node{elem_type data;struct bitree_node * lchild, * rchild;}bitree_node;typedef bitree_node * binary_tree;void create_bitree( binary_tree * root );void free_bitree( binary_tree * root );void trav_preorder( binary_tree root );void trav_preorder_recur( binary_tree root );void trav_inorder( binary_tree root );void trav_inorder_recur( binary_tree root );void trav_postorder( binary_tree root );void trav_postorder_recur( binary_tree root );void trav_level_order( binary_tree root );#endif

7、二叉树实现

#include <stdio.h>#include <stdlib.h>#include <string.h>#include "binary_tree.h"#include "seq_stack.h"#include "circ_queue.h"#include "po_seq_stack.h"void create_bitree( binary_tree * root ){char ch;if( ( ch = getchar() ) == '#' ){*root = NULL;}else{*root = ( bitree_node * )malloc( sizeof( bitree_node ) );( *root )->data = ch;create_bitree( &( *root )->lchild );create_bitree( &( *root )->rchild );}}void free_bitree( binary_tree * root ){if( *root != NULL ){free_bitree( &( *root )->lchild );free_bitree( &( *root )->rchild );free( *root );*root = NULL;}}void trav_preorder_recur( binary_tree root ){if( root != NULL ){printf( "%c", root->data );trav_preorder_recur( root->lchild );trav_preorder_recur( root->rchild );}}void trav_inorder_recur( binary_tree root ){if( root != NULL ){trav_inorder_recur( root->lchild );printf( "%c ", root->data );trav_inorder_recur( root->rchild );}}void trav_postorder_recur( binary_tree root ){if( root != NULL ){trav_postorder_recur( root->lchild );trav_postorder_recur( root->rchild );printf( "%c ", root->data );}}void trav_preorder( binary_tree root ){seq_stack node_seq; /* node sequence */stack_elem_type p = root;init_stack_sq( &node_seq );push_elem_sq( &node_seq, NULL );while( p != NULL ){printf( "%c ", p->data );if( p->rchild != NULL )push_elem_sq( &node_seq, p->rchild );if( p->lchild != NULL )p = p->lchild;else{p = get_top_sq( node_seq );pop_elem_sq( &node_seq );}}free_stack_sq( &node_seq );}void trav_inorder( binary_tree root ){seq_stack stack;bitree_node * p = root;init_stack_sq( &stack );while( p != NULL || ! stack_empty_sq( stack ) ){if( p != NULL ){push_elem_sq( &stack, p );p = p->lchild;}else{p = get_top_sq( stack );pop_elem_sq( &stack );printf( "%c ", p->data );p = p->rchild;}}free_stack_sq( &stack );}void trav_postorder( binary_tree root ){po_seq_stack stack; // po: post-orderpo_stack_elem_type elem;bitree_node * p = root;init_stack_posq( &stack );while( p != NULL || ! stack_empty_posq( stack ) ){while( p != NULL ){elem.ptr = p;elem.tag = LR;push_elem_posq( &stack, elem );p = p->lchild;}elem = get_top_posq( stack );pop_elem_posq( &stack );p = elem.ptr;if( elem.tag == LR ){elem.tag = RR;push_elem_posq( &stack, elem );p = p->rchild;}else{printf( "%c ", p->data );p = NULL;}}free_stack_posq( &stack );}void trav_level_order( binary_tree root ){circ_queue cq;queue_elem_type p = NULL;init_circ_queue( &cq );if( root != NULL ){push_elem_cq( &cq, root );while( ! circ_queue_empty( cq ) ){p = get_front_elem_cq( cq );pop_elem_cq( &cq );printf( "%c ", p->data );if( p->lchild != NULL )push_elem_cq( &cq, p->lchild );if( p->rchild != NULL )push_elem_cq( &cq, p->rchild );}}free_circ_queue( &cq );}

8、测试程序

#include <stdio.h>#include <stdlib.h>#include <assert.h>#include "binary_tree.h"#include "seq_stack.h"int main( int argc, char * argv[] ){binary_tree root = NULL;create_bitree( &root );printf( "PreOrder recursive: " );trav_preorder_recur( root );printf( "\n" );trav_preorder( root );printf( "\n\n" );printf( "InOrder recursive: " );trav_inorder_recur( root );printf( "\n" );trav_inorder( root );printf( "\n\n" );printf( "PostOrder recursive:" );trav_postorder_recur( root );printf( "\n" );trav_postorder( root );printf( "\n\n" );printf( "Level Order: " );trav_level_order( root );printf( "\n" );free_bitree( &root );return 0;}