栈的顺序存储构架

 定义

　　栈是限定只能在表尾删除和插入操作的线性表。

　　允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom）。栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构。

　　栈的插入操作称为进栈，也称压栈、入栈。

　　栈的删除操作称为出栈，也称弹栈。

 栈的抽象数据结构

　　由于栈本身就是一个线性表，所以线性表的操作特性它都具备，针对它的特殊性，在它的操作上可能会有一些变化。将进栈和出栈分别改名为push和pop。

　　由于栈本身是一个线性表，所以线性表的顺序存储结构和链式存储结构同样适用于栈。

栈的顺序存储构架搭建

数组去模拟顺序存储

typedef struct SEQSTACK{
    void *data[MAX_SIZE];
    int size;
}SeqStack;

架构搭建

//初始化栈
SeqStack *Init_SeqStack();
//入栈
void *Push_SeqStack(SeqStack* stack, void* data);
//返回栈顶元素
void* Top_SeqStack(SeqStack* stack);
//出栈
void Pop_SeqStack(SeqStack* stack);
//判断是否为空
int IsEmpty(SeqStack* stack);
//返回栈中元素个数
int Size_SeqStack(SeqStack* stack);
//清空栈
void Clear_SeqStack(SeqStack* stack);
//销毁
void FreeSpace_SeqStack(SeqStack* stack);

栈的顺序存储构架实现

初始化栈

SeqStack *Init_SeqStack()
{
    SeqStack* stack = (SeqStack*)malloc(sizeof(SeqStack));
    for (int i = 0; i < MAX_SIZE; i++)
    {
        stack->data[i] = NULL;
    }
    stack->size = 0;
    return stack;
}

入栈

void *Push_SeqStack(SeqStack* stack, void* data)
{
    if (stack == NULL)
        return NULL;
    if (stack->data == NULL)
        return NULL;
    if (stack->size == MAX_SIZE)
        return;

    stack->data[stack->size] = data;
    stack->size++;
    return NULL;
}

返回栈顶元素

void* Top_SeqStack(SeqStack* stack)
{
    if (stack == NULL)
        return NULL;
    if (stack->size == 0)
        return;
    return stack->data[stack->size-1];
}

出栈

void Pop_SeqStack(SeqStack* stack)
{
    if (stack == NULL)
        return ;
    if (stack->size == 0)
        return;
    stack->data[stack->size - 1] = NULL;
    stack->size--;

}

判断是否为空

int IsEmpty(SeqStack* stack)
{
    if (stack == NULL)
        return -1;
    if (stack->size == 0)
        return SEQSTACK_FALSE;
    return SEQSTCAK_TRUE;
}

返回栈中元素个数

int Size_SeqStack(SeqStack* stack)
{
    return stack->size;
}

清空栈

void Clear_SeqStack(SeqStack* stack)
{
    if (stack == NULL)
        return ;
    for (int i = 0; i < stack->size; i++)
    {
        stack->data[i] = NULL;
    }
    stack->size = 0;
}

销毁

void FreeSpace_SeqStack(SeqStack* stack)
{
    if (stack == NULL)
        return;
    free(stack);
}

栈的顺序存储测试

测试思路：

定义数据类型为Person类型结构体

typedef struct PERSON {
    char name[64];
    int age;
}Person;

创建栈

    SeqStack* stack = Init_SeqStack();

创建数据

    Person p1 = { "aaa",10 };
    Person p2 = { "bbb",20 };
    Person p3 = { "ccc",30 };
    Person p4 = { "ddd",40 };
    Person p5 = { "eee",50 };

入栈

    Push_SeqStack(stack, &p1);
    Push_SeqStack(stack, &p2);
    Push_SeqStack(stack, &p3);
    Push_SeqStack(stack, &p4);
    Push_SeqStack(stack, &p5);

输出

    while (Size_SeqStack(stack) > 0)
    {
        //访问栈顶元素
        Person* person = (Person*)Top_SeqStack(stack);
        printf("name:%s  age:%d\n", person->name, person->age);
        //弹出栈顶元素
        Pop_SeqStack(stack);
    }

