1. PingCode智库首页
  2. 百科

c语言如何声明一个栈

Edit2 • • 百科

c语言如何声明一个栈

声明一个栈在C语言中，通常可以通过数组或链表来实现。 具体方法包括：使用数组创建固定大小的栈、使用链表创建动态大小的栈、结合结构体封装栈的数据和操作。在本文中，我们将详细介绍这几种方法，并说明各自的优缺点。

一、使用数组实现固定大小的栈

使用数组实现栈是一种简单而高效的方法，但其大小是固定的，无法动态扩展。

1.1、定义栈结构

首先，我们需要定义一个结构体来表示栈。这个结构体包括一个数组用于存储栈的数据、一个整数用于跟踪栈顶的位置。

#define MAX 100


typedef struct {


    int data[MAX];


    int top;


} Stack;

1.2、初始化栈

在使用栈之前，我们需要初始化它。初始化的过程非常简单，只需将 top 设为 -1，表示栈为空。

void initStack(Stack* s) {


    s->top = -1;


}

1.3、判断栈是否为空

判断栈是否为空是通过检查 top 是否等于 -1 实现的。

int isEmpty(Stack* s) {


    return s->top == -1;


}

1.4、判断栈是否已满

判断栈是否已满是通过检查 top 是否等于数组的最大索引值实现的。

int isFull(Stack* s) {


    return s->top == MAX - 1;


}

1.5、入栈操作

入栈操作是将元素添加到栈顶。首先检查栈是否已满，如果未满，将 top 加 1，然后将元素放置在 top 所在位置。

void push(Stack* s, int value) {


    if (isFull(s)) {


        printf("Stack overflown");


        return;


    }


    s->data[++(s->top)] = value;


}

1.6、出栈操作

出栈操作是从栈顶移除元素。首先检查栈是否为空，如果不为空，返回 top 所在位置的元素，然后将 top 减 1。

int pop(Stack* s) {


    if (isEmpty(s)) {


        printf("Stack underflown");


        return -1;


    }


    return s->data[(s->top)--];


}

1.7、获取栈顶元素

获取栈顶元素是通过返回 top 所在位置的元素实现的，但不会修改 top 的值。

int peek(Stack* s) {


    if (isEmpty(s)) {


        printf("Stack is emptyn");


        return -1;


    }


    return s->data[s->top];


}

二、使用链表实现动态大小的栈

使用链表实现栈可以动态调整栈的大小，不受固定容量的限制。

2.1、定义节点结构

首先，我们需要定义一个链表节点的结构体。每个节点包含一个数据部分和一个指向下一个节点的指针。

typedef struct Node {


    int data;


    struct Node* next;


} Node;

2.2、定义栈结构

栈结构只需要一个指向链表头部的指针。

typedef struct {


    Node* top;


} Stack;

2.3、初始化栈

初始化栈的过程是将 top 指针设为 NULL，表示栈为空。

void initStack(Stack* s) {


    s->top = NULL;


}

2.4、判断栈是否为空

判断栈是否为空是通过检查 top 是否为 NULL 实现的。

int isEmpty(Stack* s) {


    return s->top == NULL;


}

2.5、入栈操作

入栈操作是将新节点添加到链表头部。首先创建新节点，然后将新节点的 next 指针指向当前 top，最后将 top 指针更新为新节点。

void push(Stack* s, int value) {


    Node* newNode = (Node*)malloc(sizeof(Node));


    if (newNode == NULL) {


        printf("Memory allocation failedn");


        return;


    }


    newNode->data = value;


    newNode->next = s->top;


    s->top = newNode;


}

2.6、出栈操作

出栈操作是从链表头部移除节点。首先检查栈是否为空，如果不为空，保存 top 节点的值，更新 top 为 top->next，然后释放原 top 节点的内存。

int pop(Stack* s) {


    if (isEmpty(s)) {


        printf("Stack underflown");


        return -1;


    }


    Node* temp = s->top;


    int value = temp->data;


    s->top = s->top->next;


    free(temp);


    return value;


}

2.7、获取栈顶元素

