BiTree.h
# ifndef MaxSize
# define MaxSize 50
# endif
typedef struct BiTNode {
ElemType data;
struct BiTNode * lchild, * rchild;
} BiTNode, * BiTree;
typedef struct {
BiTree data[ MaxSize] ;
int rear, front;
} SqQueue;
int EnQueue ( SqQueue* Q, BiTree node) {
if ( ( ( Q-> rear + 1 ) % MaxSize) == Q-> front) return 0 ;
Q-> data[ Q-> rear] = node;
Q-> rear = ( Q-> rear + 1 ) % MaxSize;
return 1 ;
}
int DeQueue ( SqQueue* Q, BiTree* t) {
if ( Q-> front == Q-> rear) return 0 ;
* t = Q-> data[ Q-> front] ;
Q-> front = ( Q-> front + 1 ) % MaxSize;
return 1 ;
}
typedef struct {
BiTree data[ MaxSize] ;
int top;
} SqStack;
int Push ( SqStack* S, BiTree node) {
if ( S-> top == MaxSize - 1 ) return 0 ;
S-> data[ ++ S-> top] = node;
return 1 ;
}
int Pop ( SqStack* S, BiTree* t) {
if ( S-> top == - 1 ) return 0 ;
* t = S-> data[ S-> top-- ] ;
return 1 ;
}
int GetTop ( SqStack S, BiTree* t) {
if ( S. top == - 1 ) return 0 ;
* t = S. data[ S. top] ;
return 1 ;
}
void Insert ( BiTree* T, ElemType e) {
BiTree p, s = ( BiTree) malloc ( sizeof ( BiTNode) ) ;
s-> lchild = s-> rchild = NULL ;
s-> data = e;
if ( ! * T) {
* T = s;
} else {
SqQueue Q = { 0 } ; EnQueue ( & Q, * T) ;
while ( Q. rear != Q. front) {
DeQueue ( & Q, & p) ;
if ( p-> lchild) {
EnQueue ( & Q, p-> lchild) ;
} else {
p-> lchild = s;
break ;
} if ( p-> rchild) {
EnQueue ( & Q, p-> rchild) ;
} else {
p-> rchild = s;
break ;
}
}
}
}
void PreOrder ( BiTree T) {
if ( T != NULL ) {
printf ( "%d " , T-> data) ;
PreOrder ( T-> lchild) ;
PreOrder ( T-> rchild) ;
}
}
void InOrder ( BiTree T) {
if ( T != NULL ) {
InOrder ( T-> lchild) ;
printf ( "%d " , T-> data) ;
InOrder ( T-> rchild) ;
}
}
void PostOrder ( BiTree T) {
if ( T != NULL ) {
PostOrder ( T-> lchild) ;
PostOrder ( T-> rchild) ;
printf ( "%d " , T-> data) ;
}
}
void PreOrder2 ( BiTree T) {
SqStack S = { 0 } ; S. top = - 1 ;
BiTree p = T;
while ( p || S. top != - 1 ) {
if ( p) {
Push ( & S, p) ;
printf ( "%d " , p-> data) ;
p = p-> lchild;
} else {
Pop ( & S, & p) ;
p = p-> rchild;
}
}
}
void InOrder2 ( BiTree T) {
SqStack S = { 0 } ; S. top = - 1 ;
BiTree p = T;
while ( p || S. top != - 1 ) {
if ( p) {
Push ( & S, p) ;
p = p-> lchild;
} else {
Pop ( & S, & p) ;
printf ( "%d " , p-> data) ;
p = p-> rchild;
}
}
}
void PostOrder2 ( BiTree T) {
SqStack S = { 0 } ; S. top = - 1 ;
int tag[ MaxSize] = { 0 } ; BiTree p = T;
while ( p || S. top != - 1 ) {
if ( p) {
Push ( & S, p) ;
p = p-> lchild;
tag[ S. top] = 0 ;
} else {
while ( tag[ S. top] == 1 ) {
Pop ( & S, & p) ;
printf ( "%d " , p-> data) ;
}
GetTop ( S, & p) ;
p = p-> rchild;
tag[ S. top] = 1 ;
}
if ( S. top == - 1 ) break ;
}
}
void LevelOrder ( BiTree T) {
SqQueue Q = { 0 } ; BiTree p;
EnQueue ( & Q, T) ;
while ( Q. rear != Q. front) {
DeQueue ( & Q, & p) ;
printf ( "%d " , p-> data) ;
if ( p-> lchild) EnQueue ( & Q, p-> lchild) ;
if ( p-> rchild) EnQueue ( & Q, p-> rchild) ;
}
}
main.c
# include <stdlib.h>
# include <stdio.h>
typedef int ElemType;
# include "BiTree.h"
int main ( void )
{
BiTree T = { 0 } ;
int arr[ ] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 } ;
for ( int i = 0 ; i < 9 ; ++ i)
Insert ( & T, arr[ i] ) ;
printf ( "=========递归算法=========\n" ) ;
printf ( "前序遍历:" ) ; PreOrder ( T) ;
printf ( "\n中序遍历:" ) ; InOrder ( T) ;
printf ( "\n后序遍历:" ) ; PostOrder ( T) ;
printf ( "\n========非递归算法========\n" ) ;
printf ( "前序遍历:" ) ; PreOrder2 ( T) ;
printf ( "\n中序遍历:" ) ; InOrder2 ( T) ;
printf ( "\n后序遍历:" ) ; PostOrder2 ( T) ;
printf ( "\n==========================\n" ) ;
printf ( "层次遍历:" ) ; LevelOrder ( T) ;
return 0 ;
}