数据结构-6栈的程序

顺序栈（低配）

#include <stdio.h>
#include <stdlib.h>

#define MAX 100

typedef struct node{
    int arr[MAX];
    int top;
}SeqStack, *PSeqStack;

void stack_init(PSeqStack *S)
{
    *S = malloc(sizeof(SeqStack));
    if(NULL == *S){
        perror("malloc");
        return;
    }
    (*S)->top = -1; //(*S)->top = 0;
}

int stack_empty(PSeqStack s)
{
    if(NULL == s){
        puts("arg err");
        return 0;
    }
    if(-1 == s->top)
        return 1;
    else
        return 0;
}

int stack_full(PSeqStack s)
{
    if(NULL == s)
    {
        puts("arg err");
        return 0;
    }
    if(MAX-1 == s->top)
        return 1;
    else
        return 0;
}

int push_back(PSeqStack s, int data)
{
    if(NULL == s || stack_full(s))
        return -1;
    s->top++;   //因为s->top从-1开始，所以应该先+1
    s->arr[s->top] = data;
    return 0;
}

//返回值只做函数正确或错误调用的判断
//int *data 才是真正出栈的数据
int pop_back(PSeqStack s, int *data)
{
    if(NULL == s || stack_empty(s))
        return -1;
    *data = s->arr[s->top--];
    return 0;
}

void show(PSeqStack s)
{
    for(int i = s->top; i > -1; i--)
        printf("%d ", s->arr[i]);
    puts("");
}

int main(int argc, char *argv[])
{ 
    PSeqStack s;
    stack_init(&s);
    
    int data, ret;
    while(1)
    {
        printf("please input push data: ");
        ret = scanf("%d", &data);
        if(0 >= ret){
            getchar();
            break;
        }
        push_back(s, data);
    }
    show(s);

    while(!stack_empty(s)){
        pop_back(s, &data);
        printf("pop data:%d\n", data);
    }
    return 0;
} 

高配版

stack.h

#ifndef __STACK_H
#define __STACK_H
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
typedef int TypeData;

typedef struct node{
    TypeData *arr;
    int top;
    int size;
}Stack, *Pstack;

void stack_init(Pstack *S, int len);
bool stack_empty(Pstack s);
bool stack_full(Pstack s);
int stack_len(Pstack s);
bool push_back(Pstack s, TypeData data);
bool pop_back(Pstack s, TypeData *pd);

#endif

stack.c

#include <stdio.h>
#include "stack.h"
void stack_init(Pstack *S, int len)
{
    *S = malloc(sizeof(Stack));
    if(NULL == *S){
        perror("malloc");
        return ;
    }
    (*S)->arr = malloc(sizeof(TypeData)*len);
    if(NULL == (*S)->arr){
        perror("malloc");
        return;
    }
    (*S)->top = -1;
    (*S)->size = len;
}

bool stack_empty(Pstack s)
{
    if(NULL == s){
        puts("empty arg NULL");
        return false;
    }
    if(-1 == s->top)
        return true;
    else
        return false;
}

bool stack_full(Pstack s)
{
    if(NULL == s){
        puts("full arg NULL");
        return false;
    }
    if(s->size-1 == s->top)
        return true;
    else
        return false;
}

int stack_len(Pstack s)
{
    if(NULL == s){
        puts("len arg NULL");
        return -1;
    }
    return s->top+1;
}

bool push_back(Pstack s, TypeData data)
{
    if(NULL == s){
        puts("push arg NULL");
        return false;
    }
    if(stack_full(s)){
        puts("push full");
        return false;
    }
    s->top++;
    s->arr[s->top] = data;
    return true;
}

bool pop_back(Pstack s, TypeData *pd)
{
    if(NULL == s){
        puts("pop arg NULL");
        return false;
    }
    if(stack_empty(s)){
        puts("pop empty");
        return false;
    }
    *pd = s->arr[s->top--];
    return true;
}

mian.c

#include "stack.h"

int main(int argc, char *argv[])
{ 
    Pstack s;
    stack_init(&s, 5);
    TypeData data;
    while(1){
        scanf("%d", &data);
        if(!push_back(s, data))
            break;
    }
    printf("len:%d\n", stack_len(s));
    return 0;
}