C语言实现栈的构建、入栈、出栈、取栈顶元素等基本操作

C语言实现栈的构建、入栈、出栈、取栈顶元素等基本操作

一 栈的定义

  在文章的开头，小编强调一句：小编知道C++的STL中有现成的stack，可以直接拿来用，但是这里小编还是用C语言来实现stack的基本操作，请大家不要喷小编，小编伤不起呀！！！
  栈最重要的性质是：后进先出。性质大家都知道，关键是如何运用栈后进先出的性质解决题目。
  好了，话不多说，咱们直接进入正题，其结构定义如下：

typedef struct Stack {
    int *data;  //存储栈中元素
    int top, size;  //top: 栈顶元素下标， size: 栈的大小
} Stack;

二 向栈中插入元素

  向栈中插入元素很简单，只要将栈顶指针上移，同时将待插入的值，插入到栈顶，唯一需要注意的是，当栈满了之后，我们需要进行栈的扩容操作。
  元素入栈的示意图如下：

对应实现代码如下：

bool expand(Stack *s) {  //栈 扩容
    if (!s) return false;
    int *tmp = NULL;
    int extra_size = s->size;
    //一般栈的扩容是扩大为原来大小的两倍
    //但是可能内存空间无法满足，此时申请的内存空间就要少一些了，这也是while循环的作用
    while (extra_size) {
        tmp = (int *)realloc(s->data, sizeof(int) * (s->size + extra_size));
        if (tmp) break;
        extra_size /= 2;
    }
    if (!tmp) return false;
    s->size += extra_size;
    s->data = tmp;
    return true;
}

bool push(Stack *s, int val) {  //入栈
    if (!s) return false;
    if (s->top == s->size - 1) {
        if (expand(s)) printf("expand success\n");
        else {
            printf("expand failed\n");
            return false;
        }
    }
    s->data[++s->top] = val;
    return true;
}

三 弹出栈顶元素

  注意弹出栈顶元素和取栈顶元素之间的区别，前者栈中不再存在，后者只是拿栈顶元素出来看看。
  弹栈示意图如下：

实现代码如下：

bool pop(Stack *s) {  //出栈
    if (!s || empty(s)) return false;  //栈空或者指针为空，返回false
    s->top--;
    return true;
}

四 取栈顶元素、判断栈空、删除栈、输出栈中元素 操作

这四个操作的实现没有复杂的逻辑，所以此处直接展示代码

bool empty(Stack *s) {  //判空
    return s->top == -1;
}

int top(Stack *s) {  //返回栈顶元素
    return s->data[s->top];
}

void output(Stack *s) {  //输出栈中元素
    if (!s) return ;
    printf("stack(%d) = [", s->top + 1);
    for (int i = 0; i <= s->top; i++) {
        if (i) printf(", ");
        printf("%d", s->data[i]);
    }
    printf("]\n");
}

void clear(Stack *s) {  //删除栈
    if (!s) return ;
    free(s->data);
    free(s);
}

五 总代码献上

#include <iostream>
using namespace std;

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

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

bool empty(Stack *s) {  //判空
    return s->top == -1;
}
int top(Stack *s) {  //返回栈顶元素
    return s->data[s->top];
}

bool expand(Stack *s) {  //栈 扩容
    if (!s) return false;
    int *tmp = NULL;
    int extra_size = s->size;
    while (extra_size) {
        tmp = (int *)realloc(s->data, sizeof(int) * (s->size + extra_size));
        if (tmp) break;
        extra_size /= 2;
    }
    if (!tmp) return false;
    s->size += extra_size;
    s->data = tmp;
    return true;
}
bool push(Stack *s, int val) {  //入栈
    if (!s) return false;
    if (s->top == s->size - 1) {
        if (expand(s)) printf("expand success\n");
        else {
            printf("expand failed\n");
            return false;
        }
    }
    s->data[++s->top] = val;
    return true;
}

bool pop(Stack *s) {  //出栈
    if (!s || empty(s)) return false;
    s->top--;
    return true;
}

