算法代码（转）

动态内存分配算法 

1. /* 工程名称： W32_Alloc */
2. /* Alloc.h */
3. #ifndef __ALLOC_H
4. #define __ALLOC_H
6. #include "Alloc.cpp"
8. #endif
9. /* Alloc.cpp */
10. typedef unsigned int WORD;
12. typedef enum { sUsed = 1, sFree = 0 } blk_state;
14. typedef struct mcb {
16. blk_state s; /* block state */
18. WORD *pBegin; /* begining of allocated address */
19. WORD *pEnd; /* ending of allocated address */
20. size_t size; /* allocated size */
22. struct mcb *next; 
23. struct mcb *prev;
24. } mcb_t; /* memory control block */
26. typedef struct {
27. mcb_t *blk_head; /* mcb linked-list head and tail */
28. mcb_t *blk_tail;
30. WORD *blk_free; /* free block ptr */
32. WORD *ptos; /* pointer of stack top */
34. size_t stack_size; /* stack size */
35. size_t used_size; /* used size */
37. } mcbc_t; /* memory control block container */
39. mcbc_t *c; /* global container */
41. inline mcbc_t *
42. init_container( WORD *ptos, int stack_size ) {
43. mcbc_t *ret = (mcbc_t *)malloc(sizeof(mcbc_t));
44. assert(ret);
46. ret->ptos = ptos;
48. ret->blk_head = (mcb_t *)0;
49. ret->blk_tail = (mcb_t *)0;
50. ret->blk_free = ptos;
52. ret->stack_size = stack_size;
53. ret->used_size = (int)0;
55. return ret;
56. }
58. inline void
59. bind_container( mcbc_t *con ) {
60. c = con;
61. }
63. inline void
64. throw_container( void ) {
65. mcb_t *p, *bak;
67. if(c) {
68. /* free linked-list */
69. p = c->blk_head;
70. while(p) {
71. bak = p->next;
72. free(p);
73. p = bak;
74. }
75. /* free container */
76. free(c);
77. c = (mcbc_t *)0;
78. }
79. }
81. inline void *
82. allocate( size_t size ) {
83. assert(c); /* ensure container has been binded */
85. size_t reminder = c->stack_size - c->used_size; /* calc reminder */
86. size_t split_size;
88. size_t ss;
89. mcb_t *p, *bak;
91. void *ret;
93. if(!size)
94. return (void *)0;
96. /* general size convert to stack offset */
97. if(!(size % sizeof(WORD)))
98. ss = size / sizeof(WORD);
99. else
100. ss = size / sizeof(WORD) + 1;
102. if( reminder < ss )
103. return (void *)0; /* not enough space for allocating */
105. if(!c->blk_head) {
107. /* no mcb in linked-list, create one */
108. p = (mcb_t *)malloc(sizeof(mcb_t));
109. assert(p);
111. ret = (void *)c->ptos;
113. c->blk_free += ss;
114. c->used_size += ss;
116. p->pBegin = c->ptos;
117. p->pEnd = c->blk_free;
118. p->s = sUsed;
119. p->size = size;
121. p->next = (mcb_t *)0;
122. p->prev = (mcb_t *)0;
124. c->blk_head = c->blk_tail = p;
126. return ret;
128. }
129. else {
130. /* find free block */
131. p = c->blk_head;
132. while(p) {
133. if(p->size >= ss && p->s == sFree) {
134. ret = (void *)p->pBegin;
136. /* p->size > ss, split it! */
137. if(p->size > ss) {
138. split_size = p->size - ss;
140. /* recalc end boundary */
141. p->pEnd = (WORD *)(p->pBegin + ss);
142. p->size = ss;
143. p->s = sUsed;
145. bak = (mcb_t *)malloc(sizeof(mcb_t));
146. assert(bak);
148. /* insert mcb */
149. bak->prev = p;
150. if(p->next) {
151. p->next->prev = bak;
152. bak->next = p->next;
153. }
154. else {
155. bak->next = (mcb_t *)0;
156. c->blk_tail = bak;
157. }
158. p->next = bak;
160. /* constructing a splited control block */
161. bak->pBegin = p->pEnd;
162. bak->pEnd = (WORD *)(bak->pBegin + split_size);
164. bak->size = split_size;
165. bak->s = sFree;
166. }
167. else
168. p->s = sUsed;
170. c->used_size += ss;
171. return ret;
172. }
173. p = p->next;
174. }
176. /* no matched block, create one at tail */
177. ret = (void *)c->blk_free;
179. c->blk_free += ss;
180. c->used_size += ss;
182. p = (mcb_t *)malloc(sizeof(mcb_t));
183. assert(p);
185. p->pBegin = (WORD *)ret;
186. p->pEnd = c->blk_free;
188. p->prev = c->blk_tail;
189. p->next = (mcb_t *)0;
191. p->size = ss;
192. p->s = sUsed;
194. c->blk_tail->next = p;
195. c->blk_tail = p;
197. return ret;
198. }
199. }
201. inline int
202. release( void *ptr ) {
203. assert(c);
205. mcb_t *p = (mcb_t *)0;
206. mcb_t *pLeft = (mcb_t *)0;
207. mcb_t *pRight = (mcb_t *)0;
209. p = c->blk_head;
210. while(p) {
211. /* free matched block */
212. if(p->pBegin == (WORD *)ptr) {
213. p->s = sFree;
214. c->used_size -= p->size;
216. /* merge free neighbours */
217. pLeft = p->prev;
218. pRight = p->next;
219. while( (pLeft && pLeft->s == sFree) || (pRight && pRight->s == sFree) ) {
220. /* merge left neighbour */
221. if(pLeft && pLeft->s == sFree) {
222. p->pBegin = pLeft->pBegin;
223. p->size += pLeft->size;
224. /* destory left neighbour */
225. p->prev = pLeft->prev;
226. if(pLeft->prev)
227. pLeft->prev->next = p;
228. else
229. c->blk_head = p;
230. free(pLeft);
231. }
233. /* merge right neighbour */
234. if(pRight && pRight->s == sFree) {
235. p->pEnd = pRight->pEnd;
236. p->size += pRight->size;
237. /* destory right neighbour */
238. p->next = pRight->next;
239. if(pRight->next)
240. pRight->next->prev = p;
241. else
242. c->blk_tail = p;
243. free(pRight);
244. }
246. /* reload neighbours */
247. pLeft = p->prev;
248. pRight = p->next;
249. }
250. /* on success */
251. return 0;
252. }
253. p = p->next;
254. }
255. /* no block matched */
256. return 1;
257. }
258. /* main.cpp */
259. #include <stdio.h>
260. #include <stdlib.h>
261. #include <string.h>
262. #include <conio.h>
263. #include <assert.h>
265. #include "Alloc.h"
267. WORD stk[8 * 1024]; /* 16Kbytes */
269. int main() {
270. char *s1,*s2,*s3;
271. mcbc_t *con = init_container(stk, 8*1024);
272. bind_container(con);
274. s1 = (char *)allocate(12);
275. s2 = (char *)allocate(4);
276. s3 = (char *)allocate(5);
277. strcpy(s1,"Hello,world");
278. strcpy(s2,"ABC");
279. strcpy(s3,"1234");
281. printf("%s,%s,%s\n",s1,s2,s3);
283. getch();
285. release((void *)s1);
286. release((void *)s2);
288. s1 = (char *)allocate(16);
289. strcpy(s1,"Hello,world,ABC");
291. printf("%s %s %s\n",s1,s2,s3);
293. getch();
295. release((void *)s1);
296. release((void *)s3);
298. throw_container();
300. return 0;
301. }

复制代码

A*算法

