Binary Tree 

 1 #pragma once
 2 
 3 typedef int ElemType;
 4 typedef enum {false, true} bool;
 5 
 6 typedef struct Node {
 7     ElemType data;
 8     struct Node *lchild;
 9     struct Node *rchild;
10 } Node, *NodePtr;
11 
12 NodePtr CreateNode(ElemType d);
13 NodePtr CreateTree(int n);
14 int PreOrder(NodePtr root);
15 int InOrder(NodePtr root);
16 int PostOrder(NodePtr root);
17 int QueueOrder(NodePtr root);
18 int StackOrder(NodePtr root);
19 int DestroyTree(NodePtr root);
  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include "tree.h"
  4 #include "SQueue.h"
  5 #include "SquenceStack.h"
  6 
  7 NodePtr CreateNode(ElemType d)
  8 {
  9     NodePtr node;
 10 
 11     node = (NodePtr)malloc(sizeof(*node));
 12     if (NULL == node)
 13    　　 return NULL;
 14 
 15     node->data = d;
 16     node->rchild = NULL;
 17     node->lchild = NULL;
 18 
 19     return node;
 20 }
 21 
 22 NodePtr CreateTree(int n)
 23 {
 24     NodePtr root;
 25 
 26     if (n < 0)
 27     return NULL;
 28 
 29     root =(NodePtr)CreateNode(n);
 30     if (NULL == root)
 31     　　return NULL;
 32 
 33     root->rchild = CreateTree(n - 1);
 34     root->lchild = CreateTree(n - 1);
 35 
 36     return root;
 37 }
 38 
 39 int PreOrder(NodePtr root)
 40 {
 41     if (NULL == root)
 42     　　return 0;
 43 
 44     printf("%d ", root->data);
 45     PreOrder(root->lchild);
 46     PreOrder(root->rchild);
 47 
 48     return 0;
 49 }
 50 
 51 int InOrder(NodePtr root)
 52 {
 53     if (NULL == root)
 54   　　  return 0;
 55 
 56     InOrder(root->lchild);
 57     printf("%d ", root->data);
 58     InOrder(root->rchild);
 59 
 60     return 0;
 61 }
 62 
 63 int PostOrder(NodePtr root)
 64 {
 65     if (NULL == root)
 66     　　return 0;
 67 
 68     PostOrder(root->lchild);
 69     PostOrder(root->rchild);
 70     printf("%d ", root->data);
 71 
 72     return 0;
 73 }
 74 
 75 int QueueOrder(NodePtr root)
 76 {
 77     NodePtr node;
 78     SQueue queue;
 79 
 80     CreateSQueue(&queue);
 81     EnSQueue(&queue, root);
 82 
 83     while (DeSQueue(&queue, &node)) {
 84    　　 printf("%d ", node->data);
 85 
 86    　　 if (NULL != node->lchild)
 87        　　 EnSQueue(&queue, node->lchild);
 88 
 89    　　 if (NULL != node->rchild)
 90        　　 EnSQueue(&queue, node->rchild);
 91     }
 92 
 93     return 0;
 94 }
 95 
 96 int StackOrder(NodePtr root)
 97 {
 98     NodePtr node;
 99 
100     SStack stk;
101     CreateSStack(&stk, 50);
102     Push(&stk, root);
103 
104     while (Pop(&stk, &node)) {
105   　　  printf("%d ", node->data);
106 
107     　　if (NULL != node->lchild)
108        　　 Push(&stk, node->lchild);
109 
110    　　 if (NULL != node->rchild)
111       　　  Push(&stk, node->rchild);
112     }
113 
114     return 0;
115 }
116 
117 int DestroyTree(NodePtr root)
118 {
119     if (NULL == root)
120   　　  return 0;
121 
122     DestroyTree(root->lchild);
123     DestroyTree(root->rchild);
124     free(root);
125 
126     return 0;
127 }
 1 #include <stdio.h>
 2 #include "tree.h"
 3 
 4 int main(int argc, char **argv)
 5 {
 6     NodePtr root;
 7 
 8     root = CreateTree(3);
 9 
10     PreOrder(root);
11     putchar('\n');
12 
13     InOrder(root);
14     putchar('\n');
15 
16     PostOrder(root);
17     putchar('\n');
18 
19     QueueOrder(root);
20     putchar('\n');
21 
22     StackOrder(root);
23     putchar('\n');
24 
25     DestroyTree(root);
26 
27     return 0;
28 }

posted on 2012-09-15 14:58  robin.he  阅读(144)  评论(0)    收藏  举报

导航