数据结构 堆栈

堆栈的抽象数据类型描述

堆栈(Stack)：具有一定操作约束的线性表

• 只在一端（栈顶，Top）做插入、删除
• 后入先出：Last In First Out（FIFO）

类型名称：堆栈（stack）

数据对象集：一个有0个或多个元素的又穷线性表。

操作集：长度为MaxSize的堆栈S∈Stack，堆栈元素item∈ElementType

1、Stack CreateStack(int MaxSize)：生成空堆栈，其最大长度为MaxSzie;

2、int IsFull(Stack S, int MaxSize)：判断堆栈S是否已满

3、void Push(Stack S, ElementType item)：将元素item压入堆栈

4、int IsEmpty(Stack S)：判断堆栈S是否为空

5、ElementType Pop(Stack S)：删除并返回栈顶元素

栈的顺序存储实现

　　栈的顺序存储结构通常由一个一维数组和一个记录栈顶元素位置的变量组成。

#define MAXSIZE 100

typedef struct SNode *Stack;
struct SNode{
    ElementType Data[MAXSIZE];
    int Top;
}

入栈

void Push(Stack PtrS, ElementType item)
{
    if(PtrS->Top == MAXSIZE - 1) {
        printf("Stack full");
        return;
    } else {
        PtrS->Data[++(PtrS->Top)] = item;
        return; 
    }
}

出栈

ElementType Pop(Stack PtrS)
{
    if(PtrS->Top == -1) {
        printf("Stack Empty");
        return ERROR;
    } else
        return(PtrS->Data[(PtrS->Top)--]);
}

例子:请用要给数组实现两个堆栈，要求最大地利用数组空间，使数组只要有空间入栈操作就可以成功。

#define MAXSIZE 100
struct DStack{
    ElementType Data[MAXSIZE];
    int Top1;
    int Top2;
}S;
S.Top1 = -1;
S.Top2 = MAXSIZE;

void Push(struct DStack *PtrS, ElementType item, int Tag)
{
    if(PtrS->Top2 - PtrS->Top1 == 1) {
        printf("stack full");
        return;
    }
    if(Tag == 1)
        PtrS->Data[++(PtrS->Top1)] = item;
    else
        PtrS->Data[--(PtrS->Top2)] = item;
}

ElementType Pop(stuct DStack *PtrS, int Tag)
{
    if(Tag == 1) {
        if(PtrS->Top == -1) {
            ptintf("Stack1 Empty");
            return;
        } else {
            return(PtrS->Data[(PtrS->Top1)--])
        }
   } else {
       if(PtrS->Top2 == MAXSIZE) {
           printf("Stack2 Empty");
           return;
       } else {
           return PtrS->Data[(PtrS->Top2)--];
       }
   }
}

堆栈的链式存储实现

　　站的链式存储结构实际上就是一个单链表，叫做链栈。插入和删除操作智能在链栈的栈顶进行。栈顶指针Top应该在链表的哪一头？

typedef struct SNode *Stack;
struct SNode{
    ElementType Data;
    struct SNode *Next;
};

堆栈初始化

Stack CreateStack()
{
    Stack = s;
    S = (Stack)malloc(sizeof(struct SNode));
    S->Next = NULL;
    return S;
}

判断堆栈S是否为空

int IsEmpty(Stack S)
{
    return (S->Next == NULL);
}

push操作

void Push(ElementType item, Stack S)
{
    struct SNode *TmpCell;
    TmpCell = (SNode)malloc(sizeof(struct SNode));
    TmpCell->Data = item;
    TmpCell->Next = S->Next;
    S->Next = TmpCell;
}

pop操作

ElementType Pop(Stack S)
{
    struct SNode *FirstCell;
    ElementType TopElem;
    if(IsEmpty(S)) {
        printf("Stack Empty");
        return NULL;
    } else {
        FirstCell = S->Next;
        S->Next = FirstCell->Next;
        TopElem = FirstCell->Data;
        free(FirstCell);
        return TopElem;
    }
}