数据结构----栈的链式存储结构源码

数据结构----栈的链式存储结构源码

//  栈是仅限定在表尾进行插入和删除的操作的表；下面以栈的链式储存结构为例。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct StackNode{
    int data;
    struct stacknode *next;
}stacknode,*linkstackptr;

typedef struct LinkStack{
    linkstackptr top;
    int cnt;
}linkstack;

int Initstack(linkstack *s)
{
    s->top=(linkstackptr)malloc(sizeof(stacknode));
    if(!(s->top))
    return -1;
    s->top=NULL;
    s->cnt=0;
    return 1;
}

int push(linkstack *s,int val)
{
    linkstackptr p=(linkstackptr)malloc(sizeof(stacknode));
    if(!p)
    return -1;
    p->data=val;
    p->next=s->top;
    s->top=p;
    s->cnt++;
    return 1;
}

int length(linkstack *s)
{
    if(s->cnt==0)
    return 0;
    else
    return s->cnt;
}
int pop(linkstack *s)
{
    linkstackptr p;
    if(length(s)==0)
    return -1;
    p=s->top;
    s->top=s->top->next;
    free(p);
    s->cnt--;
    return 1;
}

int get(linkstack *s)
{
    if(length(s)==0)
    return -1;
    return s->top->data;
}

int clear(linkstack *s)
{
    linkstackptr q,p=s->top;
    while(p)
    {
        q=p;
        p=p->next;
        free(q);
    }
    s->cnt=0;
    return 1;
}

int show(linkstack *s)
{
    if(s->cnt==0)
    return -1;
    linkstackptr p=s->top;
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}

int main()
{
	int k;
    linkstack L;
    k=Initstack(&L);
    if(k==-1)
    {
        printf("内存分配失败，栈的链式储存初始化失败\n");
        return 0;
    }
    else
    {
        printf("恭喜你！内存分配成功，栈的链式储存初始化成功！栈中元素为零！\n");
    }
    printf("请输入一些元素，用以入栈！以输入-1代表结束：\n");
    int n;
    while(~scanf("%d",&n))
    {
        if(n==-1)
        break;
        push(&L,n);
    }
    printf("压栈成功！栈顶到栈底元素为：\n");
    show(&L);
    char s[50];
    printf("输入你想要进行的操作（输入end代表结束）：push,length,pop,get,clear,show\n");
    memset(s,'\0',sizeof(s));
    while(~scanf("%s",s))
    {
        if(!strcmp(s,"end"))
        break;
        if(!strcmp(s,"push"))
        {
            int flag,tmp;
            printf("请输入你要压入栈顶的元素：");
            scanf("%d",&flag);
            tmp=push(&L,flag);
            if(flag==-1)
            printf("动态内存分配失败！压栈失败！\n");
            else
            {
                printf("动态内存分配成功！压栈成功！\n栈顶到栈底元素为：");
                show(&L);
            }
        }
        if(!strcmp(s,"length"))
        {
            int tmp;
            tmp=length(&L);
            printf("栈中元素个数为：%d\n",tmp);
        }
        if(!strcmp(s,"pop"))
        {
            int flag;
            flag=pop(&L);
            if(flag==-1)
            printf("栈中元素个数为零，出栈失败！\n");
            else
            {
                printf("恭喜你！出栈成功！\n栈顶到栈底的元素为：");
                show(&L);
            }
        }
        if(!strcmp(s,"get"))
        {
            int flag;
            flag=get(&L);
            if(flag==-1)
            printf("栈中元素个数为零，获取栈顶元素失败！\n");
            else
            {
                printf("恭喜你！获取成功，栈顶元素为：%d\n",flag);
            }
        }
        if(!strcmp(s,"clear"))
        {
            int flag,tmp;
            flag=clear(&L);
            if(flag==1)
            {
                tmp=length(&L);
                printf("恭喜你！清理成功，栈中元素为：%d\n",tmp);
                printf("程序结束！\n");
                break;
            }
        }
        if(!strcmp(s,"show"))
        {
            int flag,tmp;
            flag=length(&L);
            if(flag==0)
            printf("栈中元素个数为零！展示失败！\n");
            else
            {
                printf("恭喜你！展示成功，栈顶到栈底元素为：\n");
                tmp=show(&L);
            }
        }
        memset(s,'\0',sizeof(s));
    }
    return 0;
}

原文地址：https://www.cnblogs.com/Yqifei/p/12687711.html