栈的链式存储构架

Posted 2021-11-30 lixuejian

 定义

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

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

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

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

 栈的抽象数据结构

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

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

栈的链式存储框架搭建

链式栈的结点

typedef struct LINKNODE {
    struct LINKNODE* next;
}LinkNode;

 

链式栈

typedef struct LINKSTACK {
    LinkNode head;
    int size;
}LinkStack;

 

构架搭建

//初始化栈
LinkStack *Init_LinkStack();
//入栈
void Push_LinkStack(LinkStack* stack, LinkNode* data);
//返回栈顶元素
LinkNode* Top_LinkStack(LinkStack* stack);
//出栈
void Pop_LinkStack(LinkStack* stack);
//返回栈中元素个数
int Size_LinkStack(LinkStack* stack);
//清空栈
void Clear_LinkStack(LinkStack* stack);
//销毁栈
void FreeSpace_LinkStack(LinkStack* stack);

 

栈的链式存储框架实现

初始化栈

LinkStack *Init_LinkStack()
{
    LinkStack* stack = (LinkStack*)malloc(sizeof(LinkStack));
    stack->head.next = NULL;
    stack->size = 0;
    return stack;
}

 

入栈

void Push_LinkStack(LinkStack* stack, LinkNode* data)
{
    if (stack == NULL)
        return ;
    if (data == NULL)
        return ;
    data->next = stack->head.next;
    stack->head.next = data;
    stack->size++;
}

 

返回栈顶元素

LinkNode* Top_LinkStack(LinkStack* stack)
{
    if (stack == NULL)
        return NULL;
    if (stack->size == 0)
        return NULL;
    return stack->head.next;
}

 

出栈

void Pop_LinkStack(LinkStack* stack)
{
    if (stack == NULL)
        return;
    if (stack->size == 0)
        return;
    //第一个有效结点
    LinkNode* pNext = stack->head.next;
    stack->head.next = pNext->next;
    stack->size--;
}

 

返回栈中元素个数

int Size_LinkStack(LinkStack* stack)
{
    if (stack == NULL)
        return -1;
    return stack->size;
}

 

清空栈

void Clear_LinkStack(LinkStack* stack)
{
    if (stack == NULL)
        return;
    stack->head.next = NULL;
    stack->size = 0;
}

 

销毁栈

void FreeSpace_LinkStack(LinkStack* stack)
{
    if (stack == NULL)
        return;
    free(stack);
}

 

栈的链式存储框架测试

测试思路

创建栈

    LinkStack *stack = Init_LinkStack();

 

创建数据

　　创建数据包括两步：创建结构体类型和数据初始化

创建结构体类型

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

 

数据初始化

    Person p1, p2, p3, p4, p5;
    strcpy(p1.name, "aaa");
    strcpy(p2.name, "bbb");
    strcpy(p3.name, "ccc");
    strcpy(p4.name, "ddd");
    strcpy(p5.name, "eee");
    p1.age = 10;
    p2.age = 20;
    p3.age = 30;
    p4.age = 40;
    p5.age = 50;

 

入栈

    Push_LinkStack(stack, (LinkNode*)&p1);
    Push_LinkStack(stack, (LinkNode*)&p2);
    Push_LinkStack(stack, (LinkNode*)&p3);
    Push_LinkStack(stack, (LinkNode*)&p4);
    Push_LinkStack(stack, (LinkNode*)&p5);

 

输出

    while (Size_LinkStack(stack)>0)
    {
        //取出栈顶元素
        Person* p = (Person*)Top_LinkStack(stack);
        printf("Name:%s  Age:%d\\n", p->name, p->age);
        //弹出栈顶元素
        Pop_LinkStack(stack);
    }

 

销毁栈

    FreeSpace_LinkStack(stack);

 

运行结果

 

源码

LinkStack.h

 1 #pragma once
 2 
 3 #include<stdlib.h>
 4 #include<stdio.h>
 5 
 6 //链式栈的结点
 7 typedef struct LINKNODE {
 8     struct LINKNODE* next;
 9 }LinkNode;
