c语言提高学习笔记——03-c提高08day_数据结构

在学习c语言提高-数据结构总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。

03-c提高08day_数据结构

目录：
1、数据结构理论
（1）数据结构概念
（2）算法的概念
2、线性表
（1）线性表基本概念
（2）线性表的顺序存储
练习1：
动态数组（+初始化、+插入、+遍历）
动态数组（+删除、+销毁）
动态数组（分文件实现）
练习2：
单向链表（版本一）——（+初始化、+插入、+遍历）
单向链表（版本一）——（+值删除、+位置删除、+大小、+清空、+销毁）
 练习3：
单向链表（版本二）

1、数据结构理论
（1）数据结构概念
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合，通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术有关。

数据结构是计算机存储、组织数据的方式。

（2）算法的概念
算法是特定问题求解步骤的描述，在计算机中表现为指令的有限序列，算法是独立存在的一种解决问题的方法和思想。

对于算法而言，语言并不重要，重要的是思想。

2、线性表

（1）线性表基本概念
线性结构是一种最简单且常用的数据结构。线性结构的基本特点是节点之间满足线性关系。本章讨论的动态数组、链表、栈、队列都屈于线性结构。他们的共同之处，是节点中有且只有一个开始节点和终端节点。按这种关系，可以把它们的所有节点排列成一个线性序列。但是，他们分别屈于几种不同的抽象数据类型实现，它们之间的区别，主要就是操作的不同。

线性表是零个或者多个数据元素的有限序列，数据元素之问是有顺序的，数据元素个数是有限的，数据元素的类型必须相同。

（2）线性表的顺序存储

通常线性表可以采用顺序存储和链式存储。这节课我们主要探讨顺序存储结构以及对应的运算算法的实现。

采用顺序存储是表示线性表最简单的方法，具体做法是：将线性表中的元素一个接一个的存储在一块连续的存储区域中，这种顺序表示的线性表也称为顺序表。

练习1：

动态数组（+初始化、+插入、+遍历）

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

1.先把所需要的数据信息结构定义下来
struct DynamicArray
{
    //数组存储元素的空间的首地址
    void** addr;
    //存储数据的内存中最大能够容纳多少元素
    int capacity;//容量
    //当前存储数据的内存中有多少个元素
    int size;//大小
};

//初始化数组
struct DynamicArray* Init_DynamicArray(int capacity)
{
    if(capacity <= 0)
    {
        return NULL;
    }
    struct DynamicArray* arr = malloc(sizeof(struct DynamicArray));
    if(NULL == arr)
    {
        return NULL;
    }
    arr->capacity = capacity;
    arr->addr = malloc(sizeof(void*) * arr->capacity);
    arr->size = 0;
    
    return arr;
}
//插入元素
void Insert_DynamicArray(struct DynamicArray* arr, int pos, void* data)
{
    if(NULL == arr)
    {
        return;
    }
    if(NULL == data)
    {
        return;
    }
    if(pos < 0 || pos > arr->size)//检查插入位置的合法性
    {
        pos = arr->size;
    }
    if(arr->size >= arr->capacity)
    {
        //1.申请一块更大的内存空间
        int newcapacity = arr->capacity * 2;
        void** newspace = malloc(sizeof(void*) * newcapacity);
        
        //2.将原来空间的数据拷贝到新空间
        memcpy(newspace, arr->addr, sizeof(void*) * arr->capacity);
        
        //3.释放原来空间的内存
        free(arr->addr);
        
        //4.更新addr指向
        arr->addr = newspace;
        arr->capacity = newcapacity;
    }
    
    //移动元素，给pos位置空出位置来
    for(int i = arr->size - 1; i >= pos; --i)
    {
        arr->addr[i + 1] = addr->addr[i];
    }
    
    //将新元素插入到pos位置
    arr->addr[pos] = data;
    arr->size++;
}
//遍历
void Foreach_DynamicArray(struct DynamicArray* arr, void(*_callback)(void*))
{
    if(NULL == arr)
    {
        return;
    }
    if(NULL == _callback)
    {
        return;
    }
    for(int i = 0; i < arr->size; ++i)
    {
        _callback(arr->addr[i]);
    }
}

//初始化数组
struct DynamicArray* Init_DynamicArray(int capacity);
//插入元素
void Insert_DynamicArray(struct DynamicArray* arr, int pos, void* data);
//遍历
void Foreach_DynamicArray(struct DynamicArray* arr, void(*_callback)(void*));


