栈（ADT）

1.概念:栈是限制插入和删除只能在一个位置上进行的表
2.注意知识点:
(1).后进先出的特点(LIFO)
(2).存在某个元素位于栈顶，而该元素是唯一可见的元素。
(3).栈的两种实现方式 ：数组、链表
3.栈的基本操作：
1、数组实现：
（1）.入栈（push）和出栈（pop）

#include <stdio.h>
#define maxsize 10
typedef int ElementType;
typedef struct
{
    ElementType data[maxsize];
    int top1;//栈的栈顶指针  
}stack;
void push(stack *s,ElementType num)
{
    if(s->top1 == maxsize-1)
    {
        printf("栈满\n");
        return;
    }
    else
    {
        s->data[++(s->top1)] = num;
        return;
    }
}
ElementType pop(stack *s)
{
    if(s->top1 == -1)
    {
        printf("栈空！\n");
        return 0;
    }
    else
    return s->data[(s->top1)--];
}
int main()
{
    stack s;
    int t;
    for(int i = 0;i<3;i++)
    {
        push(&s,i);

    }
    for(int i =0;i<3;i++)
    {
        t = pop(&s);
        printf("%d",t);
    }

} 

运行结果 ：
(2).两个堆栈的实现入栈、出栈

#include <stdio.h>
#define maxsize 10
typedef struct
{
    int data[maxsize];
    int top1 ;//栈1的栈顶指针
    int top2 ;//栈2 的栈顶指针 
}stack;
void push(stack *s,int num,int tag)
{
    if(s->top1 == s->top2)//**判断栈是否满**
    printf("栈满！\n");
    else
    {
        if(tag == 1)
        {
            s->data[++(s->top1)] = num;//对第一个栈进行操作 
        }
        else
        s->data[--(s->top2)] = num;// 对第二个栈进行操作
    } 

} 
int pop(stack *s,int tag)
{
    if(tag == 1)
    {
        if(s->top1 == -1)
        printf("栈空！\n");
        else
        return s->data[(s->top1)--];//对第一个栈进行操作 
    } 
    else
    {
        if(s->top2 == maxsize)
        printf("栈空！\n");
        else
        return s->data[(s->top2)++]; 
    } 

}
int main()
{
    int tag;
    scanf("%d",&tag);
    int i,t;
    stack s;
    s.top1 = -1;s.top2 = maxsize;
    for(i = 0;i<4;i++)
    {
        push(&s,i,tag);
    }
    for(i = 0;i<4;i++)
    {
        t = pop(&s,tag);
        printf("%d\t",t); 
    }       
} 

运行结果：
（3）、判断栈是否为空

int Isempty(stack *s)
{
    return s->top1 == -1;
}

（4）、判断栈是否满

int IsFull(stack *s)
{
    return s->top1 == maxsize-1;
}

2、链表实现：
（1）、建立空栈并判断是否为空

#include <stdio.h>
#include <stdlib.h> 
typedef struct Node
{
    int data;
    struct * next;
}stack;
stack *createstack(stack *s)
{
    s = (stack *)malloc(sizeof(struct Node));
    if(s == NULL)
    {
        printf("no space!\n");
        return NULL;
    }
    else
    {
        s->next = NULL;
        return s;
    } 
}
int Isempty(stack *s)
{
    return s->next == NULL;//判断栈是否为空，为空返回1，否返回0 
}
int main() 
{
    stack *s;
    s = createstack(s);
    int n = Isempty(s);
    printf("%d",n);
}

输出结果：
（2）、push（入栈 ）(因为是动态申请内存，不用判断是否满栈）

void push(int num,stack *s)
{   //将num压入栈 
    stack *p = (stack*)malloc(sizeof(stack));
    p->data = num;
    p->next = s->next;
    s->next = p; 
 }

（3）、从栈弹出元素（pop）并返回栈顶元素

 int pop(stack *s)
{
    //删除并返回栈顶元素 
    stack *p;
    int temp;
    if(Isempty(s))
    {
        printf("栈空！\n");
        return 0;
    }
    else
    {
        p = s->next;
        s->next = p->next;
        temp = p->data;
        free(p);
        return temp;
    }
} 

链表实现的完整代码：

#include <stdio.h>
#include <stdlib.h> 
typedef struct Node
{
    int data;
    struct Node * next;
}stack;
stack *createstack(stack *s)
{
    s = (stack *)malloc(sizeof(struct Node));
    if(s == NULL)
    {
        printf("no space!\n");
        return NULL;
    }
    else
    {
        s->next = NULL;
        return s;
    } 
}
int Isempty(stack *s)
{
    return s->next == NULL;//判断栈是否为空，为空返回1，否返回0 
}
void push(int num,stack *s)
{   //将num压入栈 
    stack *p = (stack*)malloc(sizeof(stack));
    p->data = num;
    p->next = s->next;
    s->next = p; 
 } 
int pop(stack *s)
{
    //删除并返回栈顶元素 
    stack *p;
    int temp;
    if(Isempty(s))
    {
        printf("栈空！\n");
        return 0;
    }
    else
    {
        p = s->next;
        s->next = p->next;
        temp = p->data;
        free(p);
        return temp;
    }
} 
int main() 
{
    stack *s;int num;
    s = createstack(s);
    int n = Isempty(s);
    for(int i = 0;i<2;i++)
    {
        push(i,s);
    }
    for(int i = 0;i<2;i++)
    {

        num = pop(s);
        printf("%d\t",num);
    }
}

运行结果：