c语言链表：从入门到精通

回顾

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

数组的优点：

• 访问简单
• 连续性空间

数组的缺点：

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

链表

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

物理上：非连续

逻辑上：连续性的

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

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

链表分类：

有头链表

• 有头单向
• 有头双向

无头链表

• 无头单向
• 无头双向

链表中的头：

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

1.静态单向无头链表

#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.静态双向无头链表

typedef struct student
{
    char name[32];
    int id;
    float score;
    char gender; // 数据域

    struct student *next; // 指针域
    struct student *prev;

} STU;

拓展：数据域和指针域分开

2.动态单向无头链表

1.头插法(多文件编程)

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;
    }
    
}

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

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 = {"西罗", 3, 100.0F, 'M'};

    head = HeadInsert(head, stu1);
    head = HeadInsert(head, stu2);
    head = HeadInsert(head, stu3);

    ShowNode(head);

    return 0;
}

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;
    }
}

3.动态双向有头链表

双向无头链表

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

例如：

• STU * first
• STU*last
• size_t size

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

学生结构体：

节点结构体：

表头结构体：

案例：

学生成绩管理系统中用动态双向有头链表存储数据（部分代码）

/// @brief 定义了学生结构体（数据域）
typedef struct student
{
    char name[32];
    int id;
    float score;
    char gender;
} STU4;

STU4 *get_student(FILE *file)
{
    STU4 *temp = (STU4 *)malloc(sizeof(STU4)) ;
    char temp1[500] = {0};
    fgets(temp1, sizeof(temp1), file);
    sscanf(temp1, "NAME:%s ,ID:%d,SCORE:%f,GENDER:%c\n", temp->name, &(temp->id), &(temp->score), &(temp->gender));
    return temp ;
}

/// @brief 定义了链表（存储指针和数据域）
typedef struct node
{
    STU4 *stu;
     struct node *next;
     struct node *prev;
    
} Node;


Node *get_node(STU4 * stu)
{
    Node *temp = (Node *)malloc(sizeof(Node));
    temp->next = NULL;
    temp->prev = NULL;
    temp->stu = stu;
    return temp;
}


/// @brief 定义了链表的头部（结构体）
typedef struct linkhead
{
    Node *first;
    Node *last;
    int size;
} LH;

/// @brief 将栈里面的数据赋值到新开辟的空间
/// @param node  用户提供的一个Node类型的指针
/// @return 返回一个LH类型的指针
LH *get_linkhead(void);

LH *get_linkhead(void)
{
    LH *temp = (LH *)malloc(sizeof(LH));
    temp->first = NULL;
    temp->last = NULL;
    temp->size = 0;
    return temp;
}



/// @brief 用户提供一个LH类型的指针和一个FILE类型的指针，函数执行完初始化开辟空间，将学生信息从txt文本文件录入链表中
/// @param head 用户提供的一个LH类型的指针
/// @param file 用户提供的一个FILE类型的指针
/// @return 返回一个LH类型的指针
LH *Init(LH *head, FILE *file);


LH *Init(LH *head, FILE *file)
{
    int num = 0;
    printf("请输入文本中学生个数：\n");
    scanf("%d", &num);
    for (int i = 0; i < num; i++)
    {
        head = input_student(get_node(get_student(file)), head);
    }
    fclose(file);
    return head;
}