获取栈顶元素是通过返回 top 节点的值实现的，但不会修改 top 的指针。

int peek(Stack* s) {


    if (isEmpty(s)) {


        printf("Stack is emptyn");


        return -1;


    }


    return s->top->data;


}

三、比较数组和链表实现的栈

3.1、数组实现的优缺点

优点：

  • 访问速度快：数组在内存中是连续存储的，访问元素速度快。
  • 实现简单：使用数组实现栈的代码相对简单。

缺点：

  • 大小固定：数组大小是固定的，无法动态扩展。
  • 内存浪费：如果数组大小过大，可能会浪费内存。

3.2、链表实现的优缺点

优点：

  • 动态大小：链表实现的栈可以根据需要动态调整大小。
  • 内存高效：只使用需要的内存，不会浪费。

缺点：

  • 访问速度慢：链表在内存中不是连续存储的，访问元素速度较慢。
  • 实现复杂：使用链表实现栈的代码相对复杂，需要处理内存分配和释放。

四、结合结构体封装栈的数据和操作

为了更好地封装栈的数据和操作，我们可以将栈的各个功能模块化，放入结构体中。

4.1、定义栈结构体和操作函数指针

typedef struct {


    void (*init)(void*);


    int (*isEmpty)(void*);


    int (*isFull)(void*);


    void (*push)(void*, int);


    int (*pop)(void*);


    int (*peek)(void*);


    void* data;


} Stack;

4.2、数组实现的栈

定义一个用于数组实现的栈数据结构：

typedef struct {


    int data[MAX];


    int top;


} ArrayStack;

定义数组实现的栈操作函数：

void initArrayStack(void* s) {


    ((ArrayStack*)s)->top = -1;


}


int isEmptyArrayStack(void* s) {


    return ((ArrayStack*)s)->top == -1;


}


int isFullArrayStack(void* s) {


    return ((ArrayStack*)s)->top == MAX - 1;


}


void pushArrayStack(void* s, int value) {


    if (isFullArrayStack(s)) {


        printf("Stack overflown");


        return;


    }


    ((ArrayStack*)s)->data[++(((ArrayStack*)s)->top)] = value;


}


int popArrayStack(void* s) {


    if (isEmptyArrayStack(s)) {


        printf("Stack underflown");


        return -1;


    }


    return ((ArrayStack*)s)->data[((ArrayStack*)s)->top--];


}


int peekArrayStack(void* s) {


    if (isEmptyArrayStack(s)) {


        printf("Stack is emptyn");


        return -1;


    }


    return ((ArrayStack*)s)->data[((ArrayStack*)s)->top];


}

4.3、链表实现的栈

定义一个用于链表实现的栈数据结构：

typedef struct Node {


    int data;


    struct Node* next;


} ListNode;


typedef struct {


    ListNode* top;


} ListStack;

定义链表实现的栈操作函数：

void initListStack(void* s) {


    ((ListStack*)s)->top = NULL;


}


int isEmptyListStack(void* s) {


    return ((ListStack*)s)->top == NULL;


}


void pushListStack(void* s, int value) {


    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));


    if (newNode == NULL) {


        printf("Memory allocation failedn");


        return;


    }


    newNode->data = value;


    newNode->next = ((ListStack*)s)->top;


    ((ListStack*)s)->top = newNode;


}


int popListStack(void* s) {


    if (isEmptyListStack(s)) {


        printf("Stack underflown");


        return -1;


    }


    ListNode* temp = ((ListStack*)s)->top;


    int value = temp->data;


    ((ListStack*)s)->top = ((ListStack*)s)->top->next;


    free(temp);


    return value;


}


int peekListStack(void* s) {


    if (isEmptyListStack(s)) {


        printf("Stack is emptyn");


        return -1;


    }


    return ((ListStack*)s)->top->data;


}

4.4、创建栈实例

通过封装好的栈结构体和操作函数指针，我们可以轻松创建和操作不同实现方式的栈。

