听黑马程序员教程《基础数据结构和算法 (C版本)》，

照着老师所讲抄的，

视频地址https://www.bilibili.com/video/BV1vE411f7Jh?p=1

喜欢的朋友可以去看看，欢迎大家一起交流学习。

/*
    栈的顺序存储：
        栈的顺序存储结构简称【顺序栈】，它是运算受限制的顺序表。
        顺序栈的存储结构是：利用一组地址连续的存储单元依次存放自栈底到栈顶的
        数据元素，同时附设指针top只是栈顶元素在顺序表中的位置。
    设计与实现：
        因为栈是一种特殊的线性表，所以栈的顺序存储可以通过顺序线性表来实现。
    笔记：
        先进后出规则，从栈顶进入，到栈底，
        不能遍历。压栈，入栈。出栈（top方法）。
        栈，栈容器，只要符合先进后出规则，它就是一个栈容器。
        其实栈也就是个链表，只是只能从一端插入或删除。
        
*/

栈的顺利存储main.c

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 #include<string.h>
 4 #include "SeqStack.c"
 5 
 6 /*
 7     栈的顺序存储：
 8         栈的顺序存储结构简称【顺序栈】，它是运算受限制的顺序表。
 9         顺序栈的存储结构是：利用一组地址连续的存储单元依次存放自栈底到栈顶的
10         数据元素，同时附设指针top只是栈顶元素在顺序表中的位置。
11     设计与实现：
12         因为栈是一种特殊的线性表，所以栈的顺序存储可以通过顺序线性表来实现。
13     笔记： 
14         先进后出规则，从栈顶进入，到栈底， 
15         不能遍历。压栈，入栈。出栈（top方法）。 
16         栈，栈容器，只要符合先进后出规则，它就是一个栈容器。
17         其实栈也就是个链表，只是只能从一端插入或删除。 
18         
19 */
20 
21 
22 // 用户数据
23 typedef struct PERSON{
24     char name[32];
25     int age;
26 }Person;
27 
28 int main(){
29     printf("好好学习，天天向上~！\t\t\t 栈的顺利存储 20220606\n\n\n");
30     
31     // 创建栈 
32     SeqStack* stack = Init_SeqStack();
33     
34     // 创建数据
35     Person p1 = {"pp1",10};
36     Person p2 = {"pp2",10};
37     Person p3 = {"pp3",10};
38     Person p4 = {"pp4",10};
39     Person p5 = {"pp5",10};
40     Person p6 = {"pp6",10};
41     Person p7 = {"pp7",10};
42     Person p8 = {"pp8",10};
43     Person p9 = {"pp9",10};
44     Person p10 = {"pp10",10};
45     Person p11 = {"pp11",10};
46     
47     // 入栈
48     Push_SeqStack(stack,&p1);
49     Push_SeqStack(stack,&p2);
50     Push_SeqStack(stack,&p3);
51     Push_SeqStack(stack,&p4);
52     Push_SeqStack(stack,&p5);
53     Push_SeqStack(stack,&p6);
54     Push_SeqStack(stack,&p7);
55     Push_SeqStack(stack,&p8);
56     Push_SeqStack(stack,&p9);
57     Push_SeqStack(stack,&p10);
58     Push_SeqStack(stack,&p11);
59     
60     // 输出
61     while(Size_SeqStack(stack)>0){
62         // 访问栈顶元素
63         Person* p = (Person*)Top_SeqStack(stack);
64         printf("p_name:%-4s - p_age:%-4d \n",p->name,p->age);
65         // 出栈
66         Pop_SeqStack(stack); 
67         
68     }
69     
70     // 释放内存
71     FreeSpace_SeqStack(stack); 
72      
73     
74     printf("\n\n");    
75     return 0;
76 } 

SeqStack.h

 1 #ifndef SEQSTACK_H 
 2 #define SEQSTACK_H
 3 
 4 #include<stdio.h>
 5 #include<stdlib.h>
 6 
 7  
 8 // 用数组模拟栈的顺序存储（栈顶设在数组右边，从右边入和出。类似链表尾插法 ） 
 9  
