嵌入式学习-02_数据结构和算法 (栈)

嵌入式学习-02_数据结构和算法 (栈)

1 线性结构之栈

1.1 栈的定义

栈(stack)，是限制在只能在表的一端进行插入和删除操作的线性表。应用范围非常广泛。生活中也有栈的场景，比如堆叠的盘子、报 ，电梯中的人们，邮局的邮筒等。

特点：后进先出 (LIFO，Last In First Out)或先进后出 (FILO，First In Last Out)的线性表。

1.2 相关概念

- 栈顶(Top)：允许进行插入、删除操作的一端，又称为表尾。栈顶由一个称为栈顶指针的位置指示器（其实就是一个变量）来指示，它是动态变化的。

- 栈底(Bottom)：是固定不变的，不允许进行插入和删除的一端，又称为表头。

- 空栈：不含任何元素的空表。

- 设栈S=(a1,a2,…,an )，则a1称为栈底元素，an为栈顶元素，栈中元素按a1,a2,…,a_n的次序进栈(压栈、push)，出栈(弹栈，pop)的第一个元素应为栈顶元素，出栈顺序为：an,…,a2,a1。

*情况1：初始情况top = -1。*

*情况2：初始情况top = 0。*

1.3 栈的使用举例

#include <stdio.h>
#include <stdlib.h>

// 定义栈中元素的类型别名
typedef int element_t;

// 定义栈结构体
typedef struct
{
    element_t *data; // 存储栈中的元素，指向一块连续存储的内存空间
    size_t capacity; // 容量
    size_t size;     // 已添加的元素个数
} Stack;

/**
 * @brief 初始化栈
 * @param Stack *stack
 * @param size_t initCapacity
 */
void initStack(Stack *stack, size_t initCapacity)
{
    // 开辟连续的内存空间
    stack->data = (element_t *)malloc(sizeof(element_t) * initCapacity);
    // 初始化成员
    stack->capacity = initCapacity;
    stack->size = 0;
}

/**
 * @brief 返回栈内元素个数
 * @param const Stack *stack
 */
size_t getSize(const Stack *stack)
{
    return stack -> size;
}

/**
 * @brief 入栈(添加元素)
 * @param Stack *stack
 * @param element_t element
 */
void pushStack(Stack *stack, element_t element)
{
    // 如果容量已满，扩展
    if (stack->size == stack->capacity)
    {
        stack->capacity *= 2;
        stack->data = realloc(stack->data, sizeof(element_t) * stack -> capacity);
    }

    // 在最后一个位置添加新元素
    stack->data[stack->size] = element;
    // 元素数量自增
    stack->size++;
}

//
/**
 * @brief 出栈（删除元素）
 * @param Stack *stack
 * @param element_t *deleted_element 用于存储被删除的元素
 */
void popStack(Stack *stack, element_t *deleted_element)
{
    // 如果是空栈，直接退出
    if (stack->size == 0)
    {
        return;
    }

    // 将被删除的元素存储下来
    *deleted_element = stack->data[stack->size - 1];

    // 删除最后一个元素,不用真删除，元素数量自减
    stack->size--;
}

/**
 * @brief 释放栈内存
 * @param Stack *stack
 */
void destroyStack(Stack *stack)
{
    free(stack->data);
    stack->capacity = 0;
    stack->size = 0;
}

/**
 * @brief 遍历栈中的数据
 * @param Stack *stack
 */
void printStack(Stack *stack)
{
    for (size_t i = 0; i < stack->size; i++)
    {
        printf("%d ", stack->data[i]);
    }
}

int main()
{

    // 定义栈结构
    Stack stack;

    // 初始化
    initStack(&stack, 10);

    // 入栈
    pushStack(&stack, 100);
    pushStack(&stack, 200);
    pushStack(&stack, 300);
    pushStack(&stack, 400);
    pushStack(&stack, 500);
    pushStack(&stack, 600);
    pushStack(&stack, 700);
    pushStack(&stack, 800);
    pushStack(&stack, 900);
    pushStack(&stack, 1000);
    pushStack(&stack, 1100);

    // 出栈
    element_t num;
    popStack(&stack, &num);
    printf("元素 %d 出栈\n", num);
    popStack(&stack, &num);
    printf("元素 %d 出栈\n", num);
    printf("\n");

    printf("栈内元素数量：%zu \n", getSize(&stack));
    printStack(&stack);

    // 释放栈内存
    destroyStack(&stack);
    return 0;
}

栈\n", num);
printf(“\n”);

printf("栈内元素数量：%zu \n", getSize(&stack));
printStack(&stack);

// 释放栈内存
destroyStack(&stack);
return 0;

}