Various traversal of binary tree

Reprint Address http://blog.csdn.net/SJF0115/article/details/8645991

Tree structure is a kind of important nonlinear data structure, in which tree and two-fork trees are most commonly used.

A binary tree is an ordered tree with a maximum of two subtrees per node. Usually the root of the subtree is referred to as the left subtree and right subtree. Binary trees are often used as binary search trees and two-fork or binary-ordered trees. Each node of a binary tree has a maximum of two subtrees trees (no nodes with a degree greater than 2), and the subtree of the binary tree has left and right points, and the order cannot be reversed. The first layer of the binary tree has a maximum of 2 i-1 nodes, and a two-tree with a depth of K has a maximum of 2^ (k)-1 nodes; for any binary tree T, if its terminal node number (that is, the leaf node number) is N0, the 2 node is n2, then N0 = n2 + 1.

The chain storage structure of binary tree is a kind of important data structure, and its form is defined as follows:

[CPP]View Plaincopy

1. Binary tree nodes
2. typedef struct bitnode{
3. //Data
4. char data;
5. //Left child hands
6. struct Bitnode *lchild,*rchild;
7. }bitnode,*bitree;

Binary Tree creation:

By reading a string, the algorithm for building a two-fork tree is as follows:

[CPP]View Plaincopy

2. Create a two-fork tree by ordinal sequence
4. int Createbitree (Bitree &t) {
6. char data;
8. ///Enter the value (one character) of the node in the binary tree in order of precedence, ' # ' indicates an empty tree
10. scanf ("%c", &data);
12. if (data = = ' # ') {
14. T = NULL;
16. }
18. else{
20. T = (bitree) malloc (sizeof (Bitnode));
22. //Generate root node
24. T->data = data;
26. //Construct left sub-tree
28. Createbitree (T->lchild);
30. //Construct right sub-tree
32. Createbitree (T->rchild);
34. }
36. return 0;
38. }

Traversal of a binary tree:

Traversal is one of the most basic operations of the tree, so-called traversal of the binary tree, that is, according to a certain rules and order all the nodes of the binary tree, so that each node is visited once, and only be visited once. Because the binary tree is a nonlinear structure, the traversal of the tree is essentially the transformation of each node of the two-fork tree into a linear sequence to be represented.

Recursive algorithm:

[CPP]View Plaincopy

2. Output
4. void Visit (Bitree T) {
6. if (t->data! = ' # ') {
8. printf ("%c", t->data);
10. }
12. }
14. First Order traversal
16. void preorder (Bitree T) {
18. if (T! = NULL) {
20. //Access root node
22. Visit (T);
24. //access to left dial hand nodes
26. Preorder (T->lchild);
28. //Access right sub-node
30. Preorder (T->rchild);
32. }
34. }
36. Middle Sequence traversal
38. void Inorder (Bitree T) {
40. if (T! = NULL) {
42. //access to left dial hand nodes
44. Inorder (T->lchild);
46. //Access root node
48. Visit (T);
50. //Access right sub-node
52. Inorder (T->rchild);
54. }
56. }
58. Post-post traversal
60. void Postorder (Bitree T) {
62. if (T! = NULL) {
64. //access to left dial hand nodes
66. Postorder (T->lchild);
68. //Access right sub-node
70. Postorder (T->rchild);
72. //Access root node
74. Visit (T);
76. }
78. }

Non-recursive algorithm:

<1> first-order traversal:

"Thinking": After access to T->data, the t into the stack, traversing the left subtree, after traversing the Zuozi return, the top element of the stack should be T, out of the stack, and then sequentially traverse the right subtree of T.

[CPP]View Plaincopy

2. /* Sequential traversal (non-recursive)
4. Idea: After access to T->data, the t into the stack, traversing the left subtree, after traversing the Zuozi return, the top element of the stack should be T, out of the stack, and then first traversing the right subtree of T.
6. */
8. void PreOrder2 (Bitree T) {
10. Stack<bitree> Stack;
12. //p is a traversal pointer
14. Bitree p = T;
16. //stack is not empty or p is not empty when the loop
18. While (P | |!stack.empty ()) {
20. if (P! = NULL) {
22. //deposit in stack
24. Stack.push (P);
26. //Access root node
28. printf ("%c", p->data);
30. //traverse the left subtree
32. p = p->lchild;
34. }
36. else{
38. //Stack back
40. p = stack.top ();
42. Stack.pop ();
44. //access to right sub-tree
46. p = p->rchild;
48. }
50. }//while
52. }

