堆栈——C语言（动态数组）

首先请大家预知，在C语言中，一个数组的数组名是一个指针常量，它指向数组第一个元素，比如

#include<stdio.h>
int main()
{
    int a[3] = {1, 2, 3};
    printf("a数组第1个元素：%d\n",*a);
    printf("a数组第2个元素：%d\n",*(a + 1));
    printf("a数组第3个元素：%d\n",*(a + 2));
    return 0;
}

控制台输出：

a数组第1个元素：1
a数组第2个元素：2
a数组第3个元素：3

当然平常访问数组值都是通过下标索引，但是请记住，在C语言中，下标索引访问等同于指针间接访问操作。

a[0] == *(a + 0)
a[2] == *(a + 2)

1.首先定义一个堆栈的接口（stack.h）

/*
** 一个堆栈模块的接口
*/
#include <stddef.h>

#define STACK_TYPE int /*堆栈所储存的类型*/

/*
** push
** 把一个新值压入堆栈中，它的参数是被压入的值。
*/
void push(STACK_TYPE value);

/*
** pop
** 从堆栈中弹出一个值，并将之返回
*/
STACK_TYPE pop(void);

/*
** top
** 返回堆栈顶部元素的值，但不对堆栈进行修改
*/
STACK_TYPE top(void);

/*
** is_empty
** 如果堆栈为空，返回TURE,否则返回FLASE
*/
int is_empty(void);

/*
** is_full
** 如果堆栈已满，返回TURE,否则返回FLASE
*/
int is_full(void);

/*
** len
** 返回堆栈已存储元素个数
*/
int len(void);

/*
** ---------------------接下来声明动态数组堆栈部分---------------------------
*/

/*
** create_stack
** 创建堆栈，参数指定堆栈可以保存多少元素
** 注意：这个函数并不用于静态数组版本的堆栈
** size_t来源于stddef.h文件中，表示C中任何对象所能达到的最大长度，为无符号整数
*/
void create_stack(size_t size);

/*
** destroy_stack
** 摧毁堆栈，释放堆栈所使用的内存
** 注意：这个函数并不用于静态数组版本的堆栈
*/
void destroy_stack(void);

2.在另一个文件（d_stack.c）中，实现具体函数操作

/*
** 一个动态分配数组实现的堆栈
** 堆栈的长度在创建堆栈的函数时给出，该函数必须在任何其它操作堆栈函数调用之前调用
*/
#include "stack.h"
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <assert.h>
/*
** 用于存储堆栈元素的数组
** 数组的长度
** 指向堆栈栈顶元素的索引
*/
static STACK_TYPE *stack;
static size_t stack_size;
static int top_element = -1; /*堆栈初始化时为空*/

/*
** create_stack
** malloc（参数为分配的内存字节数），在头文件stdlib.h中定义，
** 用于动态分配内存空间，该函数会返回一个*void指针，
** 该指针指向一块空的内存空间，大小至少为参数大小，指针类型会根据赋值对象进行类型转换
** 要对malloc返回的指针进行断言检查，确保并非NULL
*/
void create_stack(size_t size){
    assert( stack_size == 0 );
    stack_size = size;
    stack = malloc( stack_size * sizeof( STACK_TYPE ) );
    assert( stack != NULL );
}

/*
** destroy_stack
** free会释放指针指向空间的内存
** 记得如果指针暂时没用，应赋为NULL
*/
void destroy_stack(void){
    assert( stack_size > 0 );
    stack_size = 0;
    free(stack);
    stack = NULL;
}

/*
** push
*/
void push(STACK_TYPE value){
    assert( !is_full() );
    top_element += 1;
    stack[top_element] = value;
}

/*
** pop
*/
STACK_TYPE pop(void){
    assert( !is_empty() );
    return stack[top_element--];
}

/*
** top
*/
STACK_TYPE top(void){
    assert( !is_empty() );
    return stack[top_element];
}

/*
** is_empty
*/
int is_empty(void){
    return top_element == -1;
}

/*
** is_full
*/
int is_full(void){
    return top_element == stack_size - 1;
}

/*
** len
*/
int len(void){
    if(is_empty()){
        return 0;
    }
    else{
        return top_element + 1;
    }
}

3.最后写一个主函数文件（d_main.c）测试一下堆栈操作

#include "d_stack.c"

#define T "True"
#define F "False"

int main(){
    create_stack(10);
    push(6);
    push(3);
    push(2);
    push(4);
    push(5);
    printf("栈顶元素为：%d\n",top());
    printf("堆栈为空吗？%s\n",is_empty()?T:F);
    printf("堆栈为满吗？%s\n",is_full()?T:F);
    printf("堆栈现在存储了%d个值\n",len());
    printf("堆栈弹出了%d\n",pop());
    printf("堆栈现在存储了%d个值",len());
    destroy_stack();
    return 0;
}

控制台输出为：

栈顶元素为：5
堆栈为空吗？False
堆栈为满吗？False
堆栈现在存储了5个值
堆栈弹出了5
堆栈现在存储了4个值

总结：动态数组实现堆栈比静态数组明显更具优势，可以指定大小，但还有一种操作，没错，就是C语言的特色——链表，接下来，我将运用结构体与指针，实现一个链表节点数据类型，再用这个链表实现堆栈操作。