单向链表——C语言描述

单向链表：

• 链表是由一系列的节点组成，每个节点包含两个域，指针域和数据域

线性表的顺序存储：

• 用一块连续内存空间

线性表的链式存储：

• 不连续的内存空间

代码示例：
单向链表.c

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include"LinkList.h"
//自定义数据类型
typedef struct PERSON
{
   
        char name[64];
        int age;
        int score;
}Person;
//打印函数
void  MyPrint(void*data)
{
   
        Person*p = (Person*)data;
        printf("Name:%s Age:%d Score:%d\n", p->name, p->age, p->score);
}
//测试
void test01()
{
   
        //创建链表
        LinkList*list = Init_LinkList();
        //创建数据
        Person p1 = {
    "aaa",18,100 };
        Person p2 = {
    "bbb",19,99 };
        Person p3 = {
    "ccc",20,101 };
        Person p4 = {
    "ddd",17,97 };
        Person p5 = {
    "eee",16,59 };
        //数据插入链表
        Insert_LinkList(list, 0, &p1);
        Insert_LinkList(list, 0, &p2);
        Insert_LinkList(list, 0, &p3);
        Insert_LinkList(list, 0, &p4);
        Insert_LinkList(list, 0, &p5);
        //打印
        Print_LinkList(list, MyPrint);
        //删除3
        RemoveByPos_LinkList(list, 3);
        //打印
        printf("-----------------\n");
        Print_LinkList(list, MyPrint);
        //返回第一个结点
        printf("------------查找结果--------\n");
        Person*ret = (Person*)Front_LinkList(list);
        printf("Name:%s Age:%d Score:%d\n", ret->name, ret->age, ret->score);
        //销毁数据
        FreeSpace_LinkList(list);
}
int main()
{
   
        test01();
        return EXIT_SUCCESS;
}

LinkList.c

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include"LinkList.h"
//初始化链表
LinkList*Init_LinkList()
{
   
        LinkList*list = (LinkList*)malloc(sizeof(LinkList));
        list->size = 0;
        //头结点 是不保存数据信息
        list->head = (LinkNode*)malloc(sizeof(LinkNode));
        list->head->data = NULL;
        list->head->next = NULL;
        return list;
}
//指定位置插入
void Insert_LinkList(LinkList*list, int pos, void*data)
{
   
        if (list == NULL)
        {
   
               return;
        }
        if (data == NULL)
        {
   
               return;
        }
        //友好的处理，pos越界
        if (pos<0 || pos>list->size)
        {
   
               pos = list->size;
        }
        //创建新的结点
        LinkNode*newnode = (LinkNode*)malloc(sizeof(LinkNode));
        newnode->data = data;
        newnode->next = NULL;
        //找结点
        //辅助指针变量
        LinkNode*pCurrent = list->head;
        for (int i = 0; i < pos; i++)
        {
   
               pCurrent = pCurrent->next;
        }
        //新结点
        newnode->next = pCurrent->next;
        pCurrent->next = newnode;
        list->size++;
}
//删除指定位置的值
void RemoveByPos_LinkList(LinkList*list, int pos)
{
   
        if (list == NULL)
        {
   
               return;
        }
        if (pos < 0 || pos >= list->size)
        {
   
               return;
        }
        //查找删除结点的前一个结点
        LinkNode*pCurrent = list->head;
        for (int i = 0; i < pos; i++)
        {
   
               pCurrent = pCurrent->next;
        }
        //缓存删除的结点
        LinkNode*pDel = pCurrent->next;
        pCurrent->next = pDel->next;
        //释放删除结点的内存
        free(pDel);
        list->size--;
}
//获得链表的长度
int Size_LinkList(LinkList*list)
{
   
        return 0;
}
//查找
int Find_LinkList(LinkList*list, void*data)
{
   
        if (list == NULL)
        {
   
               return -1;
        }
        if (data == NULL)
        {
   
               return -1;
        }
        //遍历查找
        LinkNode*pCurrent = list->head->next;
        int i = 0;
        while (pCurrent!=NULL)
        {
   
               if (pCurrent->data == data)
               {
   
                       break;
               }
               i++;
               pCurrent = pCurrent->next;
        }
        return i;
}
//返回第一个节点
void* Front_LinkList(LinkList*list)
{
   
        return list->head->next->data;
}
//打印链表节点
void Print_LinkList(LinkList*list, PRINTLINKNODE print)
{
   
        if (list == NULL)
        {
   
               return;
        }
        //辅助指针变量
        LinkNode*pCurrent = list->head->next;
        while (pCurrent!=NULL)
        {
   
               print(pCurrent->data);
               pCurrent = pCurrent->next;
        }
}
//释放链表内存
void FreeSpace_LinkList(LinkList*list)
{
   
        if (list == NULL)
        {
   
               return;
        }
        //辅助指针变量
        LinkNode*pCurrent = list->head;
        while (pCurrent!=NULL)
        {
   
               //缓存下一个结点
               LinkNode*pNext = pCurrent->next;
               free(pCurrent);
               pCurrent = pNext;
        }
        //释放链表内存
        list->size = 0;
        free(list);
}

LinkList.h

#ifndef LINKLIST_H
#define LINKLIST_H
#include<stdlib.h>
#include<stdio.h>
//链表节点
typedef struct LINKNODE
{
   
        void *data;    //指向任何类型的数据
        struct LINKNODE*next;
}LinkNode;
//链表结构体
typedef struct LINKLIST
{
   
        LinkNode*head;
        int size;
        //没有容量的概念
}LinkList;
//打印函数指针
typedef void(*PRINTLINKNODE)(void*);
//初始化链表
LinkList*Init_LinkList();
//指定位置插入
void Insert_LinkList(LinkList*list, int pos, void*data);
//删除指定位置的值
void RemoveByPos_LinkList(LinkList*list, int pos);
//获得链表的长度
int Size_LinkList(LinkList*list);
//查找
int Find_LinkList(LinkList*list, void*data);
//返回第一个节点
void* Front_LinkList(LinkList*list);
//打印链表节点
void Print_LinkList(LinkList*list, PRINTLINKNODE print);
//释放链表内存
void FreeSpace_LinkList(LinkList*list);
#endif