C语言- 基础数据结构和算法 - 栈的顺序存储

听黑马程序员教程《基础数据结构和算法 (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 }