【数据结构实验三】 顺序栈和链栈的基本操作（动态分配）

目录

一、顺序栈 

二、链栈

---

一、顺序栈 

输入格式:

第1行输入若干个构成顺序栈的数字，使用-1结束，例如：1 2 3 4 5 -1。

第2行，输入一个要入栈的数字。例如：66

输出格式:

参照主函数及输出样例。

测试数据在1~99之间的整数，输出格式使用%3d。

输入样例:

1 2 3 4 5 6 -1
66

输出样例:

顺序栈里的元素有：  6  5  4  3  2  1
顺序栈S中元素的个数：6
元素66正在入栈...
顺序栈里的元素有： 66  6  5  4  3  2  1
出栈操作...
出栈的元素是：66
出栈操作...
出栈的元素是：6
顺序栈里的元素有：  5  4  3  2  1
栈顶的元素是：5
顺序栈里的元素有：  5  4  3  2  1
正在清空栈...
栈为空！

#include 
#include 
#define STACK_INIT_SIZE 10
#define STACKINCREMENT 2

typedef int SElemType;
typedef struct
{
    SElemType *base;  // 栈底指针
    SElemType *top;  // 栈顶指针
    int stacksize;  // 当前分配的空间
}SqStack;

void InitStack(SqStack &S);  // 构造一个空栈
void PushStack(SqStack &S, SElemType e); // 将e入栈
void PopStack(SqStack &S, SElemType &e); // 出栈，删除栈顶元素并返回给e
void CreatStack(SqStack &S); // 通过连续输入构造一个栈(已知)
void PrintStack(SqStack &S); // 输出栈里的元素(已知)
int LengthStack(SqStack &S); // 栈里元素的个数
void GetTopStack(SqStack &S, SElemType &e); // 获取栈顶元素
void ClearStack(SqStack &S); // 清空栈即将栈置为空栈

int main()
{
    SqStack S;
    SElemType e;
    InitStack(S);
    CreatStack(S);
    scanf("%d", &e);
    PrintStack(S);
    printf("顺序栈S中元素的个数：%d\n", LengthStack(S));
    printf("元素%d正在入栈...\n", e);
    PushStack(S, e);
    PrintStack(S);
    printf("出栈操作...\n");
    PopStack(S, e);
    printf("出栈的元素是：%d\n", e);
    printf("出栈操作...\n");
    PopStack(S, e);
    printf("出栈的元素是：%d\n", e);
    PrintStack(S);
    GetTopStack(S, e);
    printf("栈顶的元素是：%d\n", e);
    PrintStack(S);
    printf("正在清空栈...\n");
    ClearStack(S);
    PrintStack(S);

    return 0;
}

void CreatStack(SqStack &S)
{
    SElemType e;
    scanf("%d", &e);
    while(e != -1)
    {
        PushStack(S, e);
        scanf("%d", &e);
    }
    return;
}

void PrintStack(SqStack &S)
{
    if(S.base == S.top)
    {
        printf("栈为空！\n");
        return;
    }
    printf("顺序栈里的元素有：");
    for(SElemType *p=S.top-1; p>=S.base; p--)
        printf("%3d", *p);
    printf("\n");
    return;
}

