2007-07-15

c实现的stack

关键字: 数据结构,stack
stack.h
c 代码
  1. #ifndef __STACK_H__   
  2. #define __STACK_H__   
  3.   
  4. ///////////////////////////////////////////   
  5. //这里只提供了一个框架，具体由用户自己定义   
  6. //要自定义元素，可以去修改相应文件vector或    
  7. //double_list中的值。    
  8. //////////////////////////////////////////   
  9. typedef enum {   
  10.     VECTOR,   
  11.     LIST,   
  12. }cate_enum;   
  13.   
  14. typedef void *stack_t;   
  15. typedef const void * const_stack_t;   
  16.   
  17. stack_t stack_new(cate_enum cate);   
  18.   
  19. void stack_destroy(stack_t stk);   
  20.   
  21. int stack_pop(stack_t stk);   
  22.   
  23. int stack_push(stack_t stk, const void *elem);   
  24.   
  25. const void *stack_top(const_stack_t stk);   
  26.   
  27. int stack_size(const_stack_t stk);   
  28.   
  29. int stack_is_empty(const_stack_t stk);   
  30.   
  31. int stack_equal(const_stack_t lstk, const_stack_t rstk);   
  32.   
  33. void stack_print(const_stack_t stk);   
  34.   
  35. #endif   
stack.c
c 代码
  1. #include "stack.h"   
  2. #include "double_list.h"   
  3. #include "vector.h"   
  4.   
  5.   
  6. //////////////////////////////////////////   
  7.   
  8. typedef struct _stack_t{   
  9.     cate_enum category;   
  10.     void *stk;   
  11. }_stack_t;   
  12.   
  13. stack_t stack_new(cate_enum cate)   
  14. {   
  15.     _stack_t * stk = (_stack_t *)malloc(sizeof(_stack_t));   
  16.     stk->category = cate;   
  17.     switch(stk->category)   
  18.     {   
  19.         case VECTOR:   
  20.            stk->stk = vector_new();   
  21.            break;   
  22.         case LIST:   
  23.            stk->stk = dlist_new();   
  24.            break;   
  25.         default:   
  26.            free(stk);   
  27.            return 0;   
  28.     }   
  29.     return (stack_t)stk;   
  30. }   
  31.   
  32. void stack_destroy(stack_t stk)   
  33. {   
  34.      _stack_t *ps = (_stack_t *)stk;   
  35.         
  36.      switch(ps->category)   
  37.      {   
  38.          case VECTOR:   
  39.               vector_destroy(ps->stk);   
  40.               break;   
  41.          case LIST:   
  42.               dlist_destroy(ps->stk);   
  43.               break;   
  44.      }   
  45.      free(ps);      
  46.  }   
  47.   
  48. int stack_pop(stack_t stk)   
  49. {   
  50.      _stack_t *ps = (_stack_t *)stk;   
  51.         
  52.      switch(ps->category)   
  53.      {   
  54.          case VECTOR:   
  55.               return vector_pop_back(ps->stk);   
  56.          case LIST:   
  57.               return dlist_pop_back(ps->stk);   
  58.          default:   
  59.               return 0;   
  60.      }   
  61.  }   
  62.   
  63. int stack_push(stack_t stk, const void *elem)   
  64. {   
  65.      _stack_t *ps = (_stack_t *)stk;   
  66.         
  67.      switch(ps->category)   
  68.      {   
  69.          case VECTOR:   
  70.               return vector_push_back(ps->stk, elem);   
  71.          case LIST:   
  72.               return dlist_push_back(ps->stk, elem);   
  73.          default:   
  74.               return 0;   
  75.      }   
  76. }   
  77.   
  78. const void *stack_top(const_stack_t stk)   
  79. {   
  80.      const _stack_t *ps = (const _stack_t *)stk;   
  81.         
  82.      switch(ps->category)   
  83.      {   
  84.          case VECTOR:   
  85.               return vector_back(ps->stk);   
  86.          case LIST:   
  87.               return dlist_back(ps->stk);   
  88.          default:   
  89.               return 0;   
  90.      }   
  91. }   
  92.   
  93. int stack_size(const_stack_t stk)   
  94. {   
  95.      const _stack_t *ps = (const _stack_t *)stk;   
  96.         
  97.      switch(ps->category)   
  98.      {   
  99.          case VECTOR:   
  100.               return vector_size(ps->stk);   
  101.          case LIST:   
  102.               return dlist_size(ps->stk);   
  103.          default:   
  104.               return 0;   
  105.      }   
  106. }   
  107.   
  108. int stack_is_empty(const_stack_t stk)   
  109. {   
  110.      const _stack_t *ps = (const _stack_t *)stk;   
  111.         
  112.      switch(ps->category)   
  113.      {   
  114.          case VECTOR:   
  115.               return vector_is_empty(ps->stk);   
  116.          case LIST:   
  117.               return dlist_is_empty(ps->stk);   
  118.      }   
  119. }   
  120.   
  121. int stack_equal(const_stack_t lstk, const_stack_t rstk)   
  122. {   
  123.      const _stack_t *lps = (const _stack_t *)lstk;   
  124.      const _stack_t *rps = (const _stack_t *)rstk;   
  125.         
  126.      if(rps->category != lps->category)   
  127.          return 0;   
  128.         
  129.         
  130.      switch(lps->category)   
  131.      {   
  132.          case VECTOR:   
  133.               return vector_equal(lps->stk, rps->stk);   
  134.          case LIST:   
  135.               return dlist_equal(lps->stk, rps->stk);   
  136.      }   
  137. }   
  138.   
  139. void stack_print(const_stack_t stk)   
  140. {   
  141.      const _stack_t *ps = (const _stack_t *)stk;   
  142.         
  143.      switch(ps->category)   
  144.      {   
  145.          case VECTOR:   
  146.               return vector_print(ps->stk);   
  147.          case LIST:   
  148.               return dlist_print(ps->stk);   
  149.      }   
  150.  }   
评论
发表评论

您还没有登录，请登录后发表评论

xombat
搜索本博客
存档
最新评论