1. /* 工程名称： W32_AStar */
2. /* AStar.h */
3. /* 设计者： yuki */
5. #ifndef __ASTAR_H
6. #define __ASTAR_H
8. #define MAZE_WIDTH 10 /* 迷宫宽度 */
9. #define MAZE_HEIGHT 10 /* 迷宫高度 */
11. #define PATH_BLOCK 0 /* 障碍物 */
12. #define PATH_WALKON 1 /* 可行走 */
13. #define PATH_FOOTPRINT 2 /* 脚印 */
15. #include "AStar.cpp"
17. #endif
18. /* AStar.cpp */
19. /* 设计者： yuki */
21. typedef unsigned char byte_t;
22. typedef unsigned int uint_t;
24. /* 路径节点 */
25. typedef struct footprint {
27. /* 存放在数组中的位置 */
28. uint_t pos;
30. /* 存放方向信号量 */
31. byte_t direct;
33. struct footprint *next;
34. struct footprint *prev;
36. } path_t;
39. /*
40. 方向信号量查询表
41. 0x01(0000 0001) : 上
42. 0x02(0000 0010) : 下
43. 0x04(0000 0100) : 左
44. 0x08(0000 1000) : 右
45. */
47. static byte_t d_signal[4] = {0x01, 0x02, 0x04, 0x08};
49. /*
50. 方向信号量使用表
51. 如果指定方向已经走过，那么使用“与”运算去处该方向
52. 0x0E(0000 1110) : 上
53. 0x0D(0000 1101) : 下
54. 0x0B(0000 1011) : 左
55. 0x07(0000 0111) : 右
56. */
58. static byte_t d_spend[4] = {0x0E, 0x0D, 0x0B, 0x07};
60. /* 指定方向移动偏量 */
61. static int move[4][2] = { {0, -1}, {0, 1}, {-1, 0}, {1, 0} };
63. /* 打印迷宫用的符号 */
64. static byte_t symbolic[3] = {'#',0x20,'*'};
66. /* 求两点间的距离 */
67. inline uint_t
68. distance( uint_t pos1X, uint_t pos1Y, uint_t pos2X, uint_t pos2Y ) {
70. uint_t ret = 0;
72. /* 距离公式 */
73. ret = (uint_t)sqrt((pow((double)((int)pos1X - (int)pos2X),2) + pow((double)((int)pos1Y - (int)pos2Y),2)));
75. return ret;
77. }
79. /* 压缩坐标 */
80. inline uint_t
81. create_pos( uint_t pX, uint_t pY ) {
82. uint_t ret = 0;
83. /* 将pX赋给ret，这样pX坐标在ret的低八位 */
84. ret = pX;
86. /* 将pX坐标移到高八位去，这样低位就能存放pY */
87. ret <<= 8;
88. /* 将pY存放放到ret的低八位，并保持高八位的数据不变 */
89. ret |= pY;
91. return ret;
92. }
94. /*
95. == 估计函数 ===========================================
96. -p : 当前移动到的节点指针
97. -quit_x
98. -quit_y : quit_x 和 quit_y表示迷宫出口坐标
99. -maze : 迷宫矩阵
100. =======================================================
101. */
102. inline path_t *
103. evaluate( path_t *p, uint_t quit_x, uint_t quit_y, byte_t maze[MAZE_HEIGHT][MAZE_WIDTH] ) {
104. uint_t pX, pY;
106. /* 用于接收四个方向离开出口的距离，以便选择最近的方向移动 */
107. int dis[4];
108. int minDis = 32767;
109. int minId = -1;
111. path_t *pnode = (path_t *)0;
113. register int i;
115. /* 计算当前节点的坐标 */
116. pX = p->pos >> 8;
117. pY = p->pos & 0x00FF;
119. memset(dis, (int)-1, sizeof(int)*4);
121. /* 计算每个方向离开出口的距离，一次存放到dis数组，若没有i方向，则dis[i]任保留-1 */
122. for( i = 0; i < 4; ++i ) {
123. if( (p->direct & d_signal[i]) >> i == 0x01 )
124. dis[i] =(int)distance(pX + move[i][0], pY + move[i][1], quit_x, quit_y);
125. }
127. /* 获得最短距离的方向 */
128. for(i = 0; i < 4; ++i) {
129. if(dis[i] != -1 && dis[i] < minDis) {
130. minId = i;
131. minDis = dis[i];
132. }
133. }
135. /* 若没有可用的方向，则通知寻径函数折回 */
136. if(minId == -1)
137. return (path_t *)0;
139. /* 用去最近距离方向的信号量 */
140. p->direct &= d_spend[minId];
141. /* 在移动到新位置之前，在旧位置处留下足迹 */
142. maze[pY][pX] = (byte_t)PATH_FOOTPRINT;
144. /* 构建新的路径节点 */
145. pnode = (path_t *)malloc(sizeof(path_t));
146. assert(pnode);
148. /* 计算下一个位置的坐标 */
149. pX += move[minId][0];
150. pY += move[minId][1];
152. pnode->pos = create_pos(pX, pY);
153. pnode->prev = p;
154. pnode->next = (path_t *)0;
155. pnode->direct = 0;
157. /* 在新位置处，计算下一个位置可用的移动方向 */
158. for(i = 0; i < 4; ++i) {
159. if(maze[pY + move[i][1]][pX + move[i][0]] != PATH_BLOCK && maze[pY + move[i][1]][pX + move[i][0]] != PATH_FOOTPRINT) {
160. /* 若尝试的下一个位置不是障碍物或自己走过的足迹，则视为可用方向，获得该方向的信号量 */
161. pnode->direct |= d_signal[i];
162. }
163. }
165. return pnode;
167. }
169. /*
170. == A*算法寻径函数 ===========================================
171. -eX
172. -eY :入口坐标
173. -qX
174. -qY :出口坐标
175. -maze :迷宫矩阵
176. =============================================================
177. */
179. inline path_t *
180. AStar(uint_t eX, uint_t eY, uint_t qX, uint_t qY, byte_t maze[MAZE_HEIGHT][MAZE_WIDTH]) {
181. register int i;
183. /* 压缩坐标 */
184. uint_t quit_pos = create_pos(qX, qY);
186. /* 构建入口路径节点，视为路径链的头 */
187. path_t *head = (path_t *)malloc(sizeof(path_t));
188. path_t *p = (path_t *)0;
189. path_t *back = (path_t *)0;
190. assert(head);
192. p = head;
193. p->direct = 0;
194. p->pos = create_pos(eX,eY);
195. p->next = (path_t *)0;
196. p->prev = (path_t *)0;
198. /* 创建入口处的可用方向 */
199. for(i = 0; i < 4; ++i) {
200. if(maze[eY + move[i][1]][eX + move[i][0]] != PATH_BLOCK)
201. /* 若无障碍物则获得该方向的信号量 */
202. p->direct |= d_signal[i];
203. }
205. do {
207. /* 获得下个路径的节点指针 */
208. back = evaluate(p, qX, qY, maze);
209. if(back) {
210. p->next = back;
211. p = p->next;
212. }
214. /* 无路可走则折回 */
215. if(p->direct == 0 && p != head && p->pos != quit_pos) {
216. back = p->prev;
217. back->next = (path_t *)0;
219. /* 清楚脚印 */
220. maze[p->pos & 0x00FF][p->pos >> 8] = (byte_t)PATH_WALKON;
222. free(p);
223. p = back;
224. }
226. /* 若走不出迷宫，即折回到入口，且入口处的可用方向全部尝试过 */
227. if(p == head && p->direct == 0) {
228. free(head);
229. return (path_t *)0;
230. }
232. } while( p->pos != quit_pos );
234. /* 在出口处留下脚印，便于打印 */
235. maze[p->pos & 0x00FF][p->pos >> 8] = (byte_t)PATH_FOOTPRINT;
237. return head;
239. }
240. /* main.cpp */
241. /* 设计者： yuki */
243. #include <stdio.h>
244. #include <stdlib.h>
245. #include <string.h>
246. #include <conio.h>
247. #include <math.h>
248. #include <assert.h>
250. #include "AStar.h"
252. static byte_t maze[MAZE_HEIGHT][MAZE_WIDTH] = { 
253. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
254. 0, 1, 1, 0, 1, 1, 1, 0, 1, 0,
255. 0, 1, 1, 0, 1, 1, 1, 0, 1, 0,
256. 0, 1, 1, 1, 1, 0, 0, 0, 1, 0,
257. 0, 1, 0, 0, 0, 1, 1, 0, 1, 0,
258. 0, 1, 1, 1, 0, 1, 1, 0, 1, 0,
259. 0, 1, 0, 1, 1, 1, 0, 1, 1, 0,
260. 0, 1, 0, 0, 0, 1, 0, 0, 1, 0,
261. 0, 0, 1, 1, 1, 1, 1, 1, 1, 0,
262. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
263. };
265. int main() {
266. register int i,j;
268. path_t *pHead = AStar((uint_t)1,(uint_t)1,(uint_t)2,(uint_t)8,maze);
269. path_t *p = pHead;
270. path_t *bak;
271. if(p) {
272. bak = p->next;
273. printf("(%u,%u)",p->pos >> 8, p->pos & 0x00FF);
274. free(p);
275. p = bak;
276. while(p) {
277. bak = p->next;
278. printf("->(%u,%u)",p->pos >> 8, p->pos & 0x00FF);
279. free(p);
280. p = bak;
281. }
282. printf("\n");
283. }
284. else
285. printf("No path to get out of the maze\n");
287. pHead = p = bak = (path_t *)0;
289. /* 打印迷宫 */
290. for(i = 0; i < MAZE_HEIGHT; ++i) {
291. for(j = 0; j < MAZE_WIDTH; ++j)
292. printf("%c",symbolic[maze[i][j]]);
293. printf("\n");
294. }
296. getch();
298. return 0;
299. }

复制代码

表达式计算器