void InitStack(SqStack &S)
{
    S.base = (SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
    if(!S.base)
    {
        printf("初始化栈失败！\n");
        return;
    }
    S.top = S.base;
    S.stacksize = STACK_INIT_SIZE;
    return;
}

void PushStack(SqStack &S, SElemType e)
{
    if(S.top-S.base>=S.stacksize)
    {
        S.base = (SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
        if(!S.base)
        {
            printf("空间申请失败！\n");
            return;
        }
        S.top = S.base+S.stacksize;
        S.stacksize+=STACKINCREMENT;
    }
    *S.top++=e;
    return;
}

void PopStack(SqStack &S, SElemType &e)
{
    if(S.top==S.base)
    {
        printf("栈为空！\n");
        e=-1;
        return;
    }
    e = *--S.top;
    return;
}

int LengthStack(SqStack &S)
{
    return S.top-S.base;
}

void GetTopStack(SqStack &S, SElemType &e)
{
    if(S.top==S.base)
    {
        printf("栈为空！\n");
        e=-1;
        return;
    }
    e=*(S.top-1); //这里不能是S.top--
    return;
}

void ClearStack(SqStack &S)
{
    S.top = S.base;
    return;
}

二、链栈

输入格式:

第1行输入若干个构成链栈的数字，使用-1结束，例如：1 2 3 4 5 -1。

第2行，输入一个要入栈的数字。例如：66

输出格式:

参照主函数及输出样例。

测试数据在1~99之间的整数，输出格式使用%3d。

输入样例:

1 2 3 4 5 -1
66

输出样例:

栈里的元素有：  5  4  3  2  1
栈内元素的个数：5
将元素66入栈...
栈里的元素有： 66  5  4  3  2  1
出栈操作...
出栈的元素是：66
出栈操作...
出栈的元素是：5
栈里的元素有：  4  3  2  1
获取栈顶元素...
栈顶的元素是：4
栈里的元素有：  4  3  2  1
正在销毁栈...
栈已销毁！

#include 
#include 
typedef int SElemType;
typedef struct LNode
{
    SElemType data;
    struct LNode *next;
}LStackNode, *LinkStack;

void InitStack(LinkStack &Top);
void PushStack(LinkStack &Top, SElemType e);
void PopStack(LinkStack &Top, SElemType &e);
void CreatStack(LinkStack &Top); //已知
void PrintStack(LinkStack &Top); //已知
void GetTopStack(LinkStack &Top, SElemType &e);
int LengthStack(LinkStack &Top);
void FreeStack(LinkStack &Top);

int main()
{
    LinkStack Top;
    SElemType e;
    InitStack(Top);
    CreatStack(Top);
    scanf("%d", &e);
    PrintStack(Top);
    printf("栈内元素的个数：%d\n", LengthStack(Top));

    printf("将元素%d入栈...\n", e);
    PushStack(Top, e);
    PrintStack(Top);

    printf("出栈操作...\n");
    PopStack(Top, e);
    printf("出栈的元素是：%d\n", e);
    printf("出栈操作...\n");
    PopStack(Top, e);
    printf("出栈的元素是：%d\n", e);
    PrintStack(Top);

    printf("获取栈顶元素...\n");
    GetTopStack(Top, e);
    printf("栈顶的元素是：%d\n", e);
    PrintStack(Top);

    printf("正在销毁栈...\n");
    FreeStack(Top);

    return 0;
}

void CreatStack(LinkStack &Top)
{
    SElemType e;
    scanf("%d", &e);
    while(e != -1)
    {
        PushStack(Top, e);
        scanf("%d", &e);
    }
    return;
}

void PrintStack(LinkStack &Top)
{
    if(Top->next == NULL)
    {
        printf("栈为空！\n");
        return;
    }
    LinkStack p = Top->next;
    printf("栈里的元素有：");
    while(p)
    {
        printf("%3d", p->data);
        p = p->next;
    }
    printf("\n");
    return;
}

void InitStack(LinkStack &Top)
{
    Top = (LinkStack)malloc(sizeof(LStackNode));
    if(!Top) return;
    Top->next = NULL;
}

void PushStack(LinkStack &Top, SElemType e)
{
    LinkStack newbase = (LinkStack)malloc(sizeof(LStackNode));
    if(!newbase)
    {
        printf("内存空间分配失败！\n");
        return;
    }
    newbase->data = e;
    newbase->next = Top->next;
    Top->next = newbase;
    return;
}

void PopStack(LinkStack &Top, SElemType &e)
{
    LinkStack p = Top->next;
    if(!p)
    {
        printf("栈为空！\n");
        return;
    }
    Top->next = p->next;
    e = p->data;
    free(p);
    return;
}

void GetTopStack(LinkStack &Top, SElemType &e)
{
    LinkStack p = Top->next;
    if(!p)
    {
        printf("栈为空！\n");
        return;
    }
    e = p->data;
    return;
}

int LengthStack(LinkStack &Top)
{
    int len=0;
    LinkStack p=Top;
    while(p->next!=NULL)
    {
        len++;
        p=p->next;
    }
    return len;
}

void FreeStack(LinkStack &Top)
{
    LinkStack p=Top,q;
    while(p->next!=NULL)
    {
        q = p;
        p = p->next;
        free(q);
    }
    printf("栈已销毁！\n");
    return;
}