10 
11 //链式栈
12 typedef struct LINKSTACK {
13     LinkNode head;
14     int size;
15 }LinkStack;
16 
17 //初始化栈
18 LinkStack *Init_LinkStack();
19 //入栈
20 void Push_LinkStack(LinkStack* stack, LinkNode* data);
21 //返回栈顶元素
22 LinkNode* Top_LinkStack(LinkStack* stack);
23 //出栈
24 void Pop_LinkStack(LinkStack* stack);
25 //返回栈中元素个数
26 int Size_LinkStack(LinkStack* stack);
27 //清空栈
28 void Clear_LinkStack(LinkStack* stack);
29 //销毁栈
30 void FreeSpace_LinkStack(LinkStack* stack);

 

LinkStack.c

 1 #include"LinkStack.h"
 2 
 3 //初始化栈
 4 LinkStack *Init_LinkStack()
 5 {
 6     LinkStack* stack = (LinkStack*)malloc(sizeof(LinkStack));
 7     stack->head.next = NULL;
 8     stack->size = 0;
 9     return stack;
10 }
11 //入栈
12 void Push_LinkStack(LinkStack* stack, LinkNode* data)
13 {
14     if (stack == NULL)
15         return ;
16     if (data == NULL)
17         return ;
18     data->next = stack->head.next;
19     stack->head.next = data;
20     stack->size++;
21 }
22 //返回栈顶元素
23 LinkNode* Top_LinkStack(LinkStack* stack)
24 {
25     if (stack == NULL)
26         return NULL;
27     if (stack->size == 0)
28         return NULL;
29     return stack->head.next;
30 }
31 //出栈
32 void Pop_LinkStack(LinkStack* stack)
33 {
34     if (stack == NULL)
35         return;
36     if (stack->size == 0)
37         return;
38     //第一个有效结点
39     LinkNode* pNext = stack->head.next;
40     stack->head.next = pNext->next;
41     stack->size--;
42 }
43 
44 //返回栈中元素个数
45 int Size_LinkStack(LinkStack* stack)
46 {
47     if (stack == NULL)
48         return -1;
49     return stack->size;
50 }
51 //清空栈
52 void Clear_LinkStack(LinkStack* stack)
53 {
54     if (stack == NULL)
55         return;
56     stack->head.next = NULL;
57     stack->size = 0;
58 }
59 //销毁栈
60 void FreeSpace_LinkStack(LinkStack* stack)
61 {
62     if (stack == NULL)
63         return;
64     free(stack);
65 }

 

main.c

 1 #define _CRT_SECURE_NO_WARNINGS
 2 
 3 #include<stdlib.h>
 4 #include<stdio.h>
 5 #include<string.h>
 6 #include"LinkStack.h"
 7 
 8 typedef struct PERSON {
 9     LinkNode node;
10     char name[64];
11     int age;
12 }Person;
13 
14 int main()
15 {
16     //创建栈
17     LinkStack *stack = Init_LinkStack();
18 
19     //创建数据
20     Person p1, p2, p3, p4, p5;
21     strcpy(p1.name, "aaa");
22     strcpy(p2.name, "bbb");
23     strcpy(p3.name, "ccc");
24     strcpy(p4.name, "ddd");
25     strcpy(p5.name, "eee");
26     p1.age = 10;
27     p2.age = 20;
28     p3.age = 30;
29     p4.age = 40;
30     p5.age = 50;
31 
32     //入栈
33     Push_LinkStack(stack, (LinkNode*)&p1);
34     Push_LinkStack(stack, (LinkNode*)&p2);
35     Push_LinkStack(stack, (LinkNode*)&p3);
36     Push_LinkStack(stack, (LinkNode*)&p4);
37     Push_LinkStack(stack, (LinkNode*)&p5);
38 
39     //输出
40     while (Size_LinkStack(stack)>0)
41     {
42         //取出栈顶元素
43         Person* p = (Person*)Top_LinkStack(stack);
44         printf("Name:%s  Age:%d\\n", p->name, p->age);
45         //弹出栈顶元素
46         Pop_LinkStack(stack);
47     }
48     //销毁栈
49     FreeSpace_LinkStack(stack);
50 
51     return 0;
52 }