算法代码（转）

动态内存分配算法 

  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. }
复制代码
posted @ 2012-08-15 15:07  山路水桥  阅读(503)  评论(0)  编辑  收藏  举报