遍历二叉树的递归算法与非递归算法以及C语言实现

zz http://blog.csdn.net/fuzhufang/archive/2009/03/08/3969375.aspx



先来看下面这棵二叉树。如图
1

。现在我们要对它进行先序遍历。递归思想：就是把这个大树拆分成
N

棵小树，每棵小树都进行一次先序遍历。再把这些遍历连合起来就是这棵树的先序遍历了。同理中序遍历和后序遍历也是一样的方法。下面举例说明先序递归算法：

令先序遍历的结果等于
S

；



图
1

对于图
2

这棵小树的先序遍历是：
1 2 3

S = 1
2
3



图
2

但以
2

为根节点又有一棵小树，这棵小树的先序遍历是：
2 4 5

S = 1
2
4
5
3



图
3

以
3

为根节点又有一棵小树，这棵小树的先序遍历是：
3 6 7

S = 1
2
4
5
3
6
7



图
4

以
6

为根节点又有一棵小树，这个小树的先序遍历是：
6 7

S =1
2
4
5
3
6
8
7



图
5

以
7

为跟节点又有一棵小树，这棵小树的先序遍历是：
7 9

S = 1 2
4
5
3
6
8
7
9



图
6

这样就得出了这棵大树的最终先序遍历结果了：

S = 1 2
4
5
3
6
8
7
9

。

再来看看这个变化过程：

S = 1
2
3

S = 1
2
4
5
3

S = 1
2
4
5
3
6
7

S =1
2
4
5
3
6
8
7

S = 1 2
4
5
3
6
8
7
9

对于二叉树的非递归算法，则是需要应用一种重要的数据结构
—

栈。用栈来存放准备需要访问的节点。例如先序遍历的非递归算法则是：

指针
p

指向根节点；

while

（
p

不为
NULL

或栈不空）｛

反复访问当前节点
*p

，

指针
p

进栈、再将指针左移，直至最左下节点；

当栈不空时，出栈，

取出栈顶指针且右移（返回上面操作，去遍历右子树）；

｝

下面是二叉树递归与非递归算法的
C

语言实现实例：

//tree.h

#ifndef
__TREE_H__

#define
__TREE_H__

typedef

struct

_node
{

struct

_node
*
left_child
;

struct

_node
*
right_child
;

ctype_t

data
;

}
node
, *
tree
;
//

二叉树节点结构

//

一种简单创建树的办法，供测试使用

void

create_tree
(
tree
*
root
,
const

ctype_t

elems
[],
csize_t
*
current_index
,
const

csize_t

max_size
);

//

不考虑二叉树的销毁了

//

二叉树先序遍历递归算法

void

preorder_recursion
(
tree

root
);

//

二叉树先序遍历递非归算法

void

preorder_nonrecursive
(
tree

root
);

//

二叉树中序遍历递归算法

void

inorder_recursion
(
tree

root
);

//

二叉树中序遍历递非归算法

void

inorder_nonrecursive
(
tree

root
);

//

二叉树后序遍历递归算法

void

postorder_recursion
(
tree

root
);

//

二叉树后序遍历递非归算法

void

postorder_nonrecursive
(
tree

root
);

#endif
//__TREE_H__

//tree.c

#include
"tree.h"

void

create_tree
(
tree
*
root
,
const

ctype_t

elems
[],
csize_t
*
current_index
,
const

csize_t

max_size
)

{

if
(*
current_index
<
max_size
)

{

const

ctype_t

t
=
elems
[(*
current_index
)++];

if
(
0
==
t
)

{

*
root
=
NULL
;

return
;

}

else

{

*
root
= (
node
*)
malloc
(
sizeof
(
node
));
//

假设
malloc

总是成功

(*
root
)->
data
=
t
;

create_tree
(&(*
root
)->
left_child
,
elems
,
current_index
,
max_size
);

create_tree
(&(*
root
)->
right_child
,
elems
,
current_index
,
max_size
);

}

}

}

void

preorder_recursion
(
tree

root
)

{

if
(
NULL
!=
root
)

{

printf
(
"%d/t"
,
root
->
data
);
//

根

preorder_recursion
(
root
->
left_child
);
//

左子树

preorder_recursion
(
root
->
right_child
);
//

右子树

}

}

void

preorder_nonrecursive
(
tree

root
)

{

tree

stack
[
100
];

int

top
=
0
;

tree

p
=
root
;

while
(
NULL
!=
p
||
top
>
0
)

{

while
(
NULL
!=
p
)

{

printf
(
"%d/t"
,
p
->
data
);

stack
[
top
++] =
p
;

p
=
p
->
left_child
;

}

p
=
stack
[--
top
];

p
=
p
->
right_child
;

}

}

void

inorder_recursion
(
tree

root
)

{

if
(
NULL
!=
root
)

{

inorder_recursion
(
root
->
left_child
);
//

左子树

printf
(
"%d/t"
,
root
->
data
);
//

根

inorder_recursion
(
root
->
right_child
);
//

右子树

}

}

void

inorder_nonrecursive
(
tree

root
)

