DataStructure-3-栈

3.1 栈

   3.1.1栈

    栈是限定仅在表尾进行插入删除操作的线性表,允许插入删除的一端称为栈顶,另一端称为栈底,不含任何数据元素的栈称为空栈.

3.2 顺序栈

    3.2.1顺序栈

    栈的顺序存储结构称为顺序栈.

  

    3.2.2顺序栈的实现

   SeqStack.h:

#ifndef SEQSTACK_H
#define SEQSTACK_H

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

//const int StackSize=10;

typedef char DataType;

typedef struct SeqStack
{
    DataType *data;
    int top;
}SeqStack;

int InitStack(SeqStack *s);     //初始化栈
int Push(SeqStack *s,DataType e); //入栈
DataType Pop(SeqStack *s); //出栈
DataType GetTop(SeqStack *s); //取栈顶元素

#endif

SeqStack.c:

include "SeqStack.h"

const int StackSize = 10;


int InitStack(SeqStack *s)
{
    s->data=(DataType*)malloc(StackSize*sizeof(DataType));

    if(s->data == NULL)
    {
        printf("InitStack Error!\n");
        return 0;
    }
    s->top = -1;  //代表栈为NULL
    return 1;
}

int Push(SeqStack *s,DataType e)
{
    if(s->top == StackSize - 1) //栈满
    {
         printf("Stack is full!\n");
        return 0;
    }
    s->top++;
    s->data[s->top] = e;

    return 1;
}

DataType Pop(SeqStack *s)
{
    DataType e;
    if(s->top == -1)   //栈空
    {
        printf("Stack is null!\n");
        return 0;
    }
    e = s->data[s->top];
    s->top--;
    return e;
}

DataType GetTop(SeqStack *s)
{
    DataType e;
    if(s->top == -1) //栈空
    {
        printf("Stack is null!\n");
        return 0;
    }
    return e = s->data[s->top];
}

main.c:

#include "SeqStack.h"

int main(void)
{
    int i;
    SeqStack s;
    //初始化
    InitStack(&s);
    //入栈
    for(i=0;i<5;i++)
    {
        Push(&s,i);
    }
    //出栈
    printf("Pop:%d\n",Pop(&s));
    //取栈顶元素
    printf("GetTop:%d\n",GetTop(&s));
}

   

 

3.3两栈共享内存

    3.3.1两栈共享内存

     当存储栈的数组中没有空闲单元时为栈满,此时栈1的栈顶元素和栈2的栈顶元素位于数组中的相邻位置,即top1=top2-1(或top2=top1+1)。另外，当新元素插入栈2时，栈顶指针top2不是加1而是减1。

    3.3.2两栈共享内存的实现

   BothStack.h:

#ifndef BOTHSTACK_H
#define BOTHSTACK_H

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

//const int StackSize=10;

typedef char DataType;

typedef struct BothStack
{
    DataType *data;
    int top1;
    int top2;
}BothStack;

int InitStack(BothStack *b);     //初始化栈
int Push(BothStack *b,int i,DataType e); //入栈,i=1代表入栈1，i=2代表入栈2
DataType Pop(BothStack *b,int i); //出栈
DataType GetTop(BothStack *b,int i); //取栈顶元素

#endif

  BothStack.c:

#include "BothStack.h"

const int StackSize = 10;


int InitStack(BothStack *b)
{
    b->data=(DataType*)malloc(StackSize*sizeof(DataType));

    if(b->data == NULL)
    {
        printf("InitStack Error!\n");
        return 0;
    }
    b->top1 = -1;  //代表栈1为NULL
    b->top2 = StackSize; //代表栈2为NULL

    return 1;
}

int Push(BothStack *b,int i,DataType e)
{
    if(b->top1 == b->top2-1) //栈满
    {
        printf("top1:%d\n",b->top1);
        printf("top2:%d\n",b->top2);
        printf("Stack is full!\n");
        return 0;
    }
    if(i==1)
    {
        b->top1++;
        b->data[b->top1] = e;
        printf("top1 push locate:%d\n",b->top1);
    }
    if(i==2)
    {
        b->top2--;
        b->data[b->top2] = e;
        printf("top2 push locate:%d\n",b->top2);
        }

    return 1;
}