1. /* 工程名称： W32_Expr */
2. /* Expr.h */
3. #ifndef __EXPR_H
4. #define __EXPR_H
6. #define TRUE 0x01
7. #define FALSE 0x00
9. #define OP_PRIOR_LESS_TO 0x00
10. #define OP_PRIOR_GREATER_THAN 0x01
11. #define OP_PRIOR_EQUAL_TO 0x02
13. #define STACK_SIZE 64
14. #define BUFFER_SIZE 16
16. #include "Expr.cpp"
18. #endif
19. /* Expr.cpp */
20. typedef unsigned char op_prior_t;
21. typedef unsigned char bool_t;
22. typedef int stack_t;
24. /* is an operator ? */
25. inline bool_t
26. is_opr(char c) {
27. switch(c) {
28. case '+':
29. case '-':
30. case '*':
31. case '/':
32. case '(':
33. case ')':
34. return (bool_t)TRUE;
35. default:
36. return (bool_t)FALSE;
37. }
38. }
40. /* calc two oprands */
41. inline int
42. calc_oprand(int opr1, int opr2, char op) {
43. switch(op) {
44. case '+':
45. return opr1 + opr2;
46. case '-':
47. return opr1 - opr2;
48. case '*':
49. return opr1 * opr2;
50. case '/':
51. assert(opr2);
52. return opr1 / opr2;
53. default:
54. return -1;
55. }
56. }
58. /* get prior of operator */
59. inline op_prior_t
60. get_op_prior(char op) {
61. switch(op) {
62. case '+':
63. case '-':
64. return 0;
65. case '*':
66. case '/':
67. return 1;
68. default:
69. return 0xFF;
70. }
71. }
73. inline int
74. cmp_op(char op1, char op2) {
75. op_prior_t pop1 = get_op_prior(op1);
76. op_prior_t pop2 = get_op_prior(op2);
78. assert(pop1 != 0xFF);
79. assert(pop2 != 0xFF);
81. if(pop1 > pop2)
82. return OP_PRIOR_GREATER_THAN;
83. else if(pop1 < pop2)
84. return OP_PRIOR_LESS_TO;
85. else
86. return OP_PRIOR_EQUAL_TO;
87. }
89. /* string length */
90. inline int
91. strl(char *str) {
92. char *p = str;
93. while(*p++);
94. return (int)(p - str - 1);
95. }
97. /* 10^n */
98. inline int
99. pow_ten_n(int n) {
100. int ret = 1;
101. while(n > 0) {
102. ret *= 10;
103. --n;
104. }
105. return ret;
106. }
108. /* convert string to integer */
109. inline int
110. str_to_int(char *str) {
111. int ret = 0;
112. int i = 0;
113. int len = strl(str);
115. if(*str == '-' || *str == '+') {
116. ++i;
117. --len;
118. }
120. while(len > 0) {
121. ret += (*(str + i) - '0') * pow_ten_n(len-1);
122. ++i;
123. --len;
124. }
126. if(*str == '-')
127. return (-1) * ret;
128. return ret;
129. }
131. inline int
132. calc_expr(char *exp) {
133. /* test express whether it is vaild */
134. assert(exp);
136. /* stack of oprands */
137. stack_t stk_opr[STACK_SIZE];
138. /* stack of operators */
139. stack_t stk_op[STACK_SIZE];
141. /* oprand1 & oprand2 */
142. int opr1 = 0;
143. int opr2 = 0;
145. int cmp_ret;
147. /* buffer */
148. char buffer[BUFFER_SIZE];
150. /* expression length */
151. int len = strl(exp);
153. /* counters */
154. register int i,j;
156. /* stack pointer */
157. stack_t *pOpr = stk_opr;
158. stack_t *pOp = stk_op;
160. /* initialize buffer & stacks */
161. memset(buffer, (char)0, sizeof(char) * BUFFER_SIZE);
162. memset(stk_opr,(stack_t)0,sizeof(stack_t) * STACK_SIZE);
163. memset(stk_op, (stack_t)0,sizeof(stack_t) * STACK_SIZE);
165. /* get the first value */
166. if(is_opr(*exp) && (*exp == '+' || *exp == '-')) {
167. *buffer = *exp;
168. i = 1;
169. j = 1;
170. }
171. else {
172. i = 0;
173. j = 0;
174. }
176. while(!is_opr(exp[i]))
177. buffer[j++] = exp[i++];
178. if(i > 0) {
179. /* push the first oprand to oprands stack */
180. *pOpr = str_to_int(buffer);
181. /* clean up buffer */
182. memset(buffer, (char)0, sizeof(char) * BUFFER_SIZE);
183. /* reset buffer pointer 'j' */
184. j = 0;
185. }
187. /* push the first operator */
188. if(exp[i] != '\0')
189. *pOp = exp[i++];
191. while(exp[i]) {
192. /* if exp[i] is not an operator, than get the value */
193. if(!is_opr(exp[i])) {
194. while(!is_opr(exp[i]) && exp[i] != '\0')
195. buffer[j++] = exp[i++];
196. ++pOpr;
197. *pOpr = str_to_int(buffer);
198. memset(buffer, (char)0, sizeof(char) * BUFFER_SIZE);
199. j = 0;
200. }
201. else {
202. if(exp[i] == '(') {
203. ++pOp;
204. *pOp = exp[i++];
205. }
206. else if(exp[i] != ')') {
207. if(*pOp != '(') {
208. cmp_ret = cmp_op(*pOp,exp[i]);
209. if(cmp_ret == OP_PRIOR_GREATER_THAN || cmp_ret == OP_PRIOR_EQUAL_TO) {
210. /* pop two oprands to calc and than push the result to the stack */
211. opr2 = *pOpr--;
212. opr1 = *pOpr;
213. *pOpr = calc_oprand(opr1,opr2,*pOp);
215. /* push the low priority operator */
216. *pOp = exp[i++];
217. }
218. else if(cmp_ret == OP_PRIOR_LESS_TO) {
219. /* push the high priority operator */
220. ++pOp;
221. *pOp = exp[i++];
222. }
223. }
224. else {
225. ++pOp;
226. *pOp = exp[i++];
227. }
228. }
229. else {
230. /* loop until a ')' matched with */
231. while(*pOp != '(') {
232. opr2 = *pOpr--;
233. opr1 = *pOpr;
234. *pOpr = calc_oprand(opr1,opr2,*pOp);
236. /* pop the operator */
237. *pOp-- = (char)0;
239. if(pOp == stk_op && *pOp != '(') {
240. printf("No '(' matched in expression!\n");
241. getch();
242. exit(1);
243. }
244. }
245. /* pop the '(',and let the expression move on */
246. if(pOp > stk_op)
247. *pOp-- = (char)0;
248. else
249. *pOp = (char)0;
250. ++i;
251. }
252. }
253. }
254. while(pOp >= stk_op) {
255. opr2 = *pOpr--;
256. opr1 = *pOpr;
257. *pOpr = calc_oprand(opr1,opr2,*pOp);
258. *pOp-- = (char)0;
259. }
260. return *stk_opr;
261. }
262. /* main.cpp */
263. #include <stdio.h>
264. #include <stdlib.h>
265. #include <assert.h>
266. #include <conio.h>
267. #include <string.h>
269. #include "Expr.h"
271. int main() {
272. char exp[80];
273. printf("Input an expression\n");
274. gets(exp);
275. printf("= %d\n",calc_expr(exp));
277. getch();
278. return 0;
279. }

复制代码

广义表的演示

1. /* 工程名称： W32_GList */
2. /* GList.h */
3. #ifndef __GLIST_H
4. #define __GLIST_H
6. #include "Glist.cpp"
8. #endif
9. /* GList.cpp */
10. #define NODE_ELEMENT 0x00
11. #define NODE_LIST 0x01
13. typedef unsigned char node_type_t;
14. typedef unsigned int index_t;
16. typedef struct {
17. index_t id_x;
18. index_t id_y;
19. } locator_t; 
21. typedef struct GList {
22. node_type_t lst_type;
23. char *menu;
24. int item_count;
26. union {
27. locator_t loc;
28. struct GList *sub_list;
29. } data_item;
30. struct Glist *next;
31. } list_t;
33. static char *description[3][2] = { "Black Eyes", "Blue Eyes" ,
34. "Tall Body" , "Short Body" ,
35. "Fat Body" , "Thin Body" 
36. };
38. static char *meu_list[] = {"== Describe yourself ==\n1. Eye\n2. Height\n3. Figure\n0. Exit\nMake your choice : ",
39. "== Your eye color ==\n1. Black\n2. Blue\n0. Exit\nMake your choice : " ,
40. "== Your height ==\n1. Tall\n2. Short\n0. Exit\nMake your choice : " ,
41. "== Your figure ==\n1. Fat\n2. Thin\n0. Exit\nMake your choice : " 
42. };
44. list_t *dialog_sheet = (list_t *)0;
45. list_t *static_dialog_sheet[4];
47. char image[256] = "You have ";
49. inline list_t *
50. create_glist( void ) {
51. register int i,j;
53. list_t *ret = (list_t *)malloc(sizeof(list_t));
54. list_t *p;
55. list_t *q;
57. /* create the first sheet */
58. ret->lst_type = NODE_LIST;
59. ret->menu = meu_list[0];
60. ret->item_count = 4;
61. ret->data_item.sub_list = (list_t *)0;
63. p = ret;
64. for(i = 1; i < 4; ++i) {
65. p->next = (struct Glist *)malloc(sizeof(list_t));
66. p = (list_t *)p->next;
67. p->menu = meu_list[i];
68. p->lst_type = NODE_LIST;
69. p->item_count = 3;
70. }
72. p->next = (struct Glist *)0;
73. p = (list_t *)ret->next;
74. i = 0;
75. j = 0;
77. while(p) {
79. p->data_item.sub_list = (list_t *)malloc(sizeof(list_t));
80. q = p->data_item.sub_list;
82. q->lst_type = NODE_ELEMENT;
83. q->data_item.loc.id_x = (index_t)i;
84. q->data_item.loc.id_y = (index_t)j++;
86. q->next = (struct Glist *)malloc(sizeof(list_t));
87. q = (list_t *)q->next;
88. q->lst_type = NODE_ELEMENT;
89. q->data_item.loc.id_x = (index_t)i++;
90. q->data_item.loc.id_y = (index_t)j;
91. q->next = (struct Glist *)0;
93. j = 0;
95. p = (list_t *)p->next;
96. }
98. return ret;
99. }
101. inline void
102. destory_list(list_t *lst) {
103. list_t *p = lst;
104. list_t *q = (list_t *)0;
106. while(p) {
107. if(p->lst_type == NODE_LIST) {
108. q = (list_t *)p->data_item.sub_list;
109. if(q)
110. destory_list(q);
111. }
112. q = (list_t *)p->next;
113. free(p);
114. p = q;
115. }
116. }
118. inline void
119. init_dialog_sheet() {
120. list_t *p;
121. register int i = 0;
123. dialog_sheet = create_glist();
124. p = dialog_sheet;
125. while(p) {
126. static_dialog_sheet[i++] = p;
127. p = (list_t *)p->next;
128. }
129. }
131. inline void
132. debug() {
133. list_t *p = (list_t *)dialog_sheet->next;
134. list_t *q;
135. while(p) {
136. q = (list_t *)p->data_item.sub_list;
137. printf("(%d,%d)",q->data_item.loc.id_x , q->data_item.loc.id_y);
138. q = (list_t *)q->next;
139. printf(",(%d,%d)\n",q->data_item.loc.id_x,q->data_item.loc.id_y);
140. p = (list_t *)p->next ;
141. }
142. }
144. inline void 
145. main_menu() {
146. int c;
148. list_t *p = static_dialog_sheet[0];
149. do {
150. printf("%s",p->menu);
151. scanf("%d",&c);
152. if(c >= 1 && c <= 3 ) {
153. p = static_dialog_sheet[c];
154. do { /* sub menu */
155. printf("%s",p->menu);
156. scanf("%d",&c);
157. if(c == 0) {
158. c = 1;
159. break;
160. }
161. else if(c == 1) {
162. p = p->data_item.sub_list;
163. strcat(image, description[p->data_item.loc.id_x][p->data_item.loc.id_y]);
164. strcat(image, " ");
165. p = static_dialog_sheet[0];
166. break;
167. }
168. else if(c == 2) {
169. p = (list_t *)p->data_item.sub_list->next;
170. strcat(image, description[p->data_item.loc.id_x][p->data_item.loc.id_y]);
171. strcat(image, " ");
172. p = static_dialog_sheet[0];
173. break;
174. }
175. } while( c != 0 );
176. }
177. } while( c != 0 );
179. if(strlen(image) == 9)
180. printf("You have nothing!\n");
181. else
182. printf("%s\n", image);
183. }
184. /* main.cpp */
185. #include <stdio.h>
186. #include <stdlib.h>
187. #include <string.h>
188. #include <dos.h>
189. #include <conio.h>
191. #include "Glist.h"
193. int main() {
194. init_dialog_sheet();
195. main_menu();
196. destory_list(dialog_sheet);
197. getch();
198. return 0;
199. }

