栈的链表和数组实现

栈的链表实现

LinkStack.h

#ifndef LINKSTACK_H_
#define LINKSTACK_H_

typedef int DataType;               //自定义数据类型,假定为整型

struct Node;                        //单链表结点类型
typedef struct Node *PNode;         //结点指针类型

typedef struct Node                 //单链表结点结构
{
    DataType info;                  //结点数据域
    PNode link;                     //结点指针域
}Node;

typedef struct LinkStack           //链表栈定义
{
    PNode top;        //栈顶指针
}LinkStack;

typedef struct LinkStack * PLinkStack;    //链表栈的指针类型

//创建一个空栈
PLinkStack createEmptyStack( void );

//判断栈是否为空栈
int isEmptyStack(PLinkStack stack);

//进栈,成功返回1，失败返回0
int push(PLinkStack stack,DataType x);

//出栈，成功返回1，失败返回0
int pop(PLinkStack stack);

//取栈顶元素
DataType getTop(PLinkStack stack);

//显示栈内所有元素
void showStack(PLinkStack stack);

//把栈置空
void setEmpty(PLinkStack stack);

//把栈销毁
void destroyStack(PLinkStack stack);


#endif /* LINKSTACK_H_ */

LinkStack.c

#include <stdio.h>
#include <malloc.h>
#include "LinkStack.h"

//创建一个的空栈
PLinkStack createEmptyStack(void)
{
    PLinkStack stack=(PLinkStack)malloc(sizeof(struct LinkStack));
    if(stack == NULL)
        printf("存储分配失败，请重建栈！
");
    else
        stack->top=NULL;
    return stack;
}

//判断栈是否为空栈
int isEmptyStack(PLinkStack stack)
{
    return (stack->top == NULL);
}


//进栈,成功返回1，失败返回0
int push(PLinkStack stack,DataType x)
{
    PNode p =(PNode)malloc(sizeof(struct Node));
    if(p == NULL )
    {
        printf("新结点分配内存失败，进栈失败，请重试！
");
        return 0;
    }
    else
    {
        p->info = x;
        p->link=stack->top;     //替换栈顶元素
        stack->top=p;
        return 1;
    }
}

//出栈，成功返回1，失败返回0
int pop(PLinkStack stack)
{
    if(isEmptyStack(stack))
    {
        printf("栈为空！
");
        return 0;
    }
    else
    {
        PNode p;
        p=stack->top;   //删除最后一个结点
        stack->top = stack->top->link;
        free(p);
        return 1;
    }
}

//取栈顶元素
DataType getTop(PLinkStack stack)
{
    if(isEmptyStack(stack))
    {
        printf("栈为空！取栈顶元素失败！
");
        return NULL;
    }
    return (stack->top->info);
}


//显示栈内所有元素
void showStack(PLinkStack stack)
{
    if(isEmptyStack(stack))
        printf("当前栈为空！无内容可显示。
");
    else
    {
        PNode p;
        p=stack->top;
        printf("顶--> ");
        while(p->link != NULL)
        {
            printf("%d ",p->info);
            p=p->link;
        }
        printf("%d ",p->info);  //显示最后一个元素
        printf("-->底
");
    }
}

//把栈置空
void setEmpty(PLinkStack stack)
{
    stack->top=NULL;
}

//把栈销毁
void destroyStack(PLinkStack stack)
{
    if(stack)
    {
        stack->top=NULL;
        free(stack);
    }
}

LinkStackMain.c

#include <stdio.h>
#include "LinkStack.h"

int main() {
    PLinkStack stack;
    int i;
    stack = createEmptyStack();
    printf("0-9依次入栈并输出如下：
");
    for (i = 0; i < 10; i++) {
        push(stack, i);
    }
    showStack(stack);
    printf("栈中元素依次出栈并输出如下：
");
    for (i = 0; i < 10; i++) {
        pop(stack);
    }

    destroyStack(stack);
    printf("栈已被销毁
");

    return 0;
}

 栈的数组实现 

#include <stdio.h>
#include <malloc.h>

#define STACK_SIZE 50

typedef struct SeqStack
{
    int data[STACK_SIZE];
    int top;
}stack;

void InitStack(stack * s)
{
    s->top = -1;
}

int IsFull(stack *s)
{
    return (s->top == STACK_SIZE - 1);
}

int IsEmpty(stack *s){
    return (s->top == -1);
}

void Push(stack *s,int n)
{
    if(IsFull(s))
    {
        printf("Stack is full!
");
        return;
    }
    s->top++;
    s->data[s->top] = n;
}

int Pop(stack *s)
{
    if(IsEmpty(s))
    {
        printf("Stack is empty!
");
        return -1;
    }
    return s->data[s->top--];
}

int  main()
{
    stack *s = (stack *)malloc(sizeof(stack));
    if(s == NULL)
    {
        printf("Malloc failed!");
        exit(0);
    }

    InitStack(s);

    int i;
    for(i=0;i<10;i++)
    {
        Push(s,i);
    }

    while(!IsEmpty(s))
    {
        int data = Pop(s);
        printf("%d->",data);
    }

    return 0;
}

 栈的数组实现 固定了数组大小，链表实现动态生成空间，都可以实现栈的数据结构特点。

 最基础的数据结构：数组和链表，其他复杂数据结构都可以在这两种基础数据结构基础上构建。