二叉树的遍历（非递归）

二叉树的遍历
1.前序遍历
　　先访问根节点，再访问左子树，最后访问右子树。
算法思想：从根到

 1 void pre_order(struct ptree_node *root)
 2 {
 3     struct ptree_node *stack[MAX_SIZE], *p = root;
 4     int top = 0;
 5     while (NULL != p || top > 0) {
 6         if (NULL != p) {
 7             visit(p);
 8             stack[top++] = p;
 9             p = p->left;
10         } else {
11             p = stack[top--];
12             p = p->rigth;
13         }  
14     }  
15 }


2.中序遍历
　　先访问左子树，再访问根节点，最后访问右子树

 1 void in_order(struct btree_node *root)
 2 {
 3     struct btree_node *stack[MAX_SIZE], *p = root;
 4     int top = 0;
 5     while (NULL != p || top > 0) {
 6         if (NULL != p) {
 7             stack[top++] = p;
 8             p = p->left;
 9         } else {
10             p = stack[top--];
11             visit(p);
12             p = p->right;
13         }
14     }
15 }

3.后续遍历
　　先访问左子树，然后访问右子树，最后访问根节点

 1 void post_order(struct btree_node *root)
 2 {
 3     struct btree_node *stack[MAX_SIZE], *p = root;
 4     int top = 0;
 5     while (NULL != p || top > 0) {
 6     　　while (p!= NULL) {
 7 　　　　　　　stack[top++] = p;
 8             p = p->left;
 9         }
10         if (top > 0) {
11 　　　　　　　 p = stack[top];
12             if (root->flag) {
13                 visit(p);
14                 top--;
15                 p = NULL;
16             } else {
17                 p->flag = true;
18                 p = p->right;
19             }
20         }
21     }
22 }


4.层次遍历
　　逐层遍历二叉树

 1 void level_tranv(struct btree_node *root)
 2 {
 3      struct btree_node *queue[MAX_SIZE], *p = root;
 4 　　inqueue(p);
 5 　　while (!is_empty(queue)) {
 6       　　p = dequeue(queue);
 7       　　visit(p);
 8       　　if (NULL != p->lchild) {
 9             　　inqueue(queue);
10      　　 }
11          if (NULL != p->rchild) {
12               inqueue(queue);
13             }
14       }
15 }

posted on 2011-08-31 23:16  lambda107  阅读(150)  评论(0)    收藏  举报

导航