[Data structure] binary tree

(1) The concept of binary tree

Binary tree is a set of finite elements that are either empty or consist of an element called root (root) and two disjoint, two-tree trees that are called Saozi right subtrees respectively. When the collection is empty, the two fork tree is called an empty binary tree.
Full two fork tree: In a binary tree, if all branch nodes have Saozi right subtree, and all leaf nodes are on the same layer, such a binary tree is called a full two-fork tree.
Complete binary tree: A two-prong tree with n nodes at a depth of k, the nodes in the tree are numbered from top to bottom, left to right, and if the nodes numbered I (1≤i≤n) are in the same position in the binary tree as the nodes numbered I in the two-fork tree, the binary tree is called a complete binary tree.

(2) Basic operation and storage of binary tree

A binary tree with a two-fork list storage representation can be described as

[CPP]View Plaincopy

1. typedef struct bitnode{
2. Elemtype data;
3. struct Bitnode *lchild,rchild;
4. }bitnode,*bitree;

Build a binary tree so that it has only the head node.

[CPP]View Plaincopy

1. int Initiate (Bitree *bt)
2. {
3. if ((bt= (Bitnode *) malloc (sizeof (Bitnode)) ==null)
4. return 0;
5. bt->lchild=null;
6. bt->rchild=null;
7. return 1;
8. }

(3) Traversal of binary tree

The traversal of a binary tree means that each node in a binary tree is accessed in some order so that each node is accessed once and accessed only once.
First-order Traversal:
(1) Access to the root node;
(2) The first sequence traverses the left subtree of the root node;
(3) The right sub-tree of the root node is traversed in the first order.
The recursive algorithm of the first order traversal binary tree is as follows:

[CPP]View Plaincopy

1. void preorder (Bitree BT)
2. {/* First sequential traversal of binary tree bt*/
3. if (bt==null) return; / * End condition for recursive call * /
4. Visite (Bt->data); / * Access the data field of the node * /
5. Preorder (Bt->lchild); / * Recursively traverse BT's left sub-tree First order recursion * /
6. Preorder (Bt->rchild); / * Recursively traverse the right subtree of BT * /
7. }

Middle sequence traversal: First left subtree, then root, then right sub-tree
Post-the-loop traversal: First walk the tree left subtree, then right subtree, the last root

Non-recursive implementation of first order traversal
Can be achieved by using the last-in-first-out feature of the stack:

[CPP]View Plaincopy

2. void Nrpreorder (Bitree bt)
6. {/* non-recursive sequential traversal of binary tree * /
8. Bitree stack[maxnode],p;
10. int top;
12. if (bt==null) return;
14. Top=0;
16. P=BT;
18. While (!) ( p==null&&top==0))
20. {while (p!=null)
22. {visite (p->data); / * Access the data field of the node * /
24. if (top<maxnode-1)/ * Press the current pointer p * /
26. {stack[top]=p;
28. top++;
30. }
32. else {printf ("stack Overflow");
34. return;
36. }
38. p=p->lchild;/ * Pointer pointing to P's left child * /
40. }
42. if (top<=0) return; / * End of Stack empty * /
44. else{top--;
46. P=stack[top]; / * Eject the top element of the stack from the stack * /
48. p=p->rchild; / * Pointer points to P's right child node * /
50. }
52. }
54. }

Data structure-two fork tree

[Data structure] binary tree