Stack栈

栈，用处很多，程序的中断等；FILO或LIFO，first in last out，last in first out

栈，有两种实现方法，一个是通过数组Array，另一个是通过链表Linked list。

通过Array

优点

1. 很容易实现，节省空间相对于链表，因为链表需要指针。

缺点

1. 由于数组是静态存储的，不能Grow和Shrink。

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

//represent stack by array
struct stack
{
    int top;
    unsigned capacity;
    int * array;
};
struct stack * creatStack(unsigned capacity)
{
    struct stack * new_stack = (struct stack *)malloc(sizeof(struct stack));
    new_stack->top = -1;
    new_stack->capacity = capacity;
    new_stack->array = (int *)malloc(new_stack->capacity * sizeof(int));
    printf("
Creat is OK!
");
    return new_stack;
}
int isFull(struct stack * s)
{
    return s->top == (s->capacity-1);
}
int isEmpty(struct stack *s)
{
    return s->top == -1;
}
void push(struct stack * s, int data)
{
    if(isFull(s))
    {
        printf("
The stack is full");
        return ;
    }
    //假如capacity为10
    // -1 0 1 2 3 4 5 6 7 8
    //  0 1 2 3 4 5 6 7 8 9
    s->array[++(s->top)] = data;
    printf("
 The %2d pushed to stack", data);
}
int pop(struct stack * s)
{
    if(isEmpty(s))
    {
        printf("
The stack is empty");
        return ;
    }
    return s->array[(s->top)--];
}
int main(void)
{
    struct stack * love = creatStack(10);
    push(love, 1);
    push(love, 2);
    push(love, 3);
    push(love, 4);
    push(love, 5);
    push(love, 6);
    push(love, 7);
    push(love, 8);
    push(love, 9);
    push(love, 10);

    int num = pop(love);
    printf("
Now the Stack top is %d", love->array[love->top]);
    return 0;
}

通过Linked list实现

优点

1. 链表存储时动态的，可以Grow和Shrink

缺点

1. 指针耗费空间资源

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

//Represent Stack on linked list.
struct Stack
{
    int data;
    struct Stack * next;
};
struct Stack * newNode(int data)
{
    struct Stack * newNode = (struct Stack *)malloc(sizeof(struct Stack));

    newNode->data = data;
    newNode->next = NULL;

    return newNode;
}
int isEmpty(struct Stack * root)
{
    return NULL == root;
}
void push(struct Stack ** root, int data)
{
    struct Stack * new_node = newNode(data);
    new_node->next = (*root);
    (*root) = new_node;

    printf("
%d pushed to Stack", data);
}
int pop(struct Stack ** root)
{
    if(isEmpty((*root)))
    {
        printf("The stack is empty");
        return -1;
    }
    struct Stack * node = (*root);
    int number = node->data;
    (*root) = node->next;

    free(node);
    return number;
}
int peek(struct Stack * root)
{
    if(isEmpty(root))
    {
        return INT_MIN;
    }

    return root->data;
}
int main(void)
{
    struct Stack * top = NULL;
    push(&top, 1);
    push(&top, 2);
    push(&top, 3);
    push(&top, 4);
    push(&top, 5);
    push(&top, 6);

    printf("
%d get out of the stack", pop(&top));
    printf("
The stack`s top is %d", peek(top));
    return 0;
}

人生如茶需慢品