栈---C语言实现

殊线性表

栈

栈是一种特殊的线性表，它只能在表尾进行插入和删除操作，就像下面这样

也就是说，我们只能在一端进行插入和删除，当我们依次插入1，2，3，4这四个元素后，连续进行四次删除操作，删除的顺序刚好相反：4、3、2、1，我们一般将其竖着看

底部称为栈底，顶部称为栈顶，所有的操作只能在栈顶进行，也就是说，被压在下方的元素，只能等待其上方的元素出栈后才能取出，就像我们往箱子里面放的书一样，因为只有一个口取出里面的物品，所以被压在下面的书只能等上面的书被拿出来之后才能取出，这就是栈的思想，它是一种先进后出的数据结构  

可以基于顺序表，链表都可以实现栈

这里我们需要实现两个新的操作：

              ·pop：出栈操作，从栈顶取出一个元素

              ·push：入栈操作，向栈中压入一个新元素

按顺序表来编写栈

初始化步骤

push 入栈操作

将元素添加至栈顶 将top向上移一格 将要插入的元素放置到top的位置即可。

优化一下

输出打印

·

优化一下 考虑到顺序表存在最大上限存储的情况 如果不够用就扩容

       判断栈是否满  满了就扩容

将原先的插入函数修改

       增加扩容功能     

定义一个动态的扩容因数，无论超过最大存储容量几次，使其始终能扩容到其原先容量的1.5倍

完整的插入函数与顺序表的插入类似

入栈编写完成

出栈操作

             

打印输出 出栈顺序

有些时候，栈的利用率可能会比较低，这个时候我们可以将一个固定长度的数组共享给两个栈来使用：

数组的两头分别作为两个栈的栈底，当两个栈顶相遇时，表示栈已满。通过这种方式，我们就可以将数组占用的空间更充分地使用，这样的栈我们称为共享栈。

#include "stdlib.h"
#include "stdio.h"
//定义初始化长度
#define length 10
typedef int E;
struct Stack{
    E * array;
    int capacity;
    int top;
};
typedef struct Stack * ArrayStack;
int newTheStack(ArrayStack stack){
    stack->array = malloc(sizeof (E) * length);
    if(stack->array == NULL) return 0;
    stack->capacity = length;
    stack->top = -1;
    return 1;
}
int pushStack(ArrayStack stack, int element){
    //这边++stack->top在if判断时已近自增所以后面就不用自增了
    if(++stack->top == stack->capacity){//此时相等就说明满了
        int size = stack->capacity + (stack->capacity >> 1);
        E * newStack = realloc(stack->array, size * sizeof (E));
        if(newStack == NULL) return 0;
        stack->array = newStack;
        stack->capacity = size;
    }
    stack->array[stack->top] = element;
    return 1;
}
//判断栈是否为空
_Bool isEmpty(ArrayStack stack){
    return stack->top == -1;
}
E popStack(ArrayStack stack){
    //出栈完成后 top自减
    return stack->array[stack->top--];
}
void printStack(ArrayStack stack){
    for (int i = 0; i < stack->top + 1; ++i) {
        printf("%d, ",stack->array[i]);
    }
}
int main(){
    struct Stack stack;
    newTheStack(&stack);
    for(int i = 0; i < 20; ++i){
        pushStack(&stack, i * i);
    }
    printStack(&stack);
    printf("\n");
    while(!isEmpty(&stack)){
        printf("%d, ", popStack(&stack));
    }
}

后面使用链表来实现 （更方便）

       直接将头节点指向栈顶结点，而栈顶结点链接后续的站内结点：当有新元素入栈，只需要在头部插入新的结点即可

初始化定义

入栈操作

       将新插入的元素的指针指向头结点指向的元素，将头结点指针指向新插入的元素

              即将新插入的元素放在第一个

输出函数

打印输出

出栈

整体代码如下：

#include "stdio.h"
#include "stdlib.h"

typedef int E;

struct ListNode{
    E element;
    struct ListNode * next;
};

typedef struct ListNode * Node;

void newTheNode(Node node){
    node->next = NULL;
}
int pushStack(Node node, int element){
    Node newNode = malloc(sizeof (struct ListNode));
    if(newNode == NULL) return 0;
    newNode->next = node->next;
    node->next = newNode;
    newNode->element = element;
    return 1;
}
int printNode(Node node){
    while (node->next){
        node = node->next;
        printf("%d ", node->element);
    }
    printf("\n");
}
_Bool isEmpty(Node node){
    return node->next ==  NULL;
}
//出栈
E popStack(Node node){
    Node tmp = node->next;
    E newElement = tmp->element;
    node->next = node->next->next;
    free(tmp);
    return newElement;
}
int main(){
    struct ListNode node;
    newTheNode(&node);
    for(int i = 0; i < 3; ++i){
        pushStack(&node, i*i+2);
    }
    printNode(&node);
    while (!isEmpty(&node)){
        printf("%d ", popStack(&node));
    }
}