10 #define MAX_SIZE 1024
11 #define SEQSTACK_TRUE 1
12 #define SEQSTACK_FALSE 0
13 
14 typedef struct SEQSTACK{
15     void* data[MAX_SIZE];
16     int size;
17 }SeqStack;
18  
19  
20 // 初始化栈
21 SeqStack* Init_SeqStack();
22 
23 // 入栈（尾插法），参数：栈，插入值。 
24 void Push_SeqStack(SeqStack* stack,void* data);
25  
26 // 返回栈顶元素
27 void* Top_SeqStack(SeqStack* stack); 
28  
29 // 出栈（删除最后元素）
30 void Pop_SeqStack(SeqStack* stack);
31 
32 // 判断是否为空
33 int IsEmpty(SeqStack* stack); 
34  
35 // 返回栈中元素个数
36 int Size_SeqStack(SeqStack* stack); 
37  
38 // 清空栈
39 void Clear_SeqStack(SeqStack* stack);
40 
41 // 销毁
42 void FreeSpace_SeqStack(SeqStack* stack); 
43  
44 #endif

SeqStack.c

  1 #include "SeqStack.h"
  2 
  3 // 初始化栈
  4 SeqStack* Init_SeqStack(){
  5     
  6     SeqStack* stack = (SeqStack*)malloc(sizeof(SeqStack));
  7     int i;
  8     for(i=0;i<MAX_SIZE;i++){
  9         stack->data[i] = NULL;
 10     }
 11     stack->size = 0;    
 12     // 这个栈就是一个数组结构体，里面有MAX_SIZE（1024）个数组元素。创建结构体后
 13     // 把里面1024个元素都设为NULL，同时size也设为0  
 14     return stack;
 15 }
 16 
 17 // 入栈（尾插法），参数：栈，插入值。 
 18 void Push_SeqStack(SeqStack* stack,void* data){
 19     
 20     if(stack==NULL){
 21         return;
 22     }
 23     if(data==NULL){
 24         return;
 25     }
 26     if(stack->size == MAX_SIZE){    // 元素个数和数组下标相等：放满了，放不下了。 
 27         return;
 28     }
 29     
 30     // 插入到最后。
 31     // 【【【【【 size即标记当前元素个数，同时也标记着最后位置】】】】 
 32     stack->data[stack->size] = data;
 33     
 34     // 标记+1 
 35     stack->size++; 
 36     
 37 }
 38  
 39 // 返回栈顶元素
 40 void* Top_SeqStack(SeqStack* stack){
 41     
 42     if(stack==NULL){
 43         return;
 44     }
 45     if(stack->size ==0){
 46         return;
 47     }
 48     
 49     return stack->data[stack->size -1];    // 减1，因为数组是从0开始。 
 50     
 51 }
 52  
 53 // 出栈（删除最后元素）
 54 void Pop_SeqStack(SeqStack* stack){
 55     if(stack==NULL){
 56         return;
 57     }
 58     if(stack->size ==0){
 59         return;
 60     }
 61     
 62     stack->data[stack->size -1] = NULL;    
 63     // 也可以置空，也可以不必置空，因为下面size-1了 
 64     
 65     stack->size--;    
 66     
 67 }
 68 
 69 // 判断是否为空
 70 int IsEmpty(SeqStack* stack){
 71     
 72     if(stack == NULL){
 73         return -1;
 74     } 
 75     if(stack->size == 0){
 76         return SEQSTACK_FALSE;
 77     }
 78     
 79     return SEQSTACK_TRUE;
 80 }
 81  
 82 // 返回栈中元素个数
 83 int Size_SeqStack(SeqStack* stack){
 84     
 85     if(stack==NULL){
 86         return;
 87     }    
 88     
 89     return stack->size;
 90 } 
 91  
 92 // 清空栈
 93 void Clear_SeqStack(SeqStack* stack){
 94     
 95     if(stack == NULL){
 96         return;
 97     }
 98     
 99     int i;
100     for(i=0;i<stack->size;i++){
101         stack->data[i] = NULL;
102     }
103     // 上面可以把每个元素都置NULL，也可以不必置NULL，因为下面size=0了。
104      
105     stack->size = 0;
106     
107 }
108 
109 // 销毁
110 void FreeSpace_SeqStack(SeqStack* stack){
111     
112     if(stack == NULL){
113         return;
114     }
115     
116     free(stack);    
117     
118 }