动态数组栈的基本功能实现

拆分：

// 错误处理宏定义
#define ERROR_CHECK(condition, msg) \
    do { \
        if (condition) { \
            printf("Error: %s\n", msg); \
            exit(1); \
        } \
    } while(0)

typedef int ElementType;

typedef struct {
    ElementType* elements;
    int size;
    int capacity;
} DynamicStack;

1. 创建动态数组栈

DynamicStack* stack_create() {
    DynamicStack* s = malloc(sizeof(DynamicStack));
    ERROR_CHECK(s == NULL, "malloc failed in stack_create.");
    s->size = 0;
    s->capacity = DEFAULT_CAPACITY;
    s->elements = malloc(DEFAULT_CAPACITY * sizeof(ElementType));
    ERROR_CHECK(s->elements == NULL, "malloc failed in stack_create.");
    return s;
}

2. 销毁动态数组栈

void stack_destroy(DynamicStack* s) {
    free(s->elements);
    free(s);
}

3. 入栈

// 入栈: 将数组末尾视为栈顶，将size作为新插入结点的下标
void stack_push(DynamicStack* s, ElementType val) {
    if (s->capacity == s->size) {
        grow_capacity(s); // 栈满, 扩容
    }
    s->elements[s->size] = val;
    s->size++;
}

4. 出栈并返回栈顶元素

ElementType stack_pop(DynamicStack* s) {
    ERROR_CHECK(is_empty(s), "stack is empty.");
    s->size--;
    return s->elements[s->size];
}

5. 访问栈顶元素

ElementType stack_peek(DynamicStack* s) {
    ERROR_CHECK(is_empty(s), "stack is empty.");
    return s->elements[s->size - 1];
}

6. 判空

bool is_empty(DynamicStack* s) {
    return s->size == 0;
}

整合：

dynamic_stack.h

#ifndef DYNAMIC_STACK_H
#define DYNAMIC_STACK_H
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

// 错误处理宏定义
#define ERROR_CHECK(condition, msg) \
    do { \
        if (condition) { \
            printf("Error: %s\n", msg); \
            exit(1); \
        } \
    } while(0)

typedef int ElementType;

typedef struct {
    ElementType* elements;
    int size;
    int capacity;
} DynamicStack;

// 创建动态数组栈
DynamicStack* stack_create();
// 销毁动态数组栈
void stack_destroy(DynamicStack* s);
// 入栈
void stack_push(DynamicStack* s, ElementType val);
// 出栈并返回栈顶元素
ElementType stack_pop(DynamicStack* s);
// 访问栈顶元素
ElementType  stack_peek(DynamicStack* s);
// 判空
bool is_empty(DynamicStack* s);

#endif // !DYNAMIC_ARR_STACK_H

dynamic_stack.c

#include "dynamic_stack.h"
#define DEFAULT_CAPACITY 8  // 动态栈的默认容量
#define THRESHOLD 1024  // 扩容阈值

// 扩容
static void grow_capacity(DynamicStack* s) {
    // 扩容策略: 超过阈值则1.5倍的扩容，否则2倍的扩容
    int new_capacity = (s->capacity >= THRESHOLD) ?
        (s->capacity + (s->capacity >> 1)) :
        (s->capacity << 1);

    ElementType* new_arr = realloc(s->elements, new_capacity * sizeof(ElementType));
    ERROR_CHECK(new_arr == NULL, "realloc failed in grow_capacity");

    s->elements = new_arr;
    s->capacity = new_capacity;
}

// 创建动态数组栈
DynamicStack* stack_create() {
    DynamicStack* s = malloc(sizeof(DynamicStack));
    ERROR_CHECK(s == NULL, "malloc failed in stack_create.");
    s->size = 0;
    s->capacity = DEFAULT_CAPACITY;
    s->elements = malloc(DEFAULT_CAPACITY * sizeof(ElementType));
    ERROR_CHECK(s->elements == NULL, "malloc failed in stack_create.");
    return s;
}

// 销毁动态数组栈
void stack_destroy(DynamicStack* s) {
    free(s->elements);
    free(s);
}

// 入栈: 将数组末尾视为栈顶，将size作为新插入结点的下标
void stack_push(DynamicStack* s, ElementType val) {
    if (s->capacity == s->size) {
        grow_capacity(s); // 栈满, 扩容
    }
    s->elements[s->size] = val;
    s->size++;
}

// 出栈并返回栈顶元素
ElementType stack_pop(DynamicStack* s) {
    ERROR_CHECK(is_empty(s), "stack is empty.");
    s->size--;
    return s->elements[s->size];
}

// 访问栈顶元素
ElementType stack_peek(DynamicStack* s) {
    ERROR_CHECK(is_empty(s), "stack is empty.");
    return s->elements[s->size - 1];
}

// 判空
bool is_empty(DynamicStack* s) {
    return s->size == 0;
}

测试代码main.c

#include "dynamic_stack.h"

/*
动态数组栈
// 创建动态数组栈
DynamicStack* stack_create();
// 销毁动态数组栈
void stack_destroy(DynamicStack* s);
// 入栈
void stack_push(DynamicStack* s, ElementType val);
// 出栈并返回栈顶元素
ElementType stack_pop(DynamicStack* s);
// 访问栈顶元素
ElementType  stack_peek(DynamicStack* s);
// 判空
bool is_empty(DynamicStack* s);
*/

int main(void) {
    DynamicStack* s = stack_create();
    for (int i = 0; i < 10; i++) {
        stack_push(s, i+1);
    }

    // 一直出栈, 顺便测试空栈出栈的报错
    while (true) {
        ElementType ele = stack_peek(s);
        printf("%d ", ele);
        stack_pop(s);
    }
    // stack_destroy(s);

    return 0;
}