栈的C语言实现

在C++中，可以直接使用std::stack

C语言实现如下:

  1 stack.c

  2 

  3 /**

  4 * @file stack.c

  5 * @brief 栈,顺序存储.

  6 * 

  7 * 

  8 * 

  9 */

 10 

 11 #include <stdlib.h> /* for malloc() */

 12 #include <string.h> /* for memcpy() */

 13 

 14 typedef int stack_elem_t; // 元素的类型

 15 

 16 /**

 17 * @struct

 18 * @brief 栈的结构体

 19 */

 20 typedef struct stack_t {

 21     int size; 　　　　　　　　/** 实际元素个数 */

 22     int capacity; 　　　　　　/** 容量,以元素为单位 */

 23     stack_elem_t *elems; 　　/** 栈的数组 */

 24 }stack_t;

 25 

 26 /**

 27 * @brief 初始化栈.

 28 * @param[inout] s 栈对象的指针

 29 * @param[in] capacity 初始容量

 30 * @return 无

 31 */

 32 void stack_init(stack_t *s, const int capacity) {

 33     s->size = 0;

 34     s->capacity = capacity;

 35     s->elems = (stack_elem_t*)malloc(capacity * sizeof(stack_elem_t));

 36 }

 37 

 38 /**

 39 * @brief 释放栈.

 40 * @param[inout] s 栈对象的指针

 41 * @return 无

 42 */

 43 void stack_uninit(stack_t *s) {

 44     s->size = 0;

 45     s->capacity = 0;

 46     free(s->elems);

 47     s->elems = NULL;

 48 }

 49 

 50 /**

 51 * @brief 判断栈是否为空.

 52 * @param[in] s 栈对象的指针

 53 * @return 是空,返回 1,否则返回 0

 54 */

 55 int stack_empty(const stack_t *s) {

 56     return s->size == 0;

 57 }

 58 

 59 /**

 60 * @brief 获取元素个数.

 61 * @param[in] s 栈对象的指针

 62 * @return 元素个数

 63 */

 64 int stack_size(const stack_t *s) {

 65     return s->size;

 66 }

 67 

 68 /**

 69 * @brief 进栈.

 70 * @param[in] s 栈对象的指针

 71 * @param[in] x 要进栈的元素

 72 * @return 无

 73 */

 74 void stack_push(stack_t *s, const stack_elem_t x)

 75 {

 76     if(s->size == s->capacity)

 77     { 

 78         /* 已满,重新分配内存 */

 79         stack_elem_t* tmp = (stack_elem_t*)realloc(s->elems,

 80         s->capacity * 2 * sizeof(stack_elem_t));

 81         s->capacity *= 2;

 82         s->elems = tmp;

 83     }

 84     s->elems[s->size++] = x;

 85 }

 86 

 87 /**

 88 * @brief 进栈.

 89 * @param[in] s 栈对象的指针

 90 * @return 无

 91 */

 92 void stack_pop(stack_t *s) {

 93 　　s->size--;

 94 }

 95 

 96 /**

 97 * @brief 获取栈顶元素.

 98 * @param[in] s 栈对象的指针

 99 * @return 栈顶元素

100 */

101 stack_elem_t stack_top(const stack_t *s) {

102 　　return s->elems[s->size - 1];

103 }

104             

　　注意到在push进栈的过程中，如果此时分配的栈空间已经满了，realloc内存空间为当前栈空间的两倍。

　　realloc(指向该内存的指针，重新分配内存大小)；使用realloc时应格外小心，因为当重新分配内存大小小于原来内存大小的时候，可能导致数据的丢失。