struct Person
{
    char name[64];
    int age;
};

void myPrint(void* data)
{
    struct Person* person = (struct Person*)data;
    printf("Name:%s Age:%d
", person->name, person->age);
}

void test()
{
    //创建动态数组
    struct DynamicArray* da = Init_DynamicArray(5);
    //动态数组添加元素
    struct Person p1 = {"aaa", 10};
    struct Person p2 = {"bbb", 20};
    struct Person p3 = {"ccc", 30};
    struct Person p4 = {"ddd", 40};
    struct Person p5 = {"eee", 50};
    struct Person p6 = {"fff", 60};
    
    Insert_DynamicArray(da, 100, &p1);
    Insert_DynamicArray(da, 100, &p2);
    Insert_DynamicArray(da, 100, &p3);
    Insert_DynamicArray(da, 100, &p4);
    Insert_DynamicArray(da, 100, &p5);
    
    printf("capacity:%d
", da->capacity);//打印容量
    Insert_DynamicArray(da, 100, &p6);//超出空间容量，扩大一倍
    printf("capacity:%d
", da->capacity);//打印容量
    
    Foreach_DynamicArray(data, myPrint);
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

 动态数组（+删除、+销毁）

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

1.先把所需要的数据信息结构定义下来
struct DynamicArray
{
    //数组存储元素的空间的首地址
    void** addr;
    //存储数据的内存中最大能够容纳多少元素
    int capacity;//容量
    //当前存储数据的内存中有多少个元素
    int size;//大小
};

//初始化数组
struct DynamicArray* Init_DynamicArray(int capacity)
{
    if(capacity <= 0)
    {
        return NULL;
    }
    struct DynamicArray* arr = malloc(sizeof(struct DynamicArray));
    if(NULL == arr)
    {
        return NULL;
    }
    arr->capacity = capacity;
    arr->addr = malloc(sizeof(void*) * arr->capacity);
    arr->size = 0;
    
    return arr;
}
//插入元素
void Insert_DynamicArray(struct DynamicArray* arr, int pos, void* data)
{
    if(NULL == arr)
    {
        return;
    }
    if(NULL == data)
    {
        return;
    }
    if(pos < 0 || pos > arr->size)//检查插入位置的合法性
    {
        pos = arr->size;
    }
    
    //判断空间是否足够
    if(arr->size >= arr->capacity)
    {
        //1.申请一块更大的内存空间
        int newcapacity = arr->capacity * 2;
        void** newspace = malloc(sizeof(void*) * newcapacity);
        
        //2.将原来空间的数据拷贝到新空间
        memcpy(newspace, arr->addr, sizeof(void*) * arr->capacity);
        
        //3.释放原来空间的内存
        free(arr->addr);
        
        //4.更新addr指向
        arr->addr = newspace;
        arr->capacity = newcapacity;
    }
    
    //移动元素，给pos位置空出位置来
    for(int i = arr->size - 1; i >= pos; --i)
    {
        arr->addr[i + 1] = addr->addr[i];
    }
    
    //将新元素插入到pos位置
    arr->addr[pos] = data;
    arr->size++;
}
//遍历
void Foreach_DynamicArray(struct DynamicArray* arr, void(*_callback)(void*))
{
    if(NULL == arr)
    {
        return;
    }
    if(NULL == _callback)
    {
        return;
    }
    for(int i = 0; i < arr->size; ++i)
    {
        _callback(arr->addr[i]);
    }
}

//位置删除
void RemoveByPos_DynamicArray(struct DynamicArray* arr, int pos)
{
    if(NULL == arr)
    {
        return;
    }
    if(pos < 0 || pos > arr->size - 1)
    {
        return;
    }
    
    for(int i = pos; i < arr->size -1; ++i)
    {
        arr->addr[i] = arr->addr[i + 1];
    }
    arr->size--;
}

//按值删除
void RemoveByValue(struct DynamicArray* arr, void* data, int(*compare)(void*, void*))
{
    if(NULL == arr)
    {
        return;
    }
    if(NULL == data)
    {
        return;
    }
    if(NULL == compare)
    {
        return;
    }
    
    for(int i = 0; i < arr->size; ++i)
    {
        if(compare(arr->addr[i], data))
        {
            RemoveByPos_DynamicArray(arr, i);
            break;
        }
    }
    
}

//销毁数组
void Destroy_DynamicArray(struct DynamicArray* arr)
{
    if(NULL == arr)
    {
        return;
    }    
    if(arr->addr != arr)
    {
        free(arr->addr);
        arr->addr = NULL;
    }
    free(arr);
    arr = NULL;            
}

//初始化数组
struct DynamicArray* Init_DynamicArray(int capacity);
//插入元素
void Insert_DynamicArray(struct DynamicArray* arr, int pos, void* data);
//遍历
void Foreach_DynamicArray(struct DynamicArray* arr, void(*_callback)(void*));


struct Person
{
    char name[64];
    int age;
};

void myPrint(void* data)
{
    struct Person* person = (struct Person*)data;
    printf("Name:%s Age:%d
", person->name, person->age);
}

int myCompare(void* d1, void* d2)
{
    struct person* p1 = (struct Person*)d1;
    struct person* p2 = (struct Person*)d2;
    
    return strcmp(p1->name, p2->name) == 0 && p1->age == p2->age;
}


void test()
{
    //创建动态数组
    struct DynamicArray* da = Init_DynamicArray(5);
    //动态数组添加元素
    struct Person p1 = {"aaa", 10};
    struct Person p2 = {"bbb", 20};
    struct Person p3 = {"ccc", 30};
    struct Person p4 = {"ddd", 40};
    struct Person p5 = {"eee", 50};
    struct Person p6 = {"fff", 60};
    
    Insert_DynamicArray(da, 0, &p1);
    Insert_DynamicArray(da, 0, &p2);
    Insert_DynamicArray(da, 0, &p3);
    Insert_DynamicArray(da, 1, &p4);
    Insert_DynamicArray(da, 1, &p5);
    
    printf("capacity:%d
", da->capacity);//打印容量
    Insert_DynamicArray(da, 100, &p6);//超出空间容量，扩大一倍3 5 4 2 1 6
    printf("capacity:%d
", da->capacity);//打印容量
    
    Foreach_DynamicArray(data, myPrint);
    
    printf("-----------------
");
    RemoveByPos_DynamicArray(data, 2);//3 5 2 1 6
    Foreach_DynamicArray(data, myPrint);
    
    printf("-----------------
");
    struct Person pDel = {"aaa", 10};
    RemoveByValue(da, &pDel, myCompare);
    Foreach_DynamicArray(data, myPrint);
    
    //销毁
    Destroy_DynamicArray(da);
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

动态数组（分文件实现）

动态数组.c

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#inlcude"DynamicArray.h"


struct Person
{
    char name[64];
    int age;
};

void myPrint(void* data)
{
    struct Person* person = (struct Person*)data;
    printf("Name:%s Age:%d
", person->name, person->age);
}

int myCompare(void* d1, void* d2)
{
    struct person* p1 = (struct Person*)d1;
    struct person* p2 = (struct Person*)d2;
    
    return strcmp(p1->name, p2->name) == 0 && p1->age == p2->age;
}


void test()
{
    //创建动态数组
    struct DynamicArray* da = Init_DynamicArray(5);
    //动态数组添加元素
    struct Person p1 = {"aaa", 10};
    struct Person p2 = {"bbb", 20};
    struct Person p3 = {"ccc", 30};
    struct Person p4 = {"ddd", 40};
    struct Person p5 = {"eee", 50};
    struct Person p6 = {"fff", 60};
    
    Insert_DynamicArray(da, 0, &p1);
    Insert_DynamicArray(da, 0, &p2);
    Insert_DynamicArray(da, 0, &p3);
    Insert_DynamicArray(da, 1, &p4);
    Insert_DynamicArray(da, 1, &p5);
    
    printf("capacity:%d
", da->capacity);//打印容量
    Insert_DynamicArray(da, 100, &p6);//超出空间容量，扩大一倍3 5 4 2 1 6
    printf("capacity:%d
", da->capacity);//打印容量
    
    Foreach_DynamicArray(data, myPrint);
    
    printf("-----------------
");
    RemoveByPos_DynamicArray(data, 2);//3 5 2 1 6
    Foreach_DynamicArray(data, myPrint);
    
    printf("-----------------
");
    struct Person pDel = {"aaa", 10};
    RemoveByValue(da, &pDel, myCompare);
    Foreach_DynamicArray(data, myPrint);
    
    //销毁
    Destroy_DynamicArray(da);
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

DynamicArray.h

#pragma once

#include<stdlib.h>
#include<stdio.h>
#include<string.h>

#ifdef __cplusplus
extern "C"{

    1.先把所需要的数据信息结构定义下来
    struct DynamicArray
    {
        //数组存储元素的空间的首地址
        void** addr;
        //存储数据的内存中最大能够容纳多少元素
        int capacity;//容量
        //当前存储数据的内存中有多少个元素
        int size;//大小
    };

    //初始化数组
    struct DynamicArray* Init_DynamicArray(int capacity);
    //插入元素
    void Insert_DynamicArray(struct DynamicArray* arr, int pos, void* data);
    //遍历
    void Foreach_DynamicArray(struct DynamicArray* arr, void(*_callback)(void*));
    //位置删除
    void RemoveByPos_DynamicArray(struct DynamicArray* arr, int pos);
    //按值删除
    void RemoveByValue(struct DynamicArray* arr, void* data, int(*compare)(void*, void*));
    //销毁数组
    void Destroy_DynamicArray(struct DynamicArray* arr);

#ifdef __cplusplus
}
#endif

DynamicArray.c

#inlcude"DynamicArray.h"

1.先把所需要的数据信息结构定义下来
struct DynamicArray
{
    //数组存储元素的空间的首地址
    void** addr;
    //存储数据的内存中最大能够容纳多少元素
    int capacity;//容量
    //当前存储数据的内存中有多少个元素
    int size;//大小
};

//初始化数组
struct DynamicArray* Init_DynamicArray(int capacity)
{
    if(capacity <= 0)
    {
        return NULL;
    }
    struct DynamicArray* arr = malloc(sizeof(struct DynamicArray));
    if(NULL == arr)
    {
        return NULL;
    }
    arr->capacity = capacity;
    arr->addr = malloc(sizeof(void*) * arr->capacity);
    arr->size = 0;
    
    return arr;
}
//插入元素
void Insert_DynamicArray(struct DynamicArray* arr, int pos, void* data)
{
    if(NULL == arr)
    {
        return;
    }
    if(NULL == data)
    {
        return;
    }
    if(pos < 0 || pos > arr->size)//检查插入位置的合法性
    {
        pos = arr->size;
    }
    
    //判断空间是否足够
    if(arr->size >= arr->capacity)
    {
        //1.申请一块更大的内存空间
        int newcapacity = arr->capacity * 2;
        void** newspace = malloc(sizeof(void*) * newcapacity);
        
        //2.将原来空间的数据拷贝到新空间
        memcpy(newspace, arr->addr, sizeof(void*) * arr->capacity);
        
        //3.释放原来空间的内存
        free(arr->addr);
        
        //4.更新addr指向
        arr->addr = newspace;
        arr->capacity = newcapacity;
    }
    
    //移动元素，给pos位置空出位置来
    for(int i = arr->size - 1; i >= pos; --i)
    {
        arr->addr[i + 1] = addr->addr[i];
    }
    
    //将新元素插入到pos位置
    arr->addr[pos] = data;
    arr->size++;
}
//遍历
void Foreach_DynamicArray(struct DynamicArray* arr, void(*_callback)(void*))
{
    if(NULL == arr)
    {
        return;
    }
    if(NULL == _callback)
    {
        return;
    }
    for(int i = 0; i < arr->size; ++i)
    {
        _callback(arr->addr[i]);
    }
}

//位置删除
void RemoveByPos_DynamicArray(struct DynamicArray* arr, int pos)
{
    if(NULL == arr)
    {
        return;
    }
    if(pos < 0 || pos > arr->size - 1)
    {
        return;
    }
    
    for(int i = pos; i < arr->size -1; ++i)
    {
        arr->addr[i] = arr->addr[i + 1];
    }
    arr->size--;
}

//按值删除
void RemoveByValue(struct DynamicArray* arr, void* data, int(*compare)(void*, void*))
{
    if(NULL == arr)
    {
        return;
    }
    if(NULL == data)
    {
        return;
    }
    if(NULL == compare)
    {
        return;
    }
    
    for(int i = 0; i < arr->size; ++i)
    {
        if(compare(arr->addr[i], data))
        {
            RemoveByPos_DynamicArray(arr, i);
            break;
        }
    }
    
}

//销毁数组
void Destroy_DynamicArray(struct DynamicArray* arr)
{
    if(NULL == arr)
    {
        return;
    }    
    if(arr->addr != arr)
    {
        free(arr->addr);
        arr->addr = NULL;
    }
    free(arr);
    arr = NULL;            
}

练习2：单向链表（版本一）——（+初始化、+插入、+遍历）

内存模型图如下：

单向链表（版本一）.c

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include"LinkList.h"

struct Person
{
    char name[64];
    int age;
};

void myPrint(void* data)
{
    struct Person* person = (struct Person*)data;
    printf("Name:%s Age:%d
", person->name, person->age);
}

void test()
{
    //创建链表
    LinkList list = Init_LinkList();
    
    //创建数据
    struct Person p1 = {"aaa", 10};
    struct Person p2 = {"bbb", 20};
    struct Person p3 = {"ccc", 30};
    struct Person p4 = {"ddd", 40};
    struct Person p5 = {"eee", 50};
    struct Person p6 = {"fff", 60};
    struct Person p7 = {"ggg", 70};
    
    //插入数据
    Insert_LinkList(list, 0, &p1);
    Insert_LinkList(list, 0, &p2);
    Insert_LinkList(list, 1, &p3);//2 3 1
    Insert_LinkList(list, 2, &p4);//2 3 4 1
    Insert_LinkList(list, 20, &p5);//2 3 4 1 5
    Insert_LinkList(list, 3, &p6);//2 3 6 4 1 5
    Insert_LinkList(list, 6, &p7);//2 3 6 4 1 7 5
    
    Foreach_LinkList(list, myPrint);
}
    
int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

LinkList.h

#pragma once

#include<stdlib.h>
#include<string.h>
#include<stdio.h>

#ifdef __cpluscplus
extern "C"{
#endif


    
    typedef void* LinkList;
    typedef void(*FOREACH)(void*);
    
    //初始化链表
    LinkList Init_LinkList();
    //插入结点
    void Insert_LinkList(LinkList list, int pos, void* data);
    //遍历链表
    void Foreach_LinkList(LinkList list, FOREACH myforeach);


#ifdef __cpluscplus
}
#endif

LinkList.c

#include"LinkList.h"

//链表结点数据类型
struct LinkNode
{
    void* data;
    struct LinkNode* next;
};

//链表数据类型
struct LList
{
    struct LinkNode header;
    int size;
};

//初始化链表
LinkList Init_LinkList()
{
    struct LList* list = malloc(sizeof(struct LList));
    if(NULL == list)
    {
        return NULL;
    }
    list->header.data = NULL;
    list->header.next = NULL;
    list->size = 0;
    
    return list;
}
//插入结点
void Insert_LinkList(LinkList list, int pos, void* data)
{
    if(NULL == list)
    {
        return;
    }
    if(NULL == data)
    {
        return;
    }    
    
    struct LList* mylist = (struct LList*)list;
    
    if(pos < 0 || pos > mylist->size)
    {
        pos = mylist->size;
    }
    
    //查找插入位置
    struct LinkNode* pCurrent = &(mylist->header);
    for(int i = 0; i < pos; ++i)
    {
        pCurrent = pCurrent->next;    
    }
    
    //创建新结点
    struct LinkNode* newnode = malloc(sizeof(struct LinkNode));
    newnode->data = data;
    newnode->next = NULL;
    
    //新结点插入到链表中
    newnode->next = pCurrent->next;
    pCurrent->next = newnode;
    
    mylist->size++;
}
//遍历链表
void Foreach_LinkList(LinkList list, FOREACH myforeach)//回调函数
{
    if(NULL == list)
    {
        return;
    }
    if(NULL == myforeach)
    {
        return;
    }
    
    struct LList* mylist = (struct LList*)list;
    
    struct LinkNode* pCurrent = mylist->header.next;
    
    while(pCurrent != NULL)
    {
        myforeach(pCurrent->data);
        pCurrent = pCurrent->next;
    }
    
}

单向链表（版本一）——（+值删除、+位置删除、+大小、+清空、+销毁）

单向链表（版本一）.c

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include"LinkList.h"

struct Person
{
    char name[64];
    int age;
};

void myPrint(void* data)
{
    struct Person* person = (struct Person*)data;
    printf("Name:%s Age:%d
", person->name, person->age);
}

int myCompare(void* d1, void* d2)
{
    struct Person* p1 = (struct Person*)d1;
    struct Person* p2 = (struct Person*)d2;

#if 0    
    if(strcmp(p1->name, p2->name) == 0 && p1->age == p2->age)
    {
        return 1;
    }
    return 0;
#endif
    return strcmp(p1->name, p2->name) == 0 && p1->age == p2->age;
}

void test()
{
    //创建链表
    LinkList list = Init_LinkList();
    
    //创建数据
    struct Person p1 = {"aaa", 10};
    struct Person p2 = {"bbb", 20};
    struct Person p3 = {"ccc", 30};
    struct Person p4 = {"ddd", 40};
    struct Person p5 = {"eee", 50};
    struct Person p6 = {"fff", 60};
    struct Person p7 = {"ggg", 70};
    
    //插入数据
    Insert_LinkList(list, 0, &p1);
    Insert_LinkList(list, 0, &p2);
    Insert_LinkList(list, 1, &p3);//2 3 1
    Insert_LinkList(list, 2, &p4);//2 3 4 1
    Insert_LinkList(list, 20, &p5);//2 3 4 1 5
    Insert_LinkList(list, 3, &p6);//2 3 6 4 1 5
    Insert_LinkList(list, 6, &p7);//2 3 6 4 1 7 5
    
    Foreach_LinkList(list, myPrint);
    
    printf("----------
");
    printf("List Size:%d
", Size_LinkList(list));
    RemoveByPos_LinkList(list, 3);
    printf("----------
");
    Foreach_LinkList(list, myPrint);
    
    struct Person pDelPerson = {"ggg", 70};
    RemoveByVal_LinkList(list, &pDelPerson, myCompare);
    printf("----------
");
    Foreach_LinkList(list, myPrint);    
    
    //清空链表
    Clear_LinkList(list);
    printf("----------
");
    Foreach_LinkList(list, myPrint);    
    
    //销毁链表
    Destroy_LinkList(list);
}
    
int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

LinkList.h

#pragma once

#include<stdlib.h>
#include<string.h>
#include<stdio.h>

#ifdef __cpluscplus
extern "C"{
#endif


    
    typedef void* LinkList;
    typedef void(*FOREACH)(void*);
    typedef int*(*COMPARE)(void*, void*);
    
    //初始化链表
    LinkList Init_LinkList();
    //插入结点
    void Insert_LinkList(LinkList list, int pos, void* data);
    //遍历链表
    void Foreach_LinkList(LinkList list, FOREACH myforeach);
    //按位置删除
    void RemoveByPos_LinkList(LinkList list, int pos);
    //按值删除
    void RemoveByVal_LinkList(LinkList list, void* data, COMPARE compare);
    //清空链表
    void Clear_LinkList(LinkList list);
    //大小
    int Size_LinkList(LinkList list);
    //销毁链表
    void Destroy_LinkList(LinkList list);

#ifdef __cpluscplus
}
#endif

LinkList.c

#include"LinkList.h"

//链表结点数据类型
struct LinkNode
{
    void* data;
    struct LinkNode* next;
};

//链表数据类型
struct LList
{
    struct LinkNode header;
    int size;
};

//初始化链表
LinkList Init_LinkList()
{
    struct LList* list = malloc(sizeof(struct LList));
    if(NULL == list)
    {
        return NULL;
    }
    list->header.data = NULL;
    list->header.next = NULL;
    list->size = 0;
    
    return list;
}
//插入结点
void Insert_LinkList(LinkList list, int pos, void* data)
{
    if(NULL == list)
    {
        return;
    }
    if(NULL == data)
    {
        return;
    }    
    
    struct LList* mylist = (struct LList*)list;
    
    if(pos < 0 || pos > mylist->size)
    {
        pos = mylist->size;
    }
    
    //查找插入位置
    struct LinkNode* pCurrent = &(mylist->header);
    for(int i = 0; i < pos; ++i)
    {
        pCurrent = pCurrent->next;    
    }
    
    //创建新结点
    struct LinkNode* newnode = malloc(sizeof(struct LinkNode));
    newnode->data = data;
    newnode->next = NULL;
    
    //新结点插入到链表中
    newnode->next = pCurrent->next;
    pCurrent->next = newnode;
    
    mylist->size++;
}
//遍历链表
void Foreach_LinkList(LinkList list, FOREACH myforeach)//回调函数
{
    if(NULL == list)
    {
        return;
    }
    if(NULL == myforeach)
    {
        return;
    }
    
    struct LList* mylist = (struct LList*)list;
    
    struct LinkNode* pCurrent = mylist->header.next;
    
    while(pCurrent != NULL)
    {
        myforeach(pCurrent->data);
        pCurrent = pCurrent->next;
    }
    
}

//按位置删除
void RemoveByPos_LinkList(LinkList list, int pos)
{
    if(NULL == list)
    {
        return;
    }
    struct LList* mylist = (struct LList*)list;
    
    if(pos < 0 || pos > mylist->size - 1)
    {
        return;
    }
    //找位置
    struct LinkNode* pCurrent = &(mylist->header);
    for(int i = 0; i < pos; ++i)
    {
        pCurrent = pCurrent->next;
    }
    
    //先保存待删除结点
    struct LinkNode* pDel = pCurrent->next;
    //重新建立待删除结点的前驱和后继结点关系
    pCurrent->next = pDel->next;
    //释放删除结点内存
    free(pDel);
    pDel = NULL;
    
    mylist->size--;
}
//按值删除
void RemoveByVal_LinkList(LinkList list, void* data, COMPARE compare)
{
    if(NULL == list)
    {
        return;
    }    
    if(NULL == data)
    {
        return;
    }
    if(NULL == compare)
    {
        return;
    }
    
    struct LList* mylist = (struct LList*)list;
    //辅助指针变量
    struct LinkNode* pPrev = &(mylist->header);
    struct LinkNode* pCurrent = pPrev->next;
    while(pCurrent != NULL)
    {
        if(compare(pCurrent->data, data))
        {
            //找到了
            pPrev->next = pCurrent->next;
            //释放删除结点内存
            free(pCurrent);
            pCurrent = NULL;
            mylist->size--;
            break;
        }
        
        pPrev = pCurrent;
        pCurrent = pCurrent->next;
    }
}
//清空链表
void Clear_LinkList(LinkList list)
{
    if(NULL == list)
    {
        return;
    }
    struct LList* mylist = (struct LList*)list;
    
    //辅助指针变量
    struct LinkNode* pCurrent = mylist->header.next;
    
    while(pCurrent != NULL)
    {
        //先缓存下一个结点的地址
        struct LinkNode* pNext = pCurrent->next;
        //释放当前结点内存
        free(pCurrent);
        
        pCurrent = pNext;
    }
    mylist->header.next = NULL;
    //把size更新
    mylist->size = 0;
    
}
//大小
int Size_LinkList(LinkList list)
{
    if(NULL == list)
    {
        return -1;
    }
    struct LList* mylist = (struct LList*)list;
    
    return mylist->size;
}
//销毁链表
void Destroy_LinkList(LinkList list)
{
    if(NULL == list)
    {
        return;
    }
    
    //清空链表
    Clear_LinkList(list);
    free(list);
    list = NULL;
}

 练习3：单向链表（版本二）

内存模型图如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

struct LinkNode
{
    struct LinkNode* next;
};

struct Person
{
    struct LinkNode node;//给四个字节存地址
    char name[64];
    int age;
};

void test()
{
    struct Person p1 = {NULL, "aaa", 10};
    struct Person p2 = {NULL, "bbb", 20};
    struct Person p3 = {NULL, "ccc", 30};
    struct Person p4 = {NULL, "ddd", 40};
    struct Person p5 = {NULL, "eee", 50};
    
    struct LinkNode* pp1 = (struct LinkNode*)&p1;
    struct LinkNode* pp2 = (struct LinkNode*)&p2;
    struct LinkNode* pp3 = (struct LinkNode*)&p3;
    struct LinkNode* pp4 = (struct LinkNode*)&p4;
    struct LinkNode* pp5 = (struct LinkNode*)&p5;
    
    pp1->next = pp2;
    pp2->next = pp3;
    pp3->next = pp4;
    pp4->next = pp5;
    pp5->next = NULL;
    
    struct LinkNode* pCurrent = pp1;
    while(pCurrent != NULL)
    {
        struct Person* person = (struct Person*)pCurrent;
        printf("Name:%s Age:%d
", person->name, person->age);
        
        pCurrent = pCurrent->next;
    }
    
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

在学习c语言提高-数据结构总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。