int main() {


    // 创建数组实现的栈


    ArrayStack arrayStack;


    Stack stack1;


    stack1.init = initArrayStack;


    stack1.isEmpty = isEmptyArrayStack;


    stack1.isFull = isFullArrayStack;


    stack1.push = pushArrayStack;


    stack1.pop = popArrayStack;


    stack1.peek = peekArrayStack;


    stack1.data = &arrayStack;


    stack1.init(stack1.data);


    stack1.push(stack1.data, 10);


    stack1.push(stack1.data, 20);


    printf("Top element: %dn", stack1.peek(stack1.data));


    printf("Popped element: %dn", stack1.pop(stack1.data));


    printf("Popped element: %dn", stack1.pop(stack1.data));


    // 创建链表实现的栈


    ListStack listStack;


    Stack stack2;


    stack2.init = initListStack;


    stack2.isEmpty = isEmptyListStack;


    stack2.push = pushListStack;


    stack2.pop = popListStack;


    stack2.peek = peekListStack;


    stack2.data = &listStack;


    stack2.init(stack2.data);


    stack2.push(stack2.data, 30);


    stack2.push(stack2.data, 40);


    printf("Top element: %dn", stack2.peek(stack2.data));


    printf("Popped element: %dn", stack2.pop(stack2.data));


    printf("Popped element: %dn", stack2.pop(stack2.data));


    return 0;


}

五、总结

在本文中，我们详细介绍了如何在C语言中声明一个栈，包括使用数组实现固定大小的栈、使用链表实现动态大小的栈以及结合结构体封装栈的数据和操作。使用数组实现的栈具有访问速度快、实现简单的优点，但大小固定，可能浪费内存；使用链表实现的栈可以动态调整大小，更加灵活，但访问速度较慢，实现复杂。

通过这些方法，读者可以根据具体需求选择合适的实现方式。在实际开发中，选择哪种实现方式取决于应用场景的具体要求，如内存使用、性能需求和代码复杂度等。如果需要进行项目管理，可以考虑使用研发项目管理系统PingCode和通用项目管理软件Worktile来辅助开发和管理。

相关问答FAQs：

1. 什么是栈？如何在C语言中声明一个栈？

栈是一种常见的数据结构，它遵循"先进后出"（Last In, First Out，LIFO）的原则。在C语言中，可以通过声明一个数组和一个指向数组顶部的指针来实现一个栈。首先，你需要确定栈的最大容量，然后声明一个数组来存储栈的元素，再声明一个指针来指向栈顶的位置。

2. 如何声明一个固定大小的栈？

在C语言中，可以使用静态数组来声明一个固定大小的栈。首先，你需要确定栈的最大容量，然后声明一个数组来存储栈的元素。例如，如果栈的最大容量是10，你可以这样声明一个栈：

#define MAX_SIZE 10

typedef struct {
    int data[MAX_SIZE];
    int top;
} Stack;

在这个例子中，data数组用于存储栈的元素，top变量用于指示栈顶的位置。

3. 如何声明一个动态大小的栈？

在C语言中，可以使用动态内存分配来声明一个动态大小的栈。首先，你需要使用malloc函数为栈的元素分配内存空间。例如，如果栈的最大容量是由用户输入的，你可以这样声明一个栈：

typedef struct {
    int *data;
    int top;
} Stack;

int main() {
    int max_size;
    printf("请输入栈的最大容量：");
    scanf("%d", &max_size);
    
    Stack stack;
    stack.data = (int*)malloc(max_size * sizeof(int));
    stack.top = -1;
    
    // 在这里可以使用栈进行操作
    
    free(stack.data); // 释放栈的内存空间
    
    return 0;
}

在这个例子中，data指针用于指向栈的元素，top变量用于指示栈顶的位置。需要注意的是，在使用完栈后，要记得使用free函数释放栈的内存空间，以避免内存泄漏。

原创文章，作者：Edit2，如若转载，请注明出处：https://docs.pingcode.com/baike/1032087

赞 (0)
Edit2Edit2
上一篇 2024年8月27日 下午2:45
下一篇 2024年8月27日 下午2:45
免费注册
电话联系

4008001024

微信咨询
微信咨询
返回顶部