数据结构—栈的实现（顺序表）

数据结构中的栈有“后进先出”的特点，意思是最后被存进栈中的数据，总是最早被取走

一个栈只有初始化，销毁，入栈，出栈和取栈顶元素，这些限制往往使在操作数据时更安全，代码容易实现，出现BUG的机会就很少

上图中，栈中有3个元素，栈顶元素是data3，如果是入栈操作则data4放入栈顶，此时栈中有四个元素，栈顶元素是data4，如果出栈，则data4被取出，栈顶元素变为data3，具体实现代码如下：

头文件（SeqStack.h）：

#pragma once

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

typedef char StackType;

typedef struct SeqStack{
    StackType* space;    //该指针指向一段向堆申请的空间
    size_t size;         //栈的元素个数
    size_t max_size;     //栈的最大存储元素个数
}SeqStack;

void SeqStackInit(SeqStack* stack);  //栈的初始化

void SeqStackDestroy(SeqStack* stack);  //销毁栈

void SeqStackPush(SeqStack* stack, StackType value); //入栈

void SeqStackPop(SeqStack* stack); //出栈

int SeqStackTop(SeqStack* stack, StackType* output_value);  //去栈顶元素

头文件的实现（SeqStack）

#include"SeqStack.h"

void SeqStackInit(SeqStack* stack){
    if(stack == NULL) {
        return;
    }
    stack->size = 0;
    stack->max_size = 1000;
    stack->space = malloc(stack->max_size * sizeof(StackType));
}

void SeqStackDestroy(SeqStack* stack) {
    if(stack == NULL) {
        return;
    }
    free(stack->space);
    stack->space = NULL;
    stack->size = 0;
    stack->max_size = 0;
}

void SeqStackPush(SeqStack* stack, StackType value) {
    if(stack == NULL) {
        return;
    }
    stack->space[stack->size] = value;
    stack->size++;
    if(stack->size >= stack->max_size) {         //当栈被填满时，申请一个更大的空间，并把原来栈中的数据复制过去，销毁原来的栈，使用新栈
        stack->max_size = stack->max_size * 2 + 1;
        SeqStack* new_stack = malloc(stack->max_size * sizeof(SeqStack));
        int i = 0;
        for(; i < stack->size; i++) {
            new_stack->space[i] = stack->space[i];            
        }
        SeqStackDestroy(stack);
        stack = new_stack;
    }
}

void SeqStackPop(SeqStack* stack) {
    if(stack == NULL) {
        return;
    }
    stack->size--;
}

int SeqStackTop(SeqStack* stack, StackType* output_value) {
    if(stack == NULL || output_value == NULL) {
        return 0;
    }
    if(stack->size == 0){
        return 0;
    }
    *output_value = stack->space[stack->size];
    return 1;
}

/
//以下为测试代码
/
void TestSeqStack() {
    SeqStack stack;
    SeqStackInit(&stack);
    printf("stack->space expected NULL, actual %p\n", stack.space);
    printf("stack->size expected 0, actual %d\n", stack.size);

    SeqStackPush(&stack, 'a');
    SeqStackPush(&stack, 'b');
    SeqStackPush(&stack, 'c');
    SeqStackPush(&stack, 'd');
    printf("stack->size expected 4, actual %d\n", stack.size);
    
    StackType value;
    int ret;
    ret = SeqStackTop(&stack, &value);
    printf("stack->space expected d, actual %c\n", stack.space[stack.size-1]);
    printf("stack->size expected 1, actual %d\n", ret);
    SeqStackPop(&stack);

    ret = SeqStackTop(&stack, &value);
    printf("stack->space expected c, actual %c\n", stack.space[stack.size-1]);
    printf("stack->size expected 1, actual %d\n", ret);
    SeqStackPop(&stack);

    ret = SeqStackTop(&stack, &value);
    printf("stack->space expected b, actual %c\n", stack.space[stack.size-1]);
    printf("stack->size expected 1, actual %d\n", ret);
    SeqStackPop(&stack);

    ret = SeqStackTop(&stack, &value);
    printf("stack->space expected a, actual %c\n", stack.space[stack.size-1]);
    printf("stack->size expected 1, actual %d\n", ret);
    SeqStackPop(&stack);

    ret = SeqStackTop(&stack, &value);
    printf("stack->space expected 0, actual %d\n", stack.space[stack.size-1]);
    printf("stack->size expected 0, actual %d\n", ret);
}


int main(){
    TestSeqStack();
    return 0;
}

实验结果：