<2> in-sequence traversal

"Idea": T is to traverse the root of the tree pointer, the middle sequence traversal requires that after traversing the left dial hand tree, access to the root, and then traverse the right subtree.
First, the t into the stack, traversing the left subtree, after traversing the Zuozi return, the top element of the stack should be T, out of the stack, access to T->data, and then the right subtree of t traversal.

[CPP]View Plaincopy

2. void InOrder2 (Bitree T) {
4. Stack<bitree> Stack;
6. //p is a traversal pointer
8. Bitree p = T;
10. //stack is not empty or p is not empty when the loop
12. While (P | |!stack.empty ()) {
14. if (P! = NULL) {
16. //deposit in stack
18. Stack.push (P);
20. //traverse the left subtree
22. p = p->lchild;
24. }
26. else{
28. //fallback, Access root node
30. p = stack.top ();
32. printf ("%c", p->data);
34. Stack.pop ();
36. //access to right sub-tree
38. p = p->rchild;
40. }
42. }//while
44. }

<3> Post-traversal

"Thinking": T is to traverse the root of the tree pointer, post-order traversal requirements after traversing the left and right subtree, and then access to the root. It is necessary to determine whether the left and right subtrees of the root node have been traversed.

[CPP]View Plaincopy

2. Post-post traversal (non-recursive)
4. typedef struct bitnodepost{
6. Bitree Bitree;
8. char tag;
10. }bitnodepost,*bitreepost;
14. void PostOrder2 (Bitree T) {
16. Stack<bitreepost> Stack;
18. //p is a traversal pointer
20. Bitree p = T;
22. Bitreepost BT;
24. //stack is not empty or p is not empty when the loop
26. While (P! = NULL | |!stack.empty ()) {
28. //traverse the left subtree
30. While (P! = NULL) {
32. BT = (bitreepost) malloc (sizeof (bitnodepost));
34. Bt->bitree = p;
36. //Visited left dial hand tree
38. Bt->tag = ' L ';
40. Stack.push (BT);
42. p = p->lchild;
44. }
46. ///left/right sub-tree access complete access to root node
48. While (!stack.empty () && (Stack.top ())->tag = = ' R ') {
50. BT = Stack.top ();
52. //Stack back
54. Stack.pop ();
56. bt->bitree;
58. printf ("%c", bt->bitree->data);
60. }
62. //Traverse Right sub-tree
64. if (!stack.empty ()) {
66. BT = Stack.top ();
68. //access to right sub-tree
70. Bt->tag = ' R ';
72. p = bt->bitree;
74. p = p->rchild;
76. }
78. }//while
80. }

<4> Hierarchy Traversal

"Thinking": Each node is accessed hierarchically from top to bottom, from left to right, and the queue is used during the hierarchical traversal process.

[CPP]View Plaincopy

2. Hierarchical traversal
4. void Levelorder (Bitree T) {
6. Bitree p = T;
8. //Queue
10. Queue<bitree> queue;
12. //The root node is enqueued
14. Queue.push (P);
16. //Queue not empty loop
18. While (!queue.empty ()) {
20. //Enemy elements out of the team
22. p = Queue.front ();
24. //Access node of P point
26. printf ("%c", p->data);
28. //Exit queue
30. Queue.pop ();
32. //Left dial hand tree is not empty, the left sub-tree is enqueued
34. if (p->lchild! = NULL) {
36. Queue.push (P->lchild);
38. }
40. //Right subtree is not empty, the right subtree is enqueued
42. if (p->rchild! = NULL) {
44. Queue.push (P->rchild);
46. }
48. }
50. }

Test Case:

Input:

abc# #DE #g# #F # # #

Output:

Various traversal of binary tree