释放内存

    FreeSpace_SeqStack(stack);

　　

运行结果：

SeqStack.h源码：

#pragma once

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

//数组去模拟栈的顺序存储
#define MAX_SIZE 1024
#define SEQSTCAK_TRUE 1
#define SEQSTACK_FALSE 0

typedef struct SEQSTACK{
    void *data[MAX_SIZE];
    int size;
}SeqStack;

//初始化栈
SeqStack *Init_SeqStack();
//入栈
void *Push_SeqStack(SeqStack* stack, void* data);
//返回栈顶元素
void* Top_SeqStack(SeqStack* stack);
//出栈
void Pop_SeqStack(SeqStack* stack);
//判断是否为空
int IsEmpty(SeqStack* stack);
//返回栈中元素个数
int Size_SeqStack(SeqStack* stack);
//清空栈
void Clear_SeqStack(SeqStack* stack);
//销毁
void FreeSpace_SeqStack(SeqStack* stack);

 

SeqStack.c源码：

#include"SeqStack.h"

//初始化栈
SeqStack *Init_SeqStack()
{
    SeqStack* stack = (SeqStack*)malloc(sizeof(SeqStack));
    for (int i = 0; i < MAX_SIZE; i++)
    {
        stack->data[i] = NULL;
    }
    stack->size = 0;
    return stack;
}
//入栈
void *Push_SeqStack(SeqStack* stack, void* data)
{
    if (stack == NULL)
        return NULL;
    if (stack->data == NULL)
        return NULL;
    if (stack->size == MAX_SIZE)
        return;

    stack->data[stack->size] = data;
    stack->size++;
    return NULL;
}
//返回栈顶元素
void* Top_SeqStack(SeqStack* stack)
{
    if (stack == NULL)
        return NULL;
    if (stack->size == 0)
        return;
    return stack->data[stack->size-1];
}
//出栈
void Pop_SeqStack(SeqStack* stack)
{
    if (stack == NULL)
        return ;
    if (stack->size == 0)
        return;
    stack->data[stack->size - 1] = NULL;
    stack->size--;

}
//判断是否为空
int IsEmpty(SeqStack* stack)
{
    if (stack == NULL)
        return -1;
    if (stack->size == 0)
        return SEQSTACK_FALSE;
    return SEQSTCAK_TRUE;
}
//返回栈中元素个数
int Size_SeqStack(SeqStack* stack)
{
    return stack->size;
}
//清空栈
void Clear_SeqStack(SeqStack* stack)
{
    if (stack == NULL)
        return ;
    for (int i = 0; i < stack->size; i++)
    {
        stack->data[i] = NULL;
    }
    stack->size = 0;
}
//销毁
void FreeSpace_SeqStack(SeqStack* stack)
{
    if (stack == NULL)
        return;
    free(stack);
}

 

main.c源码：

#include"SeqStack.h"
#include<stdlib.h>
#include<stdio.h>
#include<string.h>

//Person类型结构体
typedef struct PERSON {
    char name[64];
    int age;
}Person;
int main()
{
    
    //创建栈
    SeqStack* stack = Init_SeqStack();

    //创建数据
    Person p1 = { "aaa",10 };
    Person p2 = { "bbb",20 };
    Person p3 = { "ccc",30 };
    Person p4 = { "ddd",40 };
    Person p5 = { "eee",50 };

    //入栈
    Push_SeqStack(stack, &p1);
    Push_SeqStack(stack, &p2);
    Push_SeqStack(stack, &p3);
    Push_SeqStack(stack, &p4);
    Push_SeqStack(stack, &p5);

    //输出
    while (Size_SeqStack(stack) > 0)
    {
        //访问栈顶元素
        Person* person = (Person*)Top_SeqStack(stack);
        printf("name:%s  age:%d\n", person->name, person->age);
        //弹出栈顶元素
        Pop_SeqStack(stack);
    }

    //释放内存
    FreeSpace_SeqStack(stack);

    return 0;
}