栈的顺序存储和链式存储

栈的基本概念

1.定义：栈是限定在表尾进行插入和删除操作的线性表。
注意：首先它是一个线性表，也就是说，栈元素之间具有线性关系，即前驱后继关系。只不过它是一个受限的线性表，它的特殊之处在于限制了这个线性表的插入和删除的位置，它始终只在栈顶进行，栈底是固定的，最先进入栈的元素只能放在栈底。
2.允许插入和删除元素的一端称为栈顶，另一端称为栈底，不含任何数据元素的栈称为空栈。栈又称为先进后出的线性表，简称FILO。
3.栈的插入操作，叫做压栈、入栈。类似于子弹如弹夹。栈的删除操作，叫做出栈、弾栈。

栈的顺序存储

"stack.h"

#pragma once

typedef int ELEM_TYPE;      //元素类型
#define STACK_INIT_SIZE 100 //存储空间初始分配量
#define STACKINCREMENT 10       //存储空间分配增量


typedef struct  
{
    ELEM_TYPE *base;
    ELEM_TYPE *top;
    int stacksize;
}SqStack;

void InitStack(SqStack *s);
void DestroyStack(SqStack *s);
void ClearStack(SqStack *s);
bool StackEmpty(SqStack s);
int StackLength(SqStack s);
void GetTop(SqStack s,ELEM_TYPE *e);
void Push(SqStack *s,ELEM_TYPE e);
void Pop(SqStack *s,ELEM_TYPE *e);
void showStack(SqStack s);

"stack.cpp"

#include "stack.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>

void InitStack(SqStack *s)
{
    s->base = (ELEM_TYPE *)malloc(STACK_INIT_SIZE * sizeof(ELEM_TYPE));
    if (!s->base)
    {
        exit(EXIT_FAILURE);
    }
    s->top = s->base;
    s->stacksize = STACK_INIT_SIZE;
}

void Push(SqStack *s,ELEM_TYPE e)
{
    if (s->top-s->base >= STACK_INIT_SIZE)//栈满，追加存储空间
    {
        s->base = (ELEM_TYPE *)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(ELEM_TYPE));
        if (!s->base)
        {
            exit(EXIT_FAILURE);//存储分配失败
        }
        s->top = s->base + s->stacksize;
        s->stacksize += STACKINCREMENT;
    }
    *s->top++ = e;
}

void Pop(SqStack *s,ELEM_TYPE *e)
{
    if (s->top == s->base)
    {
        printf("栈空\n");
        return;
    }
    *e = *--s->top; 
}

void DestroyStack(SqStack *s)
{
    free(s->base);
    s->base = NULL;
}
void ClearStack(SqStack *s)
{
    while (s->top != s->base)
    {
        Pop(s,s->base);
    }
}

bool StackEmpty(SqStack s)
{
    if (s.top == s.base)
    {
        return true;
    }
    else
    {
        return false;
    }
}

int StackLength(SqStack s)
{
    int len = 0;
    while(s.top != s.base)
    {
        len++;
        s.top--;
    }
    return len;
}

void GetTop(SqStack s,ELEM_TYPE *e)
{
    if (s.top == s.base)
    {
        printf("栈空\n");
        return;
    }
    *e = *(s.top-1);
}

void showStack(SqStack s)
{
    assert(s.base != NULL);
    while (s.base != s.top)
    {
        printf("%d\n",*--s.top);;
    }
}

栈的链式存储

"linkstack.h"

#pragma once

typedef char ELEM_TYPE;

typedef struct SNode 
{
    ELEM_TYPE data;
    struct SNode *next;
}SNode,*StackPtr;

typedef struct  
{
    StackPtr top;
    int count;
}LinkStack;

void InitStack(LinkStack *s);
void Push(LinkStack *s,ELEM_TYPE e);
char Pop(LinkStack *s);
char Top(LinkStack s);
void ShowStack(LinkStack s);
int StackLength(LinkStack s);
bool StackEmpty(LinkStack s);
void ClearStack(LinkStack *s);
void DestroyStack(LinkStack *s);

"linkstack.cpp"

#include "linkstack.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

void InitStack(LinkStack *s)
{
    s->top = NULL;
    s->count = 0;
}

void Push(LinkStack *s,ELEM_TYPE e)
{
    StackPtr p = s->top;
    StackPtr newNode = (StackPtr)malloc(sizeof(SNode));
    newNode->data = e;
    newNode->next = p;
    s->top = newNode;
    s->count++;
}

char Pop(LinkStack *s)
{
    StackPtr p = s->top;
    if (!p)
    {
        printf("栈空\n");
        exit(EXIT_FAILURE);
    }
    char result = p->data;
    s->top = p->next;
    s->count--;
    free(p);
    return result;
}

char Top(LinkStack s)
{
    StackPtr p = s.top;
    assert(p != NULL);
    return p->data;
}

bool StackEmpty(LinkStack s)
{
    return s.top == NULL;
}

void ShowStack(LinkStack s)
{
    StackPtr p = s.top;
    if (!p)
    {
        printf("栈为空\n");
        return;
    }
    while (p)
    {
        printf("data:%d\n",p->data);
        p = p->next;
    }
}

int StackLength(LinkStack s)
{
    StackPtr p = s.top;
    assert(p != NULL);
    int i = 0;
    while (p)
    {
        ++i;
        p = p->next;
    }
    return i;
}

void ClearStack(LinkStack *s)
{
    StackPtr p = s->top;
    assert(p != NULL);
    while (p)
    {
        s->top = p->next;
        free(p);
        s->count--;
        p = s->top;
    }
}

void DestroyStack(LinkStack *s)
{
    StackPtr p = s->top;
    if (!p)
    {
        return;
    }
    while (p)
    {
        s->top = p->next;
        free(p);
        s->count--;
        p = s->top;
    }
}