栈

栈（Stack）

• 概念：一种特殊的线性表

栈的顺序存储：

• 一段连续的顺序空间

代码示例：

栈的顺序存储.c

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include"SeqStack.h"
typedef struct PERSON
{
   
        char name[64];
        int age;
}Person;
//测试
void test01()
{
   
        //创建栈
        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);
}
int main()
{
   
        test01();
        return EXIT_SUCCESS;
}

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;
        }
        if (stack->size == MAX_SIZE)
        {
   
               return;
        }
        
        if (data == NULL)
        {
   
               return;
        }
        stack->data[stack->size] = data;
        stack->size++;
}
//返回栈顶元素
void* Top_SeqStack(SeqStack* stack)
{
   
        if (stack == NULL)
        {
   
               return NULL;
        }
        if (stack->size == 0)
        {
   
               return NULL;
        }
        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 SEQTACK_TPUE;
        }
        return SEQSTACK_FALSE;
}
//返回栈中元素的个数
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);
}

SeqStack.h

#ifndef SEQSTACK_H
#define SEQSTACK_H
#include<stdio.h>
#include<stdlib.h>
//数组去模拟栈的顺序存储
#define MAX_SIZE 1024
#define SEQTACK_TPUE 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);
#endif // !SEQSTACK_H