【数据结构】堆栈

#include <stdio.h>
#include <stdlib.h>
 
#define STACK_SIZE 100
 
typedef struct {
    int data[STACK_SIZE];
    int top;
} SeqStack;
 
// 初始化顺序栈
void initStack(SeqStack *s) {
    s->top = -1;
}
 
// 判断栈是否为空
int isEmpty(SeqStack *s) {
    return s->top == -1;
}
 
// 判断栈是否已满
int isFull(SeqStack *s) {
    return s->top == STACK_SIZE - 1;
}
 
// 入栈操作
int push(SeqStack *s, int value) {
    if (isFull(s)) {
        printf("栈已满，无法进行入栈操作。\n");
        return 0;
    }
    s->data[++s->top] = value;
    return 1;
}
 
// 出栈操作
int pop(SeqStack *s, int *value) {
    if (isEmpty(s)) {
        printf("栈为空，无法进行出栈操作。\n");
        return 0;
    }
    *value = s->data[s->top--];
    return 1;
}
 
// 打印栈内元素
void printStack(SeqStack *s) {
    if (isEmpty(s)) {
        printf("栈为空。\n");
        return;
    }
    for (int i = s->top; i >= 0; i--) {
        printf("%d ", s->data[i]);
    }
    printf("\n");
}
 
int main() {
    SeqStack stack;
    initStack(&stack);
 
    // 入栈操作
    push(&stack, 1);
    push(&stack, 2);
    push(&stack, 3);
 
    // 出栈操作
    int value;
    pop(&stack, &value);
    printf("出栈元素: %d\n", value);
 
    // 打印栈内元素
    printStack(&stack);
 
    return 0;
}

这段代码定义了一个简单的顺序栈，并实现了初始化、判断空满、入栈、出栈以及打印栈内元素的基本操作。在main函数中演示了如何使用这些操作。

三、共享栈

3.1 定义

当需要同时使用多个栈时，可以在同一块连续的空间中设置多个栈，形成多个栈共享栈空间。当其中的某个栈满时，可能其它栈尚余许多空间，这时可以让其它的堆栈进行左右移动，然后让该栈继续获得一些新的空间，从而可以继续进行进栈活动。

3.2 操作

共享栈初始状态：

共享栈中间某状态：

3.3 C语言实现

#include <stdio.h>
#include <stdlib.h>
 
typedef struct {
    int *elements; // 存储元素的数组
    int top_index; // 栈顶索引
    int capacity;  // 栈的容量
} SharedStack;
 
// 初始化共享栈
SharedStack* init_shared_stack(int capacity) {
    SharedStack* stack = (SharedStack*)malloc(sizeof(SharedStack));
    stack->elements = (int*)malloc(capacity * sizeof(int));
    stack->top_index = -1;
    stack->capacity = capacity;
    return stack;
}
 
// 释放共享栈占用的内存
void free_shared_stack(SharedStack* stack) {
    free(stack->elements);
    free(stack);
}
 
// 判断共享栈是否为空
int is_shared_stack_empty(SharedStack* stack) {
    return stack->top_index == -1;
}
 
// 判断共享栈是否已满
int is_shared_stack_full(SharedStack* stack) {
    return stack->top_index + 1 == stack->capacity;
}
 
// 向共享栈中添加元素
void push_shared_stack(SharedStack* stack, int element) {
    if (is_shared_stack_full(stack)) {
        printf("Stack is full.\n");
        return;
    }
    stack->elements[++stack->top_index] = element;
}
 
// 从共享栈中移除元素
int pop_shared_stack(SharedStack* stack) {
    if (is_shared_stack_empty(stack)) {
        printf("Stack is empty.\n");
        return -1;
    }
    return stack->elements[stack->top_index--];
}
 
// 主函数示例
int main() {
    SharedStack* stack = init_shared_stack(10); // 初始化容量为10的共享栈
 
    push_shared_stack(stack, 1); // 添加元素
    push_shared_stack(stack, 2);
    printf("Pop element: %d\n", pop_shared_stack(stack)); // 移除元素
    printf("Pop element: %d\n", pop_shared_stack(stack));
 
    free_shared_stack(stack); // 释放栈占用的内存
 
    return 0;
}

这个简单的共享栈实现包括初始化、释放内存、判断栈满或空、进栈和出栈的基本操作。在主函数中，我们创建了一个容量为10的共享栈，添加了两个元素，然后移除并打印了这两个元素，最后释放了栈占用的内存。

四、链式栈

4.1 定义

链式栈是一种数据存储结构，可以通过单链表的方式来实现，使用链式栈的优点在于它能够克服用数组实现的顺序栈空间利用率不高的特点，但是需要为每个栈元素分配额外的指针空间用来存放指针域。

4.2 操作

每个结点存储元素和指针，栈顶指针top用于指向处于栈顶的结点，即单链表中的首结点。链式栈的进、出栈总是在首结点位置进行。

4.3 C语言实现

#include <stdio.h>
#include <stdlib.h>
 
typedef struct Node {
    int data;
    struct Node* next;
} Node;
 
typedef struct Stack {
    Node* top;
    int size;
} Stack;
 
Stack* createStack() {
    Stack* stack = (Stack*)malloc(sizeof(Stack));
    stack->top = NULL;
    stack->size = 0;
    return stack;
}
 
int isEmpty(Stack* stack) {
    return stack->top == NULL;
}
 
void push(Stack* stack, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = stack->top;
    stack->top = newNode;
    stack->size++;
}
 
int pop(Stack* stack) {
    if (isEmpty(stack)) {
        fprintf(stderr, "Stack is empty\n");
        exit(1);
    }
 
    Node* topNode = stack->top;
    int data = topNode->data;
    stack->top = stack->top->next;
    free(topNode);
    stack->size--;
    return data;
}
 
int peek(Stack* stack) {
    if (isEmpty(stack)) {
        fprintf(stderr, "Stack is empty\n");
        exit(1);
    }
    return stack->top->data;
}
 
int main() {
    Stack* stack = createStack();
 
    push(stack, 1);
    push(stack, 2);
    push(stack, 3);
 
    printf("Top element: %d\n", peek(stack));
    printf("Popped element: %d\n", pop(stack));
    printf("Top element: %d\n", peek(stack));
 
    return 0;
}

在这个实现中，我们定义了两个结构体：Node和Stack。Node用来表示链表的节点，每个节点包含一个整数和一个指向下一个节点的指针。Stack结构体包含一个指向顶部节点的指针和一个表示栈中元素数量的整数。

我们实现了几个基本的操作：