DataType Pop(BothStack *b,int i)
{
    DataType e;
    if(i==1)
    {
        if(b->top1 == -1)   //栈空
        {
            printf("Stack1 is null!\n");
            return 0;
        }
        e=b->data[b->top1];
        b->top1--;
        return e;
    }
    if(i==2)
    {
          if(b->top2 == StackSize)   //栈空
        {
            printf("Stack2 is null!\n");
            return 0;
        }
        e=b->data[b->top2];
        b->top2++;
        return e;
    }

    return 0;
}

DataType GetTop(BothStack *b,int i)
{
    if(i==1)
    {
        if(b->top1 == -1)   //栈空
        {
            printf("Stack1 is null!\n");
            return 0;
        }
        return b->data[b->top2];
    }

 if(i==2)
    {
        if(b->top2 == StackSize)   //栈空
        {
            printf("Stack2 is null!\n");
            return 0;
        }
        return b->data[b->top2];
    }

    return 0;
}

  main.c:

#include "BothStack.h"

int main(void)
{
    int i;
    int j;
    BothStack b;
    //初始化
    InitStack(&b);
    //入栈1
    for(i=0;i<3;i++)
    {
        Push(&b,1,i);
    }
    //入栈2
    for(j=0;j<3;j++)
    {
        Push(&b,2,j);
    }

    //出栈1
    printf("Stack1 Pop:%d\n",Pop(&b,1));
    //出栈2
    printf("Stack2 Pop:%d\n",Pop(&b,2));
    //取栈1顶元素
    printf("Stack1 GetTop:%d\n",GetTop(&b,1));
    //取栈2顶元素
    printf("Stack2 GetTop:%d\n",GetTop(&b,2));
}

3.4链栈

    3.4.1链栈

    栈的链接存储结构称为链栈

栈的结构:

 

  入栈:                                                   出栈:

      

    3.4.2链栈的实现

  LinkStack.c :

#ifndef LINKSTACK_H
#define LINKSTACK_H

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

typedef int DataType;

typedef struct Node
{
    DataType data;
    struct Node *next;
}Node,*LinkStack;

int InitLinkStack(LinkStack *L);
int Push(LinkStack *L,DataType e);
DataType Pop(LinkStack *L);
DataType GetTop(LinkStack *L);

#endif

  LinkStack.c :

#include "LinkStack.h"

int InitLinkStack(LinkStack *L)
{
    (*L) = (LinkStack)malloc(sizeof(LinkStack));
    if(*L == NULL)
    {
        printf("Init Error!\n");
        return 0;
    }
    (*L)->next = NULL;
    return 1;
}
/*必须使用头插法压栈，此时(*L)是头节点,(*L)->next是栈顶元素*/
int Push(LinkStack *L,DataType e)
{
    Node *p;
    p = (Node *)malloc(sizeof(Node));
    p->data=e;
    p->next = (*L)->next;
    (*L)->next = p;
}

DataType Pop(LinkStack *L)
{
    DataType e;
    Node *q;
    if(*L == NULL)
    {
        printf("LinkStack is NULL!\n");
        return 0;
    }
    e = (*L)->next->data;
    q = (*L)->next;
    (*L) = (*L)->next->next;
    free(q);
    return e;
}

DataType GetTop(LinkStack *L)
{
    if(*L == NULL)
    {
        printf("LinkStack is NULL!\n");
        return 0;
    }
    return (*L)->data;
}

  main.c :

#include "LinkStack.h"

int main(void)
{
    LinkStack L;
    //初始化
    InitLinkStack(&L);
    //入栈
    Push(&L,1);
    Push(&L,2);
    //出栈
    printf("Pop:%d\n",Pop(&L));
    //获取栈顶元素
    printf("GetTop:%d\n",GetTop(&L));
    return 0;
}