C语言实现栈

• 代码

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

//链表的栈
typedef struct Node { //链表节点的自定义数据类型
    int val;
    struct Node *next;
} Node;

typedef struct Stack {
    Node *head;
} Stack;

Node *initNode(int val) { //初始化链表节点
    Node *n = (Node *)malloc(sizeof(Node));
    if (!n) return NULL;
    n->val = val;
    n->next = NULL;
    return n;
}

void freeNode(Node *p) { //释放链表节点
    if (p) free(p);
    return ;
}

Stack *initStack() { //初始化栈
    Stack *s = (Stack *)malloc(sizeof(Stack));
    s->head = NULL;
    return s;
}

void freeStack(Stack *s) {
    if (!s) return ;
    Node *p = s->head, *k;
    while (p) {
        k = p;
        p = p->next;
        freeNode(k);
    }
    free(s);
    return ;
}

int push(Stack *s, int val) { //入栈
    if (!s) return 0;
    Node *n = initNode(val);
    if (!n) return 0;
    n->next = s->head;
    s->head = n; //成为新的头
    return 1;
}

int isEmpty(Stack *s) {
    return !(s && s->head);
}

int pop(Stack *s) { //出栈
    Node *k = s->head;
    int tmp = k->val;
    s->head = k->next;
    freeNode(k);
    return tmp;
}

#if 0 //普通栈
typedef struct Stack {
    int *data, top, size;
} Stack;

Stack *initStack(int n) { //初始化栈
    Stack *s = (Stack *)malloc(sizeof(Stack));
    s->data = (int *)malloc(sizeof(int) * n);
    s->top = -1;
    s->size = n;
    return s;
}

void freeStack(Stack **saddr) { //释放栈
    if (!(*saddr)) return ;
    free((*saddr)->data);
    free(*saddr);
    *saddr = NULL;
}

int expand(Stack *s) { //栈的扩容
    if (!s) return 0;
    int expsize = s->size;
    int *tmp;
    while (expsize) {
        tmp = (int *)realloc(s->data, sizeof(int) * (s->size + expsize));
        if (tmp) break;
        expsize >>= 1; //右移1位表示除以2
    }
    if (!tmp) return 0;
    s->data = tmp;
    s->size += expsize;
    printf("expand successfully, size: %d\n", s->size);
    return 1;
}

int push(Stack *s, int val) { //入栈
    if (!s) return 0;
    if (s->top == s->size - 1 && 0 == expand(s)) return 0;
    s->data[++s->top] = val;
    return 1;
}

int isEmpty(Stack *s) {
    return !s || -1 == s->top;
}

int pop(Stack *s) { //出栈
    return s->data[s->top--];
}
#endif
int main() {
    return 0;
}