二叉树的遍历
二叉树的非递归遍历需要用到栈，所以就自己写栈，这也是一个比较纠结的地方。C语言里面只有值传递。声明指针时知给指针分配了空间，所以对于指针指向的对象，需要我们自己malloc。我在用户函数里声明了Stack*变量，在初始化时，当然需要分配Stack的空间，切记！！！又因为值传递的影响，所以选择传递一个二维指针，就因为之前没有分配一个Stack空间，而直接操作里面的base指针，显然要错误！
1 #include "stack.h"
2 #include<stdio.h>
3 #include<stdlib.h>
4 #include<malloc.h>
5 #include <assert.h>
6
7 int InitStack(Stack **S)
8 {
9 *S = (Stack*)malloc(sizeof(Stack));
10 if(!*S)
11 {
12 printf("Stack malloc error\n");
13 exit(-1);
14 }
15 (*S)->base = (int *)malloc(STACK_INIT_SIZE * sizeof(int));
16 if(!(*S)->base)
17 {
18 printf("Stack base malloc error\n");
19 exit(-1);
20 }
21 (*S)->top = (*S)->base;
22 (*S)->stacksize = STACK_INIT_SIZE;
23 return 1;
24 }
25
26 int Push(Stack *S, int e)
27 {
28 if(S->top - S->base >= S->stacksize)
29 {
30 S->base = (int *)realloc(S->base, (S->stacksize + STACKINCREMENT) * sizeof(int));
31 if(!S->base)
32 {
33 printf("Push malloc error\n");
34 exit(1);
35 }
36 S->top = S->base + STACKINCREMENT;
37 S->stacksize += STACKINCREMENT;
38 }
39 *S->top++ = e;
40 return 1;
41 }
42
43 int Pop(Stack *S, int *pe)
44 {
45 if(S->top == S->base)
46 return 0;
47 *pe = * --S->top;
48 return 1;
49 }
50
51 int StackEmpty(Stack *s)
52 {
53 if(s->top == s->base)
54 return 1;
55 return 0;
56 }
57
58 int Top(Stack *s, int *e)
59 {
60 if(StackEmpty(s))
61 return 0;
62
63 *e = *(s->top-1);
64 return 1;
65 }
66
67 int DestoryStack(Stack *S)
68 {
69 assert(S != NULL);
70 free(S->base);
71 S->base = NULL;
72 S->top = NULL;
73 free(S);
74 S = NULL;
75 return 1;
76 }
我的tree.c文件，对二叉树后序遍历的非递归算法还是有疑问。
1 #include <stdio.h>
2 #include <assert.h>
3 #include <stdlib.h>
4 #include <time.h>
5 #include "stack.h"
6
7 #define BASE 10
8 #define COUNT 10
9
10 typedef struct Node {
11 int data;
12 struct Node *lchild, *rchild;
13 }Node, *pNode;
14
15 static void
16 BT_Visit(pNode root)
17 {
18 if(root != NULL)
19 printf("%d\t", root->data);
20 }
21
22 pNode BT_GetNode(pNode root, int e)
23 {
24 if(root == NULL)
25 return NULL;
26
27 if(root->data == e)
28 return root;
29 if(root->data > e) {
30 return BT_GetNode(root->lchild, e);
31 } else {
32 return BT_GetNode(root->rchild, e);
33 }
34 }
35
36 static pNode BT_MakeNode(int e)
37 {
38 pNode pnode = (pNode)malloc(sizeof(Node));
39 assert(pnode != NULL);
40
41 pnode->data = e;
42 pnode->lchild = NULL;
43 pnode->rchild = NULL;
44 return pnode;
45 }
46
47 pNode BT_Insert(pNode *T, int e)
48 {
49 pNode pnode;
50 assert(T != NULL);
51
52 pnode = *T;
53
54 //二叉树为空
55 if(pnode == NULL) {
56 return *T = BT_MakeNode(e);
57 }
58
59 //已经存在，不能插入
60 if(pnode->data == e)
61 return NULL;
62 else if(pnode->data > e)
63 return BT_Insert(&pnode->lchild, e);
64 else
65 return BT_Insert(&pnode->rchild, e);
66 }
67
68 void
69 BT_PreOrder(pNode root)
70 {
71 if(root != NULL)
72 {
73 BT_Visit(root);
74 BT_PreOrder(root->lchild);
75 BT_PreOrder(root->rchild);
76 }
77 }
78
79 BT_InOrder(pNode root)
80 {
81 if(root != NULL)
82 {
83 BT_InOrder(root->lchild);
84 BT_Visit(root);
85 BT_InOrder(root->rchild);
86 }
87 }
88
89 void
90 BT_PostOrder(pNode root)
91 {
92 if(root != NULL)
93 {
94 BT_PostOrder(root->lchild);
95 BT_PostOrder(root->rchild);
96 BT_Visit(root);
97 }
98 }
99
100 //先打印当前节点，再依次访问左右子树。用栈是方便回溯，记录当前节点，用来以后访问右子树。
101 void
102 BT_PreOrderNoRec(pNode root)
103 {
104 pNode pnode = root;
105 int data;
106 assert(pnode != NULL);
107
108 Stack *s;
109 InitStack(&s);
110
111 while(pnode != NULL || !StackEmpty(s))
112 {
113 if(pnode != NULL) {
114 BT_Visit(pnode);
115 Push(s, pnode->data);
116 pnode = pnode->lchild;
117 } else {
118 Pop(s, &data);
119 pnode = BT_GetNode(root, data);
120 pnode = pnode->rchild;
121 }
122 }
123 DestoryStack(s);
124 }
125
126 //先访问左子树，所以先将节点压栈，且并不打印data
127 void
128 BT_InOrderNoRec(pNode root)
129 {
130 pNode pnode = root;
131 int data;
132 Stack *s;
133 InitStack(&s);
134
135 while(pnode != NULL || !StackEmpty(s))
136 {
137 if(pnode != NULL) {
138 Push(s, pnode->data);
139 pnode = pnode->lchild;
140 } else {
141 Pop(s, &data);
142 pnode = BT_GetNode(root, data);
143 BT_Visit(pnode);
144 pnode = pnode->rchild;
145 }
146 }
147 DestoryStack(s);
148 }
149
150 //要先判断当前节点是否存在右子树，如果存在，先打印右子树，所以，要设置一个tag，如果右子树已经在上次访问过了，
151 //那么就不用继续访问，可以直接打印当前节点。
152 void
153 BT_PostOrderNoRec(pNode root)
154 {
155 pNode pnode = root;
156 pNode pre = NULL;
157 int data;
158 Stack* s;
159 InitStack(&s);
160
161 while(pnode != NULL || !StackEmpty(s))
162 {
163 if(pnode != NULL) {
164 Push(s, pnode->data);
165 pnode = pnode->lchild;
166 } else {
167 Top(s, &data);
168 pnode = BT_GetNode(root, data);
169 if(pnode->rchild != NULL && pre != pnode->rchild)
170 pnode = pnode->rchild;
171 else {
172 BT_Visit(pnode);
173 Pop(s, &data);
174 pre = pnode;
175 pnode = NULL;
176 }
177 }
178 }
179 DestoryStack(s);
180 }
181
182 int
183 main(void)
184 {
185 int i;
186 pNode root = NULL;
187 BT_Insert(&root, 100);
188 BT_Insert(&root, 10);
189 BT_Insert(&root, 11);
190 BT_Insert(&root, 9);
191 BT_Insert(&root, 2);
192
193 printf("BT_PreOrderNoRec:\n");
194 BT_PreOrderNoRec(root);
195 printf("\n");
196
197 printf("BT_InOrderNoRec:\n");
198 BT_InOrderNoRec(root);
199 printf("\n");
200
201 printf("BT_PostOrderNoRec:\n");
202 BT_PostOrderNoRec(root);
203 printf("\n");
204 return 0;
205 }