复制代码

赫夫曼自动编码

2. /* 工程名称： W32_Huffman */
3. /* Huffman.h */
4. #ifndef __HUFFMAN_H
5. #define __HUFFMAN_H
6. #include "huffman.cpp"
7. #endif
8. /* Huffman.cpp */
9. typedef unsigned int uint_t;
10. typedef struct huffman {
11. uint_t weight; /* 权值 */
12. struct huffman *lchild;
13. struct huffman *rchild;
14. } HuffmanTreeNode, *PHuffmanNode;
15. typedef struct lnklst {
16. PHuffmanNode HNode; /* 赫夫曼树 */
17. struct lnklst *next;
18. struct lnklst *prev;
19. } LnkListNode, *PLnkListNode;
20. typedef struct {
21. uint_t count; /* 树的棵数 */
22. PLnkListNode head; /* 链表结构，表示一行赫夫曼树 */
23. PLnkListNode tail;
24. } LnkList;
25. /* ===================================================================================================================== */
26. inline PHuffmanNode
27. create_huffman_node( uint_t weight ) {
28. PHuffmanNode node = (PHuffmanNode)malloc(sizeof(HuffmanTreeNode));
29. assert(node);
30. /* 确保权值有效 */
31. assert(weight > (uint_t)0);
32. /* 使用传入的权值初始化赫夫曼结点 */
33. node->weight = weight;
34. node->lchild = (PHuffmanNode)0;
35. node->rchild = (PHuffmanNode)0;
37. return node;
38. }
39. inline PLnkListNode
40. create_lnklst_node( PHuffmanNode node ) {
41. PLnkListNode lstNode = (PLnkListNode)malloc(sizeof(LnkListNode));
42. assert(lstNode);
43. /* 初始化链表结点 */
44. lstNode->HNode = node;
45. lstNode->next = (PLnkListNode)0;
46. lstNode->prev = (PLnkListNode)0;
47. return lstNode;
48. }
49. inline void
50. add_to_lnklist( LnkList *lst, PLnkListNode lstNode ) {
51. /* 却保lstNode有效 */
52. assert(lstNode); 
54. /* 第一次添加结点 */
55. if(!lst->head) {
56. lst->head = lstNode;
57. lst->tail = lstNode;
58. lst->count = (uint_t)1;
59. }
60. else {
61. lst->tail->next = lstNode;
62. lstNode->prev = lst->tail;
63. lst->tail = lstNode;
64. ++lst->count;
65. }
66. }
67. inline void
68. remove_from_lnklist( LnkList *lst, PLnkListNode lstNode ) {
69. /* 辅助结点 */
70. PLnkListNode pnode = (PLnkListNode)0;
72. assert(lstNode);
73. /* 如果结点为链表头 */
74. if(lstNode == lst->head) {
75. pnode = lstNode->next;
76. pnode->prev = (PLnkListNode)0;
77. lst->head = pnode;
78. --lst->count;
79. free(lstNode);
80. }
81. /* 如果是两表尾部 */
82. else if(lstNode == lst->tail) {
83. pnode = lstNode->prev;
84. pnode->next = (PLnkListNode)0;
85. lst->tail = pnode;
86. --lst->count;
87. free(lstNode);
88. }
89. else {
90. pnode = lstNode->next;
91. pnode->prev = lstNode->prev;
92. lstNode->prev->next = pnode;
93. --lst->count;
94. free(lstNode);
95. } 
96. }
97. inline void
98. find_and_insert( LnkList *lst, PLnkListNode plst ) {
99. /* 根据赫夫曼树的节点权值，插入链表的适当位置 */
100. PLnkListNode pcur = (PLnkListNode)0;
101. if(!lst->head) 
102. add_to_lnklist(lst,plst);
103. else {
104. pcur = lst->head;
105. while(pcur) {
106. if(plst->HNode->weight >= pcur->HNode->weight) {
107. if(pcur->next && plst->HNode->weight <= pcur->next->HNode->weight) {
108. plst->prev = pcur;
109. plst->next = pcur->next;
110. pcur->next->prev = plst;
111. pcur->next = plst;
112. ++lst->count;
113. break;
114. }
115. else if(!pcur->next) {
116. add_to_lnklist(lst, plst);
117. break;
118. }
119. }
120. pcur = pcur->next;
121. }
122. }
123. }
124. /* ===================================================================================================================== */
125. inline void
126. swap_lnklst_node( PLnkListNode lstNode1, PLnkListNode lstNode2 ) {
127. PHuffmanNode pnode = (PHuffmanNode)0;
128. assert(lstNode1 && lstNode2);
129. /* 交换链表内容 */
130. pnode = lstNode1->HNode;
131. lstNode1->HNode = lstNode2->HNode;
132. lstNode2->HNode = pnode;
133. }
134. inline void
135. select_sort( LnkList *lst ) {
136. /* 根据权值做一个从小到大的选择排序 */
137. PLnkListNode cmp_node = lst->head;
138. PLnkListNode p;
139. assert(cmp_node);
140. while(cmp_node) {
141. p = cmp_node->next;
142. while(p) {
143. /* 如果目标位置权值比比较位置的权值小，则将它们交换 */
144. if(p->HNode->weight < cmp_node->HNode->weight)
145. swap_lnklst_node(cmp_node,p);
146. p = p->next;
147. }
148. cmp_node = cmp_node->next;
149. }
150. }
151. /* ===================================================================================================================== */
152. inline PHuffmanNode 
153. merge_tree( PHuffmanNode root1, PHuffmanNode root2 ) {
154. /* 合并两棵赫夫曼树，并返回合并后新树根的指针 */
155. PHuffmanNode retRoot = (PHuffmanNode)0;
157. assert(root1 && root2);
159. /* 创建一棵合并后的赫夫曼树 */
160. retRoot = create_huffman_node(root1->weight + root2->weight);
162. retRoot->lchild = root1;
163. retRoot->rchild = root2;
165. return retRoot;
166. }
167. inline void
168. destory_tree( PHuffmanNode root ) {
169. /* 销毁一棵树 */
170. PHuffmanNode plchild, prchild;
171. if(root) {
172. plchild = root->lchild;
173. prchild = root->rchild;
174. free(root);
175. root = (PHuffmanNode)0;
176. destory_tree(plchild);
177. destory_tree(prchild);
178. }
179. }
180. /* ===================================================================================================================== */
181. inline void
182. convert_to_lnklst( LnkList *lst, uint_t Wi[], uint_t size ) {
183. /* 将权值数组转换成赫夫曼树并添加到链表 */
184. PLnkListNode plstnode = (PLnkListNode)0;
185. PHuffmanNode phufnode = (PHuffmanNode)0;
186. register uint_t i;
187. for(i = 0; i < size; ++i) {
188. phufnode = create_huffman_node(Wi[i]);
189. plstnode = create_lnklst_node(phufnode);
190. add_to_lnklist(lst,plstnode);
191. }
192. /* 排序链表 */
193. select_sort(lst);
194. }
195. inline PHuffmanNode
196. Huffman_code( uint_t Wi[], uint_t size) {
197. /* 根据权值数组进行赫夫曼编码，并返回赫夫曼树的树根 */
198. LnkList lst;
199. PLnkListNode p1,p2,pnode;
200. PHuffmanNode phnode;
201. /* 初始化链表 */
202. lst.count = (uint_t)0;
203. lst.head = (PLnkListNode)0;
204. lst.tail = (PLnkListNode)0;
205. /* 转换链表 */
206. convert_to_lnklst(&lst, Wi, size);
208. /* 开始合并树 */
209. while(lst.count > 1) {
210. /* 取两棵根权值最小的树进行合并，并将合并结果写入链表 */
211. p1 = lst.head;
212. p2 = lst.head->next;
213. /* 合并两树 */
214. phnode = merge_tree(p1->HNode, p2->HNode);
215. /* 为该树创建一个链表节点 */
216. pnode = create_lnklst_node(phnode);
217. /* 将新树添加入链表 */
218. find_and_insert(&lst,pnode);
219. /* 删除旧树的两个链表节点 */
220. remove_from_lnklist(&lst,p1);
221. remove_from_lnklist(&lst,p2);
222. }
223. /* 工作完成删除链表 */
224. /* 首先获取创建的赫夫曼树的根便于返回 */
225. phnode = lst.head->HNode;
226. pnode = lst.head;
227. while(pnode) {
228. p1 = pnode->next;
229. free(pnode);
230. pnode = p1;
231. }
232. lst.head = lst.tail = (PLnkListNode)0;
233. return phnode;
234. }
235. inline void
236. PreOrderTraverse( PHuffmanNode root, uint_t pos, char code[]) {
237. if(root) {
238. if(!root->lchild && !root->rchild)
239. printf("%u is coded to %s\n",root->weight, code);
240. code[pos] = '0';
241. PreOrderTraverse(root->lchild, pos+1, code);
242. code[pos] = '1';
243. PreOrderTraverse(root->rchild, pos+1, code); 
244. }
245. }
246. /* main.cpp */
247. #include <stdio.h>
248. #include <stdlib.h>
249. #include <string.h>
250. #include <assert.h>
251. #include <conio.h>
252. #include "huffman.h"
253. int main() {
254. uint_t n = 0;
255. uint_t *Wi = (uint_t *)0;
256. register uint_t i;
257. char buf[80];
258. PHuffmanNode HuffmanTree;
259. memset(buf,(char)0,80 * sizeof(char));
260. printf("How many weight you wanna import ( 1...65535 ) ? ");
261. scanf("%u",&n);
263. Wi = (uint_t *)malloc(n * sizeof(uint_t));
264. assert(Wi);
265. printf("Input weights in turn \n");
266. for(i = 0; i < n; ++i)
267. scanf("%u",&Wi[i]);
269. HuffmanTree = Huffman_code(Wi, n);
270. PreOrderTraverse(HuffmanTree,0,buf);
271. getch();
272. destory_tree(HuffmanTree);
273. free(Wi);
274. return 0;
275. }

