算法村，数组栈的实现

栈的结构体

struct Stack {
    void* data[MAX]; // 存放数据的数组
    int size; // 栈中元素个数
};

数组栈的实现

// 初始化栈
Stack* Init_Stack() {
    Stack* stack = new Stack();
    if (nullptr == stack) {
        return nullptr;
    }
    std::memset(stack, 0, sizeof(Stack));
    stack->size = 0;
    return stack;
}

// 入栈操作
void Push_Stack(Stack* stack, void* data) {
    if (stack == nullptr) {
        return;
    }
    if (data == nullptr) {
        return;
    }
    Stack* s = stack;
    s->data[s->size] = data;
    s->size++;
}

// 出栈操作
void Pop_Stack(Stack* stack) {
    if (stack == nullptr) {
        return;
    }
    Stack* s = stack;
    if (s->size == 0) {
        return;
    }
    s->data[s->size - 1] = nullptr;
    s->size--;
 
   
}

// 返回栈顶元素的指针
void* Top_Stack(Stack* stack) {
    if (stack == nullptr) {
        return nullptr;
    }
    Stack* s = stack;
    if (s->size == 0) {
        return nullptr;
    }
    return s->data[s->size - 1];
}

// 获取栈的大小
int Size_Stack(Stack* stack) {
    if (stack == nullptr) {
        return 0;
    }
    Stack* s = stack;
    return s->size;
}

测试数据

int main() {
    Stack* stack = Init_Stack();

    int a = 5;
    Push_Stack(stack, &a);

    int b = 10;
    Push_Stack(stack, &b);

    std::cout << "栈的大小: " << Size_Stack(stack) << std::endl;

    int* top = static_cast<int*>(Top_Stack(stack));
    if (top != nullptr) {
        std::cout << "返回栈顶元素: " << *top << std::endl;
    }

    Pop_Stack(stack);

    std::cout << "删除后的大小: " << Size_Stack(stack) << std::endl;
    delete stack; // 释放内存
    return 0;
}

总结

栈是一种线性数据结构，元素按照线性顺序排列，向进后出，插入和删除只能栈顶进行操作