【数据结构】顺序栈

1. stack.h

/*
* File Name: stack.h
*
* Copyright (c) 2022, c code from sustzc.
* All rights reserved.
*/

#ifndef __STACK_H__
#define __STACK_H__

#include <stdio.h>

#ifdef __cplusplus
extern "C" {
#endif

#define MAX_STACK_SIZE 6

typedef int stack_data_t;
typedef struct stack_s {
    stack_data_t data[MAX_STACK_SIZE];
    int top; /* stack top pointer  */
} stack_t;

void init_stack(stack_t *stack);

int get_stack_size(const stack_t *stack);

int is_stack_empty(const stack_t *stack);

int is_stack_full(const stack_t *stack);

stack_data_t top(const stack_t *stack);

void print_stack(const stack_t *stack);

void push(stack_t *stack, stack_data_t data);

void pop(stack_t *stack);

void clear_stack(stack_t *stack);

void destroy_stack(stack_t *stack);

#ifdef __cplusplus
}
#endif

#endif // __STACK_H__

2. stack.c

/*
* File Name: stack.c
*
* Copyright (c) 2022, c code from sustzc.
* All rights reserved.
*/

#include "stack.h"

void init_stack(stack_t *stack)
{
    stack->top = 0;
}

int get_stack_size(const stack_t *stack)
{
    return stack->top;
}

int is_stack_empty(const stack_t *stack)
{
    return 0 == get_stack_size(stack);
}

int is_stack_full(const stack_t *stack)
{
    return MAX_STACK_SIZE == get_stack_size(stack);
}

stack_data_t top(const stack_t *stack)
{
    return stack->data[stack->top - 1];
}

void print_stack(const stack_t *stack)
{
    if (is_stack_empty(stack)) {
        return;
    }

    printf("top data: [%d]\n", top(stack));
}

void push(stack_t *stack, stack_data_t data)
{
    if (is_stack_full(stack)) {
        return;
    }

    stack->data[stack->top++] = data;
}

void pop(stack_t *stack)
{
    if (is_stack_empty(stack)) {
        return;
    }

    --stack->top;
}

void clear_stack(stack_t *stack)
{
    stack->top = 0;
}

void destroy_stack(stack_t *stack)
{
    clear_stack(stack);
}

3. test_stack.c

/*
* File Name: test_stack.c
*
* Copyright (c) 2022, c code from sustzc.
* All rights reserved.
*/

#include "stack.h"

void test()
{
    stack_t st;
    int i = 0;

    init_stack(&st);

    if (is_stack_empty(&st)) {
        printf("stack is empty\n");
    } else {
        printf("stack is not empty\n");
    }
    printf("stack size: %d\n", get_stack_size(&st));

    printf("===========push data===========\n");
    for (; i <= MAX_STACK_SIZE; ++i) {
        push(&st, i);
    }
    printf("stack size: %d\n", get_stack_size(&st));

    // printf("===========clear stack data===========\n");
    // clear_stack(&st);
    // printf("stack size: %d\n", get_stack_size(&st));

    // printf("===========destroy stack data===========\n");
    // destroy_stack(&st);
    // printf("stack size: %d\n", get_stack_size(&st));

    for (i = 0; i <= MAX_STACK_SIZE; ++i) {
        print_stack(&st);
        printf("===========pop data===========\n");
        pop(&st);
    }

    if (is_stack_empty(&st)) {
        printf("stack is empty\n");
    } else {
        printf("stack is not empty\n");
    }
    printf("stack size: %d\n", get_stack_size(&st));
}

int main(void)
{
    test();

    return 0;
}