复制代码

KMP模式匹配算法（不用next函数）

1. /* 工程名称： W32_KMP */
2. /* main.cpp */
3. #include <stdio.h>
4. #include <conio.h>
6. inline int KMP(char *s,char *p);
8. int main() {
9. char *s1 = "abacabcdabbab";
10. char *s2 = "abc";
11. printf("index = %d\n",KMP(s1,s2));
12. getch();
13. return 0;
14. }
16. /************************************************
17. *
18. * 函数名： KMP
19. *
20. * 参数表： s - 主串的指针； p - 模式串的指针
21. *
22. * 功能介绍： 比较p是否为s的子串，若是则返回在
23. * s中起始的索引号。
24. *
25. ************************************************/
27. inline int 
28. KMP(char *s, char *p) {
29. char *ptr_s = s; /* 映射字符串指针s */
30. char *ptr_p = p; /* 映射字符串指针p */
31. char *ptr_bak = s; /* 用于定位在*ptr_s与*p内容相同的位置 */
33. int addr_delta; /* 计算相匹配的内容长度，调整ptr_p对比起始位置 */
35. while(*ptr_s && *ptr_p) {
36. if(*ptr_s == *ptr_p) {
37. /* 如果匹配字符与对比串的首字符相等，则备份该指针 */
38. if(*ptr_s == *p)
39. ptr_bak = ptr_s;
40. ++ptr_s;
41. ++ptr_p;
42. }
43. else {
44. /* 计算新位置与备份指针的差，这便是以匹配的字符数，从而使p+addr_delta获得开始匹配的起始位置 */
45. addr_delta = (int)(ptr_s - ptr_bak);
46. /* 若备份位置与当前位置相同，则将当前位置一下下一个位置，从头开始比较 */
47. if(!addr_delta) {
48. ++ptr_s;
49. ptr_bak = ptr_s;
50. ptr_p = p;
51. }
52. else {
53. ptr_p = p + addr_delta;
54. /* 若备份位置与模式串的首位置都不匹配当前位置的字符串，则继续向后比较，重设备份位置和匹配位置 */
55. if(*ptr_p != *ptr_s && *p != *ptr_s) {
56. ++ptr_s;
57. ptr_bak = ptr_s;
58. ptr_p = p;
59. }
60. else {
61. /* 若备份位置与当前位置字符不匹但与模式串首字符相匹，则重设匹配位置和备份位置 */
62. if(*p == *ptr_s) {
63. ptr_p = p;
64. ptr_bak = ptr_s;
65. }
66. }
67. }
68. }
69. }
70. if(*ptr_p)
71. return -1;
72. else
73. /* 计算索引 */
74. return (int)((ptr_s - s) - (ptr_p - p));
75. }

复制代码

一元多项式加减乘