{

tree

stack
[
100
];

int

top
=
0
;

tree

p
=
root
;

while
(
NULL
!=
p
||
top
>
0
)

{

while
(
NULL
!=
p
)

{

stack
[
top
++] =
p
;

p
=
p
->
left_child
;

}

p
=
stack
[--
top
];

printf
(
"%d/t"
,
p
->
data
);

p
=
p
->
right_child
;

}

}

void

postorder_recursion
(
tree

root
)

{

if
(
NULL
!=
root
)

{

postorder_recursion
(
root
->
left_child
);

postorder_recursion
(
root
->
right_child
);

printf
(
"%d/t"
,
root
->
data
);

}

}

void

postorder_nonrecursive
(
tree

root
)

{

tree

stack
[
100
];

int

top
=
0
;

tree

p
=
root
;

tree

lastvist
=
NULL
;

while
(
NULL
!=
p
||
top
>
0
)

{

while
(
NULL
!=
p
)

{

stack
[
top
++] =
p
;

p
=
p
->
left_child
;

}

p
=
stack
[
top
-
1
];

if
(
NULL
==
p
->
right_child
||
lastvist
==
p
->
right_child
)

{

printf
(
"%d/t"
,
p
->
data
);

--
top
;

lastvist
=
p
;

p
=
NULL
;

}

else

{

p
=
p
->
right_child
;

}

}

}

//main.c

#include
"tree.h"

int

main
()

{

ctype_t

elems
[] = {
1
,
2
,
4
,
0
,
0
,
5
,
0
,
0
,
3
,
6
,
8
,
0
,
0
,
0
,
7
,
0
,
9
,
0
,
0
,
0
,};

csize_t

current_index
=
0
;

tree

t
=
NULL
;

create_tree
(&
t
,
elems
, &
current_index
,
sizeof
(
elems
));

printf
(
"

二叉树先序遍历递归算法
/n"
);

preorder_recursion
(
t
);

printf
(
"/n"
);

printf
(
"

二叉树先序遍历非递归算法
/n"
);

preorder_nonrecursive
(
t
);

printf
(
"/n/n"
);

printf
(
"

二叉树中序遍历递归算法
/n"
);

inorder_recursion
(
t
);

printf
(
"/n"
);

printf
(
"

二叉树中序遍历非递归算法
/n"
);

inorder_nonrecursive
(
t
);

printf
(
"/n/n"
);

printf
(
"

二叉树后序遍历递归算法
/n"
);

postorder_recursion
(
t
);

printf
(
"/n"
);

printf
(
"

二叉树后序遍历非递归算法
/n"
);

postorder_nonrecursive
(
t
);

printf
(
"/n"
);

return

0
;

}

输出结果：

二叉树先序遍历递归算法

1 2 4 5 3 6 8 7 9

二叉树先序遍历非递归算法

1 2 4 5 3 6 8 7 9

二叉树中序遍历递归算法

4 2 5 1 8 6 3 7 9

二叉树中序遍历非递归算法

4 2 5 1 8 6 3 7 9

二叉树后序遍历递归算法

4 5 2 8 6 9 7 3 1

二叉树后序遍历非递归算法

4 5 2 8 6 9 7 3 1

Press any key to continue

=================

zz http://blog.pfan.cn/byoneself/19799.html

PreOrder(BiTree T)
//先序非递归遍历二叉树

{

InitStack(S); //创建工作栈

Push(S,T);

while(!StackEmpty(S))

{

Pop(S,p); //出栈

Visit(p); //访问

if(p->rchild)

Push(S,p->rchild); //右子树入栈

if(p->lchild)

Push(S,p->lchild); //左子树入栈

}

}

InOrder(BiTree T)
//中序非递归遍历二叉树

{

InitStack(S); //创建工作栈

Push(S,<T,0>); //根入栈，且置0标志此时不能访问

while(!StackEmpty(S))

{

Pop(S,<p,flag>); //出栈

if(flag==1)

Visit(p);
//访问标志为1可以访问

else

{

if(p->rchild)

Push(S,<p->rchild,0>); //右子树入栈且置访问标志0

Push(S,<p,1>); //根入栈且置访问标志1

if(p->lchild)

Push(S,<p->lchild,0>); //左子树入栈且置访问标志0

}

}

}

PostOrder(BiTree T)
//后序非递归遍历二叉树

{

InitStack(S); //创建工作栈

Push(S,<T,0>); //根入栈，且置i0标志此时不能访问

while(!StackEmpty(S))

{

Pop(S,<p,flag>); //出栈

if(flag==1)

Visit(p);
//访问标志为1可以访问

else

{

Push(S,<p,1>); //根入栈且置访问标志1

if(p->rchild)

Push(S,<p->rchild,0>); //右子树入栈且置访问标志0

if(p->lchild)

Push(S,<p->lchild,0>); //左子树入栈且置访问标志0

}

}

}

LayerOrder(BiTree T)
//层次遍历二叉树

{

InitQueue(Q); //创建工作队列

EnQueue(Q,T); //根入队

while(!QueueEmpty(Q))

{

DeQueue(Q,p); //出队

Visit(p); //访问

if(p->lchild)

EnQueue(Q,p->lchild); //左子树入队

if(p->rchild)

EnQueue(Q,p->rchild); //右子树入队

}

}

===

其他：


1

二叉树遍历及C语言实现

2

判断整数序列是不是二元查找树的后序遍历结果