void output(Stack *s) {  //输出栈中元素
    if (!s) return ;
    printf("stack(%d) = [", s->top + 1);
    for (int i = 0; i <= s->top; i++) {
        if (i) printf(", ");
        printf("%d", s->data[i]);
    }
    printf("]\n");
}

void clear(Stack *s) {  //删除栈
    if (!s) return ;
    free(s->data);
    free(s);
}

int main() {
    srand(time(0));
    #define MAX_OP 20
    int op, val;
    Stack *s = init(1);
    for (int i = 0; i < MAX_OP; i++) {
        val = rand() % 100;
        op = rand() % 4;
        switch (op) {  //之所以这样，插入元素的频率比删除多，代码演示效果才好
            case 0:
            case 1:
            case 2: {
                printf("insert %d into stack = %d\n", val, push(s, val));
                break;
            }
            case 3: {
                printf("pop %d from stack = ", top(s));
                printf("%d\n", pop(s));
                break;
            }
            default: {
                printf("it's impossible\n");
            }
        }
        output(s);
        printf("\n");
    }
    clear(s);
    return 0;
}
/*代码输出：
insert 40 into stack = 1
stack(1) = [40]

expand success
insert 79 into stack = 1
stack(2) = [40, 79]

pop 79 from stack = 1
stack(1) = [40]

insert 94 into stack = 1
stack(2) = [40, 94]

expand success
insert 17 into stack = 1
stack(3) = [40, 94, 17]

pop 17 from stack = 1
stack(2) = [40, 94]

insert 68 into stack = 1
stack(3) = [40, 94, 68]

insert 69 into stack = 1
stack(4) = [40, 94, 68, 69]

expand success
insert 23 into stack = 1
stack(5) = [40, 94, 68, 69, 23]

insert 7 into stack = 1
stack(6) = [40, 94, 68, 69, 23, 7]

insert 91 into stack = 1
stack(7) = [40, 94, 68, 69, 23, 7, 91]

insert 27 into stack = 1
stack(8) = [40, 94, 68, 69, 23, 7, 91, 27]

pop 27 from stack = 1
stack(7) = [40, 94, 68, 69, 23, 7, 91]

insert 34 into stack = 1
stack(8) = [40, 94, 68, 69, 23, 7, 91, 34]

pop 34 from stack = 1
stack(7) = [40, 94, 68, 69, 23, 7, 91]

insert 46 into stack = 1
stack(8) = [40, 94, 68, 69, 23, 7, 91, 46]

expand success
insert 4 into stack = 1
stack(9) = [40, 94, 68, 69, 23, 7, 91, 46, 4]

pop 4 from stack = 1
stack(8) = [40, 94, 68, 69, 23, 7, 91, 46]

insert 21 into stack = 1
stack(9) = [40, 94, 68, 69, 23, 7, 91, 46, 21]

insert 75 into stack = 1
stack(10) = [40, 94, 68, 69, 23, 7, 91, 46, 21, 75]
*/

六 关于栈的思考

  栈先入后出的性质深入人心，我们在用栈时，绝大部分都是使用栈的这个性质，甚至我们熟悉的递归函数也是通过系统栈实现的 (系统栈的大小为 8MB，所以递归层数过深才会出现爆栈这样的情况)， 但是栈是否还有别的特殊的性质呢？
  大家都知道关于栈的一个典型题目就是括号匹配问题，详情点击我，我们用到的就是栈，关于具体的实现代码，小编这里不想赘述，只是想说一说括号匹配这道题该自己带来的思考。

  我们把括号的(看成事件的开始，把)看成事件的结束，那么一个完整的括号()就表示一个完整的事件，而括号之外又有括号，这就是事件之间的完全包含关系，由此我们知道栈可以用来解决完全包含关系的问题 （重要）！！！！！！！
  最后小编在抛出最后一个疑问：树和完全包含关系之间有什么关系？这和栈又有什么关系？？？

  这一点，小编在二叉树部分进行了阐述，此处不再赘述， 详情请点击我进行跳转。

  加油，穷且益坚，不坠青云之志！吾将天天敲代码！