1. /* 工程名称： W32_Polynomial */
2. /* Polynomial.h */
3. #ifndef __POLYNOMIAL_H
4. #define __POLYNOMIAL_H
6. #define TRUE 0x01
7. #define FALSE 0x00
9. /* 错误代码 */
10. #define ERR_ON_SUCCESS 0x00 /* 没有错误 */
11. #define ERR_STACK_OVERRUN 0x01 /* 堆栈溢出 */
12. #define ERR_ITEM_EXIST 0x02 /* 欲添加项已存在 */
13. #define ERR_PTR_INVAILD 0x04 /* 无效的指针传入 */
14. #define ERR_LNKLST_INVAILD 0x08 /* 无效的链表 */
15. #define ERR_ACTCODE_INVAILD 0x10 /* 无效的操作码 */
16. #define ERR_ADD_IMPOSSIBLE 0x20 /* 无法做加运算 */
17. #define ERR_SUB_IMPOSSIBLE 0x40 /* 无法做减运算 */
18. #define ERR_EMPTY_POLY 0x80 /* 多项式链表为空 */
19. #define ERR_UNKNOWN 0xff /* 位置错误 */
21. /* 操作码 */
22. #define ACT_ADD 0x01 /* 多项式加 */
23. #define ACT_SUB 0x02 /* 多项式减 */
24. #define ACT_MUP 0x03 /* 多项式乘 */
26. /* 嵌入式功能配置常数 */
27. #define AUTO_DESTORY_EXIST FALSE /* 欲插入的项已存在时，自动删除创建的项 */
28. #define CHK_PARAMETER_PTR TRUE /* 检查作为参数传入的指针是否有效 */
29. #define RAISE_ERR TRUE /* 错误报告函数 */
30. #define CRITICAL_ABORT TRUE /* 错误异常中断 */
31. #define COPY_LNKLST TRUE /* 链表复制函数 */
32. #define SIMPLE_OUTPUT TRUE /* 简单的多项式输出函数 */
33. #define SIMPLE_INPUT TRUE /* 简单的多项式输入函数 */
35. #define EPSILON 1E-6 /* 极小值定义，用于浮点数趋近比较 */
37. #include "Polynomial.cpp"
39. #endif
40. /* Polynomial.cpp */
41. typedef struct Polynomial { 
42. float p; 
43. int e; 
44. struct Polynomial *next; 
45. struct Polynomial *prev; 
46. } poly;
48. typedef struct {
49. poly *head; 
50. poly *tail; 
51. int length;
52. } poly_lnklst;
54. typedef unsigned int uint;
56. #if RAISE_ERR == TRUE
57. inline void
58. raise_err(uint err) {
59. switch(err) {
60. case ERR_STACK_OVERRUN:
61. printf("Error %#x : Stack overrun\n", err);
62. break;
63. case ERR_ITEM_EXIST:
64. printf("Error %#x : Item is already exist\n",err);
65. break;
66. case ERR_PTR_INVAILD:
67. printf("Error %#x : Invaild pointer\n",err);
68. break;
69. case ERR_LNKLST_INVAILD:
70. printf("Error %#x : Invaild Linked-List\n",err);
71. break;
72. case ERR_ACTCODE_INVAILD:
73. printf("Error %#x : Invaild Action Code\n",err);
74. break;
75. case ERR_ADD_IMPOSSIBLE:
76. printf("Error %#x : Item cannot be added\n",err);
77. break;
78. case ERR_SUB_IMPOSSIBLE:
79. printf("Error %#x : Item cannot be subtracted\n",err);
80. break;
81. case ERR_EMPTY_POLY:
82. printf("Error %#x : Polynomial grows empty!\n",err);
83. break;
84. case ERR_UNKNOWN:
85. printf("Error %#x : Unknown error\n",err);
86. break;
87. }
88. }
89. #endif
91. inline uint
92. destory_polynomial(poly_lnklst *plst) {
93. poly *p = (poly *)0;
94. poly *tmp = (poly *)0;
96. #if CHK_PARAMETER_PTR == TRUE
97. if(!plst)
98. return ERR_LNKLST_INVAILD;
99. #endif
101. p = plst->head;
102. /* 逐一释放链表项目 */
103. while(p) {
104. tmp = p->next;
105. free(p);
106. p = tmp;
107. }
109. /* 释放两表容器 */
110. free(plst);
111. plst = (poly_lnklst *)0;
112. return ERR_ON_SUCCESS;
113. }
115. inline uint
116. init_poly_lnklst(poly_lnklst *plst) {
117. #if CHK_PARAMETER_PTR == TRUE
118. if(!plst)
119. return ERR_LNKLST_INVAILD;
120. #endif
122. plst->head = (poly *)0;
123. plst->tail = (poly *)0;
124. plst->length = (int)0;
126. return ERR_ON_SUCCESS;
127. }
129. inline poly *
130. create_poly_item(float p, int e, uint *err) {
131. poly *item =
132. (poly *)malloc(sizeof(poly));
133. if(!item) {
134. *err = ERR_STACK_OVERRUN;
135. return (poly *)0;
136. }
137. item->p = p;
138. item->e = e;
139. item->next = (poly *)0;
140. item->prev = (poly *)0;
141. *err = ERR_ON_SUCCESS;
142. return item;
143. }
145. #if COPY_LNKLST == TRUE
146. inline poly_lnklst *
147. copy_polynomial(poly_lnklst *plstSrc,uint *err) { 
148. poly *pSrc = (poly *)0;
149. poly *pDes = (poly *)0;
150. poly *tmp = (poly *)0;
151. poly_lnklst *plstDes = (poly_lnklst *)0;
153. #if CHK_PARAMETER_PTR == TRUE
154. if(!plstSrc) {
155. *err = ERR_LNKLST_INVAILD;
156. return (poly_lnklst *)0;
157. }
158. #endif
160. plstDes = (poly_lnklst *)malloc(sizeof(poly_lnklst));
161. if(!plstDes) {
162. *err = ERR_STACK_OVERRUN;
163. #if RAISE_ERR == TRUE
164. raise_err(*err);
165. #endif
166. #if CRITICAL_ABORT == TRUE
167. exit(1);
168. #else
169. return (poly_lnklst *)0;
170. #endif
171. }
173. /* 复制表首 */
174. pSrc = plstSrc->head;
175. if(!pSrc) {
176. free(plstDes);
177. *err = ERR_EMPTY_POLY;
178. return (poly_lnklst *)0;
179. }
180. pDes = create_poly_item(pSrc->p,pSrc->e,err);
181. if(*err != ERR_ON_SUCCESS) {
182. #if RAISE_ERR == TRUE
183. raise_err(*err);
184. #endif
185. #if CRITICAL_ABORT == TRUE
186. exit(1);
187. #else
188. return (poly_lnklst *)0;
189. #endif
190. }
191. plstDes->head = plstDes->tail = pDes;
192. plstDes->length = plstSrc->length;
193. /* 逐一复制余下的项目 */
194. pSrc = pSrc->next;
195. while(pSrc) {
196. tmp = create_poly_item(pSrc->p,pSrc->e,err);
197. if(*err != ERR_ON_SUCCESS) {
198. #if RAISE_ERR == TRUE
199. raise_err(*err);
200. #endif
201. #if CRITICAL_ABORT == TRUE
202. exit(1);
203. #else
204. return (poly_lnklst *)0;
205. #endif
206. }
207. /* 创建链表的节点连接 */
208. pDes->next = tmp;
209. tmp->prev = pDes;
210. pDes = tmp;
211. plstDes->tail = tmp;
212. pSrc = pSrc->next;
213. }
214. return plstDes;
215. }
216. #endif
218. inline uint
219. connect_to_lst(poly_lnklst *plst, poly *item) {
220. poly *p = (poly *)0,
221. *tmp = (poly *)0;
223. #if CHK_PARAMETER_PTR == TRUE
224. if(!plst)
225. return ERR_LNKLST_INVAILD;
226. if(!item)
227. return ERR_PTR_INVAILD;
228. #endif
230. if(!plst->head) {
231. plst->head = plst->tail = item;
232. item->next = item->prev = (poly *)0;
233. plst->length = (int)1;
234. }
235. else {
236. p = plst->head;
237. while(p) {
238. tmp = p->next;
239. #if AUTO_DESTORY_EXIST == TRUE
240. if(p->e == item->e) {
241. free(item);
242. item = (poly *)0;
243. return ERR_ITEM_EXIST;
244. }
245. #else
246. if(p->e == item->e)
247. return ERR_ITEM_EXIST;
248. #endif
249. if(tmp) {
250. if((p->e < item->e) && (tmp->e > item->e)) {
251. item->prev = p;
252. item->next = tmp;
253. p->next = item;
254. tmp->prev = item;
255. ++plst->length;
256. break;
257. }
258. }
259. else {
260. if(p->e > item->e && !p->prev) {
261. item->prev = (poly *)0;
262. item->next = p;
263. p->prev = item;
264. plst->head = item;
265. ++plst->length;
266. break;
267. }
268. else {
269. item->prev = p;
270. item->next = (poly *)0;
271. p->next = item;
272. plst->tail = item;
273. ++plst->length;
274. break;
275. }
276. }
277. p = tmp;
278. }
279. }
280. return ERR_ON_SUCCESS;
281. }
283. inline uint
284. remove_item(poly_lnklst *plst, poly *item) {
285. poly *tmp_prev = (poly *)0;
286. poly *tmp_next = (poly *)0;
288. #if CHK_PARAMETER_PTR == TRUE
289. if(!plst)
290. return ERR_LNKLST_INVAILD;
291. if(!plst->head || !item)
292. return ERR_PTR_INVAILD;
293. #endif
295. tmp_prev = item->prev;
296. tmp_next = item->next;
298. if(tmp_prev) {
299. tmp_prev->next = tmp_next;
300. if(tmp_next)
301. tmp_next->prev = tmp_prev;
302. else
303. plst->tail = tmp_prev;
304. }
305. else {
306. plst->head = tmp_next;
307. if(!tmp_next)
308. return ERR_EMPTY_POLY;
309. if(!tmp_next->next)
310. plst->tail = tmp_next;
311. tmp_next->prev = (poly *)0;
312. }
314. --plst->length;
315. free(item);
316. item = (poly *)0;
317. return ERR_ON_SUCCESS;
318. }
320. inline uint
321. merge_item(poly *des, poly *src, uint code) {
322. poly *tmp = (poly *)0;
324. poly *tmp_prev = (poly *)0;
325. poly *tmp_next = (poly *)0;
327. #if CHK_PARAMETER_PTR == TRUE
328. if(!des || !src)
329. return ERR_PTR_INVAILD;
330. #endif
332. switch(code) {
333. case ACT_ADD:
334. if(des->e == src->e) {
335. des->p += src->p;
336. return ERR_ON_SUCCESS;
337. }
338. else
339. return ERR_ADD_IMPOSSIBLE;
340. case ACT_SUB:
341. if(des->e == src->e) {
342. des->p -= src->p;
343. return ERR_ON_SUCCESS;
345. }
346. else
347. return ERR_SUB_IMPOSSIBLE;
348. case ACT_MUP:
349. des->p *= src->p;
350. des->e += src->e;
351. return ERR_ON_SUCCESS;
352. default:
353. return ERR_ACTCODE_INVAILD;
354. }
355. }
357. inline uint
358. find_and_merge(poly_lnklst *plst) {
359. poly *tmp = (poly *)0;
360. poly *tmp_next = (poly *)0;
361. poly *tmp_prev = (poly *)0;
362. poly **container = (poly **)0;
363. register int i = 0;
364. register int j;
365. uint err;
367. #if CHK_PARAMETER_PTR == TRUE
368. if(!plst)
369. return ERR_LNKLST_INVAILD;
370. if(!plst->head)
371. return ERR_PTR_INVAILD;
372. #endif
374. tmp = plst->head;
375. container = (poly **)malloc(sizeof(poly *) * plst->length);
377. container[0] = tmp;
378. tmp = tmp->next;
379. while(tmp) {
380. for(j = i; j >=0; --j) {
381. if(!container[j]) 
382. continue;
383. if(container[j]->e == tmp->e) {
384. err = merge_item(tmp,container[j],ACT_ADD);
385. if(err != ERR_ON_SUCCESS) {
386. #if RAISE_ERR == TRUE
387. raise_err(err);
388. #endif
389. #if CRITICAL_ABORT == TRUE
390. exit(1);
391. #else
392. return err;
393. #endif
394. }
396. err = remove_item(plst,container[j]);
397. if(err != ERR_ON_SUCCESS) {
398. #if RAISE_ERR == TRUE
399. raise_err(err);
400. #endif
401. #if CRITICAL_ABORT == TRUE
402. exit(1);
403. #else
404. return err;
405. #endif
406. }
408. /* 如果系数为0 */
409. if(tmp->p <= EPSILON) {
410. tmp_next = tmp->next;
411. err = remove_item(plst,tmp);
413. if(err != ERR_ON_SUCCESS) {
414. #if RAISE_ERR == TRUE
415. raise_err(err);
416. #endif
417. #if CRITICAL_ABORT == TRUE
418. exit(1);
419. #else
420. return err;
421. #endif
422. }
424. tmp = tmp_next;
425. }
426. else
427. tmp = tmp->next;
428. break;
429. }
430. }
431. /* 如果没有合并，则存入容器 */
432. if(j < 0) {
433. container[++i] = tmp;
434. tmp = tmp->next;
435. }
436. }
437. free(container);
438. return ERR_ON_SUCCESS;
439. }
441. inline uint
442. polynomial_opr(poly_lnklst *plstDes, poly_lnklst *plstSrc, uint oprcode) {
443. poly *pSrc = (poly *)0;
444. poly *pDes = (poly *)0;
445. poly *tmp = (poly *)0;
446. poly_lnklst *plstOpr = (poly_lnklst *)0;
447. poly_lnklst *plstRet = (poly_lnklst *)0;
449. uint err;
451. #if CHK_PARAMETER_PTR == TRUE
452. if(!plstDes || !plstSrc)
453. return ERR_LNKLST_INVAILD;
454. if(!plstDes->head || !plstSrc->head)
455. return ERR_PTR_INVAILD;
456. #endif
458. pSrc = plstSrc->head;
460. switch(oprcode) {
461. case ACT_ADD:
462. case ACT_SUB:
463. while(pSrc) {
464. pDes = plstDes->head;
465. while(pDes) {
466. if(pSrc->e == pDes->e) {
467. err = merge_item(pDes,pSrc,oprcode);
468. if(err != ERR_ON_SUCCESS) {
469. #if RAISE_ERR == TRUE
470. raise_err(err);
471. #endif
472. #if CRITICAL_ABORT == TRUE
473. exit(1);
474. #else
475. return err;
476. #endif
477. }
479. /* 如果相加后的系数为0，则删除此项 */
480. if(pDes->p <= EPSILON) {
481. tmp = pDes->next;
482. err = remove_item(plstDes,pDes);
483. if(err != ERR_ON_SUCCESS) {
484. #if RAISE_ERR == TRUE
485. raise_err(err);
486. #endif
487. #if CRITICAL_ABORT == TRUE
488. exit(1);
489. #else
490. return err;
491. #endif
492. }
493. pDes = tmp;
494. }
495. break;
496. }
497. else {
498. if(pDes->next) {
499. if((pSrc->e > pDes->e) && (pSrc->e < pDes->next->e)) {
500. tmp = create_poly_item(pSrc->p,pSrc->e,&err);
501. if(err != ERR_ON_SUCCESS) {
502. #if RAISE_ERR == TRUE
503. raise_err(err);
504. #endif
505. #if CRITICAL_ABORT == TRUE
506. exit(1);
507. #else
508. return err;
509. #endif
510. }
511. tmp->prev = pDes;
512. tmp->next = pDes->next;
513. pDes->next->prev = tmp;
514. pDes->next = tmp;
515. ++plstDes->length;
516. break;
517. }
518. }
519. else {
520. tmp = create_poly_item(pSrc->p,pSrc->e,&err);
521. if(err != ERR_ON_SUCCESS) {
522. #if RAISE_ERR == TRUE
523. raise_err(err);
524. #endif
525. #if CRITICAL_ABORT == TRUE
526. exit(1);
527. #else
528. return err;
529. #endif
530. }
531. if(pDes->e > tmp->e && !pDes->prev) {
532. tmp->prev = (poly *)0;
533. tmp->next = pDes;
534. pDes->prev = tmp;
535. plstDes->head = tmp;
536. ++plstDes->length;
537. break;
538. }
539. else {
540. plstDes->tail->next = tmp;
541. tmp->prev = plstDes->tail;
542. tmp->next = (poly *)0;
543. plstDes->tail = tmp;
544. ++plstDes->length;
545. break;
546. }
547. }
548. }
549. pDes = pDes->next;
550. }
551. pSrc = pSrc->next;
552. }
553. return ERR_ON_SUCCESS;
554. case ACT_MUP:
555. /* 复制旧链表 */
556. plstOpr = copy_polynomial(plstDes,&err);
557. if(err != ERR_ON_SUCCESS) {
558. #if RAISE_ERR == TRUE
559. raise_err(err);
560. #endif
561. #if CRITICAL_ABORT == TRUE
562. exit(1);
563. #else
564. return err;
565. #endif
566. }
567. /* 首先计算第一项，保存到返回链表 */
568. pDes = plstOpr->head;
569. while(pDes) {
570. err = merge_item(pDes,pSrc,ACT_MUP);
571. pDes = pDes->next;
572. }
573. plstRet = copy_polynomial(plstOpr,&err);
574. if(err != ERR_ON_SUCCESS) {
575. #if RAISE_ERR == TRUE
576. raise_err(err);
577. #endif
578. #if CRITICAL_ABORT == TRUE
579. exit(1);
580. #else
581. return err;
582. #endif
583. }
584. /* 删除plstOpr */
585. err = destory_polynomial(plstOpr);
586. if(err != ERR_ON_SUCCESS) {
587. #if RAISE_ERR == TRUE
588. raise_err(err);
589. #endif
590. #if CRITICAL_ABORT == TRUE
591. exit(1);
592. #else
593. return err;
594. #endif
595. }
596. /* 计算其余项 */
597. pSrc = pSrc->next;
598. while(pSrc) {
599. plstOpr = copy_polynomial(plstDes,&err);
600. if(err != ERR_ON_SUCCESS) {
601. #if RAISE_ERR == TRUE
602. raise_err(err);
603. #endif
604. #if CRITICAL_ABORT == TRUE
605. exit(1);
606. #else
607. return err;
608. #endif
609. }
610. pDes = plstOpr->head;
611. while(pDes) {
612. err = merge_item(pDes,pSrc,ACT_MUP);
613. pDes = pDes->next;
614. }
615. /* 两链表相加 */
616. err = polynomial_opr(plstRet,plstOpr,ACT_ADD);
617. if(err != ERR_ON_SUCCESS) {
618. #if RAISE_ERR == TRUE
619. raise_err(err);
620. #endif
621. #if CRITICAL_ABORT == TRUE
622. exit(1);
623. #else
624. return err;
625. #endif
626. }
627. /* 删除plstOpr */
628. err = destory_polynomial(plstOpr);
629. if(err != ERR_ON_SUCCESS) {
630. #if RAISE_ERR == TRUE
631. raise_err(err);
632. #endif
633. #if CRITICAL_ABORT == TRUE
634. exit(1);
635. #else
636. return err;
637. #endif
638. }
639. /* 计算下一项 */
640. pSrc = pSrc->next;
641. }
642. /* 清除原表达式 */
643. pDes = plstDes->head;
644. while(pDes) {
645. pSrc = pDes->next;
646. free(pDes);
647. pDes = pSrc;
648. }
649. plstDes->head = plstRet->head;
650. plstDes->tail = plstRet->tail;
651. plstDes->length = plstRet->length;
653. free(plstRet);
655. return ERR_ON_SUCCESS;
656. default:
657. return ERR_ACTCODE_INVAILD;
658. } 
659. }
661. #if SIMPLE_OUTPUT == TRUE
662. inline void
663. print_polynomial(poly_lnklst *plst) {
664. poly *p = plst->head;
665. printf("P = %c%.1fx^%d",p->p > 0 ? '\0' : '-',p->p,p->e);
666. p = p->next;
667. while(p) {
668. printf("%c%.1fx^%d",p->p > 0 ? '+' : '-',p->p,p->e);
669. p = p->next;
670. }
671. printf("\n");
672. }
673. #endif
675. #if SIMPLE_INPUT == TRUE
676. inline poly_lnklst *
677. input_polynomial(uint *err) {
678. poly *item = (poly *)0;
679. poly_lnklst *plst = (poly_lnklst *)malloc(sizeof(poly_lnklst));
681. int item_count = 0;
682. int i = 0;
684. *err = init_poly_lnklst(plst);
685. if(*err != ERR_ON_SUCCESS) {
686. #if RAISE_ERR == TRUE
687. raise_err(*err);
688. #endif
689. #if CRITICAL_ABORT == TRUE
690. exit(1);
691. #else
692. return (poly_lnklst *)0;
693. #endif
694. }
696. printf("Input how many items do you want to constructure a polynomial? ");
697. scanf("%d",&item_count);
699. while(item_count > 0) {
700. item = (poly *)malloc(sizeof(poly));
701. if(!item) {
702. *err = ERR_STACK_OVERRUN;
703. #if RAISE_ERR == TRUE
704. raise_err(*err);
705. #endif
706. #if CRITICAL_ABORT == TRUE
707. exit(1);
708. #else
709. free(plst);
710. return (poly_lnklst *)0;
711. #endif
712. }
713. printf("(p,e) ? ");
714. scanf("%f,%d",&item->p,&item->e);
715. *err = connect_to_lst(plst,item);
716. if(*err != ERR_ON_SUCCESS) {
717. #if RAISE_ERR == TRUE
718. raise_err(*err);
719. #endif
720. #if AUTO_DESTORY_EXIST == FALSE
721. free(item);
722. #endif
723. continue;
724. }
725. --item_count;
726. }
727. *err = ERR_ON_SUCCESS;
728. return plst;
729. }
730. #endif
731. /* main.cpp */
732. #include <stdio.h>
733. #include <stdlib.h>
734. #include <conio.h>
736. #include "Polynomial.h"
738. int main() {
739. poly_lnklst *plstA, *plstB;
740. uint err;
741. /* inputs */
742. printf("Input polynomial A\n");
743. plstA = input_polynomial(&err);
744. printf("Input polynomial B\n");
745. plstB = input_polynomial(&err);
746. /* mutiply */
747. err = polynomial_opr(plstA,plstB,ACT_MUP);
748. print_polynomial(plstA);
749. getch();
750. err = destory_polynomial(plstA);
751. err = destory_polynomial(plstB);
752. return 0;
753. }

