DAY12-链表

回顾

在开始之前，先回顾一下数组

数组：连续性的空间，存储同一类型的数据

数组的优点：

• 访问简单
• 连续性空间

数组的缺点：

• 删除非常麻烦，增加元素也麻烦

数组和链表很相似，链表在空间上并不是连续的。

链表

链表：是一种数据结构，是一种非连续性的数据结构。

物理上：非连续

逻辑上：连续性的，是通过指针进行相互连续。

链表的每一个节点（node）的组成包含两个方面：

1. 数据域：用来存储数据
2. 指针域：用来存储地址，存储上一个或者下一个节点的地址

链表分类：

有头链表：

• 有头单向链表
• 有头双向链表

无头链表

• 无头单向链表
• 无头双向链表

这里说的有头无头指的是：链表的头

链表中的头不存储有效数据，可以存储一些必要的信息（例如首元素或尾元素的地址，以及链表的尺寸），协作我们管理链表。

1.静态单向无头链表

静态:就是不动态申请空间存储node

单向:是指通过node节点中存储的指针地址，可以访问到下一个node节点，但是却不能访问上一个node节点

无头:指的是没有头指针

#include <stdio.h>
 
typedef struct student
{
    char name[32];
    int id;
    float score;
    char gender; // 数据域
 
    struct student *next; // 指针域
 
} STU;
 
 
 
int main(int argc, char const *argv[])
{
    STU stu1 = {"李雷", 1, 98.0F,'M'};
 
    STU stu2 = {"韩梅梅",2,99.0F,'F'};
 
    STU stu3 = {"Michle",3,60.0F,'M'};
 
    STU stu4 = {"Wang",4,70.0F,'M'};
 
    STU stu5 = {"Poli",5,50.0F,'M'};
 
    stu1.next = &stu2;
    stu2.next = &stu3;
    stu3.next = &stu4;
    stu4.next = &stu5;
    stu5.next = NULL;   //避免指针悬空，指向NULL
 
 
    STU *flag = &stu1;
 
    while (flag != NULL)
    {
        printf("NAME:%s ID:%d   SCORE:%0.1f GENDER:%c\n",
            flag->name,flag->id,flag->score,flag->gender);
            flag = flag->next;
    }
    
 
 
 
    
 
    return 0;
}
 

2.静态双向无头链表

双向：就是通过一个node节点，我们可以访问node节点的上一个节点和下一个节点，我们的头节点和尾节点，没有上一个节点和下一个节点。

typedef struct student
{
    char name[32];
    int id;
    float score;
    char gender; // 数据域
 
    struct student *next; // 存储指向下一个节点的指针
    struct student *prev;//存储指向上一个节点的指针
 
} STU;

拓展：可以数据域定一个指针，用来动态开辟，比较复杂。

3.动态单向无头链表

3.1头插法

顾名思义就是在一个node节点的前面加上插入一个node节点。

我们可以使用多文件编程；

student.h

#ifndef _STUDENT_H
#define _STUDENT_H
 
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
typedef struct student
{
    char name[32];
    int id;
    float score;
    char gender; // 数据域
    struct student *next; // 指针域
} STU;
 
 
/// @brief 函数功能：头插法，将节点插入链表
/// @param head  ：指针，指向整个链表首元素的指针
/// @param stu ：stu 新增节点的数据
/// @return   返回一个head的新地址
STU * HeadInsert(STU *head,STU stu);
 
/// @brief 函数功能，遍历整个链表
/// @param head  传入的链表的第一个元素
void ShowNode(STU *head);
 
#endif
 

student.c

#include "student.h"
 
STU * HeadInsert(STU *head,STU stu)
{
    STU *flag =(STU *) malloc(sizeof(stu));
    if (flag == NULL)
    {
        perror("malloc");
    }
    else
    {
        *flag = stu;   //数据域赋值
        flag->next = NULL;   //指针域赋值，赋值为NULL
    }
 
    if (head== NULL)  //链表里面没有元素
    {
        head = flag;   //head 指向这个节点，即这就是第一个节点
        return head;
    }
    else
    {
        flag->next = head;
        head = flag;  //顺序不能交换，否则会丢失整个链表
        return head;
    }
 
}
 
 
 
void ShowNode(STU *head)
{
    STU *flag = head;
    
    while (flag != NULL)
    {
        printf("NAME:%s ID:%d   SCORE:%0.1f GENDER:%c\n",
            flag->name,flag->id,flag->score,flag->gender);
            flag = flag->next;
    }
    
}

main.c

#include "student.h"
 
int main(int argc, char const *argv[])
{
    STU *head = NULL;
    STU stu1 = {"漫夜", 1, 80.0F, 'M'};
    STU stu2 = {"星河", 2, 100.0F, 'M'};
    STU stu3 = {"man", 3, 100.0F, 'M'};
 
    head = HeadInsert(head, stu1);
    head = HeadInsert(head, stu2);
    head = HeadInsert(head, stu3);
 
    ShowNode(head);
 //打印出来的顺序：
//man，星河，漫夜


    return 0;
}

3.2尾插法

STU *TailInsert(STU *head, STU stu)
{
    STU *flag = (STU *)malloc(sizeof(stu));
    if (flag == NULL)
    {
        perror("malloc");
    }
    else
    {
        *flag = stu; // stu的值赋给flag节点
        // strcpy(flag->name,stu.name);
        // flag->id = stu.id;
        //  flag->gender = stu.gender;
        // flag->score = stu.score;
        flag->next = NULL; // 指针域赋值，赋值为NULL
    }
    if (head == NULL)
    {
        head = flag;  //如果是第一个，头插尾插都一样
        return head;
    }
    else
    {
        STU *tail = head;
        while (tail->next != NULL)
        {
            tail = tail->next;  //找到最后一个元素
        }
        tail->next = flag;   //将新申请的元素插入到这个节点后面
        return head;
    }
}

4.动态双向有头链表

链表表头：是一个特殊节点，不存储任何数据信息，但是可以存储一些辅助信息，协助我们进行链表管理。

例如：

• STU * first
• STU*last
• size_t size

基于双向有头动态链表的学生信息管理系统关键机构体设计：

学生结构体：

节点结构体：

表头结构体：