复制代码

迷宫算法（用栈实现）

1. /* 工程名称： W32_Maze */
2. /* Maze.h */
3. #ifndef __MAZE_H
4. #define __MAZE_H
6. #define TRUE 0x01
7. #define FALSE 0x00
9. #define DEFAULT_MAZE TRUE
11. #define PATH_BLOCK 0x00
12. #define PATH_WALK_ON 0x01
13. #define PATH_FOOT_PRINT 0x02
15. #define MAX_COL 10
17. #include "Maze.cpp"
19. #endif
20. /* Maze.cpp */
21. /* 无符号整型 */
22. typedef unsigned int uint_t;
23. /* 地图数据 */
24. typedef int map_t;
26. typedef struct track {
27. /* 在迷宫矩阵中的位置 */
28. uint_t x;
29. uint_t y;
31. /* 可用方向 */
32. uint_t direct;
34. struct track *next;
35. struct track *prev;
36. } maze_track;
38. typedef struct {
39. /* 路径 */
40. maze_track *track_ptr;
41. /* 迷宫出口的位置 */
42. uint_t endx;
43. uint_t endy;
44. /* 当前栈的长度 */
45. int size;
46. } maze_path;
48. int count = 0;
50. /* 方向查询表 */
51. uint_t directInqTbl[4] = {0x01, 0x02, 0x04, 0x08};
52. /* 方向使用表 */
53. uint_t directUseTbl[4] = {0xE, 0xD, 0xB, 0x7};
55. /* 方向算数常数 */
56. int directTbl[4][2] = {{0,-1},{0,1},{-1,0},{1,0}};
58. /* 墙、路和足迹的符号集 */
59. unsigned char symbolic[3] = { '#', 0x20, '*' };
60. //unsigned char symbolic[3] = {0x2A, 0x20, '#'};
62. #if DEFAULT_MAZE == TRUE
63. static map_t def_maze[10][10] = { 
64. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
65. 0, 1, 1, 0, 1, 1, 1, 0, 1, 0,
66. 0, 1, 1, 0, 1, 1, 1, 0, 1, 0,
67. 0, 1, 1, 1, 1, 0, 0, 0, 1, 0,
68. 0, 1, 0, 0, 0, 1, 1, 0, 1, 0,
69. 0, 1, 1, 1, 0, 1, 1, 0, 1, 0,
70. 0, 1, 0, 1, 1, 1, 0, 1, 1, 0,
71. 0, 1, 0, 0, 0, 1, 0, 0, 1, 0,
72. 0, 0, 1, 1, 1, 1, 1, 1, 1, 0,
73. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
74. };
75. #endif
77. inline maze_path *
78. create_path(void) {
79. maze_path *path = (maze_path *)malloc(sizeof(maze_path));
80. assert(path);
81. path->track_ptr = (maze_track *)0;
82. path->size = (int)0;
83. return path;
84. }
86. inline void
87. generate_enterance(maze_path *path,uint_t x, uint_t y) {
88. if(path && !path->size) {
89. path->track_ptr = (maze_track *)malloc(sizeof(maze_track));
90. assert(path->track_ptr);
91. path->track_ptr->direct = (uint_t)0;
92. path->track_ptr->x = x;
93. path->track_ptr->y = y;
94. path->track_ptr->next = (maze_track *)0;
95. path->track_ptr->prev = (maze_track *)0;
96. ++path->size;
97. }
98. }
100. inline void
101. designate_exit(maze_path *path, uint_t x, uint_t y) {
102. if(path) {
103. path->endx = x;
104. path->endy = y;
105. }
106. }
108. inline void
109. print_maze(map_t maze[][MAX_COL], uint_t row, uint_t col) {
110. register uint_t i,j;
111. for(i = 0; i < row; ++i) {
112. for(j = 0; j < col; ++j)
113. printf("%c",*(symbolic + maze[i][j]));
114. printf("\n");
115. }
116. }
118. inline uint_t
119. find_my_way(map_t maze[][MAX_COL], uint_t row, uint_t col, maze_path *path) {
120. register int i,j;
121. uint_t x;
122. uint_t y;
123. uint_t ex;
124. uint_t ey;
126. maze_track *ptrack = (maze_track *)0;
127. maze_track *ptmp = (maze_track *)0;
129. if(path) {
130. /* 设置入口方向量 */
131. assert(path->track_ptr);
132. for(i = 0; i < 4; ++i) {
133. x = path->track_ptr->x + directTbl[i][0];
134. y = path->track_ptr->y + directTbl[i][1];
135. if( (x < 0 || x >= col) || (y < 0 || y >= row))
136. continue;
137. if(maze[y][x] == PATH_WALK_ON)
138. path->track_ptr->direct |= directInqTbl[i];
139. }
140. ptrack = path->track_ptr;
141. ex = path->endx;
142. ey = path->endy;
143. while(ptrack->x != ex || ptrack->y != ey) {
144. /* 获取行进方向 */
145. for(i = 0; i < 4; ++i) {
146. /* 方向有效，则该方向被使用 */
147. if( ((ptrack->direct & directInqTbl[i]) >> i) == 0x01 ) {
148. ptrack->direct &= directUseTbl[i];
149. break;
150. }
151. }
152. /* 当入口方向量用完，则宣告无解 */
153. if(i == 4) {
154. if(!ptrack->prev) {
155. printf("No way to solve!\n");
156. return FALSE;
157. }
158. /* 当最后个路径节点用完方向量，则折回 */
159. else {
160. /* 清除足迹 */
161. maze[ptrack->y][ptrack->x] = PATH_WALK_ON;
162. ptmp = ptrack->prev;
163. ptmp->next = (maze_track *)0;
164. free(ptrack);
165. ptrack = ptmp;
166. --path->size;
167. ++count;
168. continue;
169. }
170. }
172. ptmp = (maze_track *)malloc(sizeof(maze_track));
173. assert(ptmp);
174. ptrack->next = ptmp;
175. ++path->size;
176. /* 创建链表结构，在旧位置处留下足迹 */
177. maze[ptrack->y][ptrack->x] = PATH_FOOT_PRINT;
179. /* 设置新位置 */
180. ptmp->x = ptrack->x + directTbl[i][0];
181. ptmp->y = ptrack->y + directTbl[i][1];
182. ptmp->direct = (uint_t)0;
184. ptmp->prev = ptrack;
185. ptrack = ptmp;
186. ptmp->next = (maze_track *)0;
188. /* 为下一个路径节点获取方向信号 */
189. for(j = 0; j < 4; ++j) {
190. x = ptrack->x + directTbl[j][0];
191. y = ptrack->y + directTbl[j][1];
192. if( (x < 0 || x >= col) || (y < 0 || y >= row))
193. continue;
194. if(maze[y][x] == PATH_WALK_ON && maze[y][x] != PATH_FOOT_PRINT)
195. ptrack->direct |= directInqTbl[j];
196. }
197. }
198. maze[ey][ex] = PATH_FOOT_PRINT;
199. return TRUE;
200. }
201. return FALSE;
202. }
204. inline void
205. destory_path(maze_path *path) {
206. assert(path);
208. maze_track *track = path->track_ptr;
209. maze_track *tmp = (maze_track *)0;
211. while(track) {
212. tmp = track->next;
213. free(track);
214. track = tmp;
215. }
217. free(path);
218. path = (maze_path *)0;
219. }
220. /* main.cpp */
221. #include <stdio.h>
222. #include <stdlib.h>
223. #include <conio.h>
224. #include <assert.h>
226. #include "Maze.h"
228. int main() {
229. uint_t ret;
230. /* 创建路径链 */
231. maze_path *path = create_path();
232. maze_track *p;
233. /* 初始化入口 */
234. generate_enterance(path,1,1);
235. /* 初始化终点 */
236. designate_exit(path,8,8);
238. printf("Before explorer\n");
239. print_maze(def_maze,10,10);
240. /* 开始探索 */
241. ret = find_my_way(def_maze,10,10,path);
242. if(ret == TRUE) {
243. p = path->track_ptr;
244. printf("(%u,%u)",p->x, p->y);
245. p = p->next;
246. while(p) {
247. printf("->(%u,%u)",p->x, p->y);
248. p = p->next;
249. }
250. printf("\n");
252. printf("\nAfter explorer\n");
253. print_maze(def_maze,10,10);
254. }
255. printf("\nReturn count = %d\n",count);
256. getch();
257. destory_path(path);
258. return 0;
259. }

复制代码