数据结构-单向链表的实现（c语言）

链表的定义：

链表是由一系列的结点组成的，每个结点包含两个域，分别是指针域（*next）与数据域（data）。

单向链表的实现

//.h文件

#ifnde DXLB_H
#define DXLB_H

//定义结点结构体
typedef struct LINKNODE
{
    struct LINKNODE* next;    //指向下一个结点的指针
    int data;                //数据域
}LinkNode;

//定义链表结构体
typedef struct LINKLIST
{
    LinkNode* head;        //定义链表的头结点
    int size;              //记录链表中的结点数
}LinkList;


//定义打印函数的函数指针
typedef void(*PRINTLINKNODE)(void*);

//初始化链表
LinkList* Init_LinkList();

//指定位置插入
void Insert_LinkList(LinkList* list,int pos,void* node);

//根据位置删除
void RemoveByPos_LinkList(LinkList* list,int pos);

//查找
int Find_LinkList(LinkList* list,void* data);

//打印
void Print_LinkList(LinkList* list,PRINTLINKNODE print);

//获取链表的长度
int Size_LinkList(LinkList* list);

//返回第一个结点的数据
void* Front_LinkList(LinkList* list);

//释放链表内存
void FreeSpace_LinkList(LinkList* list);

#endif

//.c 文件

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

//初始化链表
LinkList* Init_LinkList()
{
    //申请内存空间
    LinkList* list = (LinkList*)malloc(sizeof(LinkList));

    //初始化
    list->head = (LinkNode*)malloc(sizeof(LinkNode));

    head->next = NULL;
    //头结点的数据域不保存数据
    head->data = NULL;

    //将链表的结点个数置为0
    list->size = 0;

    return list;
}

//指定位置插入
void Insert_LinkList(LinkList* list,int pos,void* node)
{
    if(list = NULL)    return;

    if(node == NULL)    return;

    if(pos < 0 || pos > list->size)    pos = list->size;

    //申请一个新的结点来存放所要存储的数据
    LinkNode* newnode = (LinkNode*)malloc(sizeof(LinkNode));
    newnode->data = node;
    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* pNext = pCurrent->next;
    pCurrent->next = pNext->next;
    
    //释放需要删除结点的内存
    free(pNext);

    list->size--;
}

//查找
int Find_LinkList(LinkList* list,void* data)
{
    if(list == NULL)    return -1;
    if(data == NULL)    return -1;

    //需要移动指针，设置一个临时指针变量
    LinkNode* pCurrent = list->head->next;
    
    int pos = -1;
    for(int i = 0; i < list->size; i++)
    {
        if(pCurrent->data == &data)
        {
            pos = i;
            break;
        }
        pCurrent = pCurrent->next;
    }
        
    return pos;
}

//打印
void Print_LinkList(LinkList* list,PRINTLINKNODE print)
{
    if(list == NULL)    return;

    LinkNode* pCurrent = list->head->next;
    for(int i = 0; i < list->size; i++)
    {
        print(pCurrent);
        pCurrent = pCurrent->next;
    }
}

void MyPrint(void* data)
{
    LinkNode* p = (LinkNode*)data;
    printf("%d ",p->data);
}

//获取链表的长度
int Size_LinkList(LinkList* list)
{
    if(list == NULL)    return -1;

    return list->size;
}

//返回第一个结点的数据
void* Front_LinkList(LinkList* list)
{
    if(list == NULL)    return NULL;

    return list->head->next;
}

//释放链表内存
void FreeSpace_LinkList(LinkList* list)
{
    if(list == NULL)    return;

    if(list != NULL)
    {
        LinkNode* pCurrent = list->head;
        while(pCurrent != NULL)
        {
            LinkNode* pNext = pCurrent->next;
            free(pCurrent);
            pCurrent = pNext;
        }

        free(list);
        list->size = 0;
    }
}

int main()
{
    return 0;
}

函数指针与指针函数：

        函数指针：其本质是一个指针变量，该指针指向这个函数。

        定义一个函数指针：int (*fun)(int x,int y);       返回值类型 (*函数名)(参数1,参数2);

        指针函数：返回指针的函数，  int* fun(int x,int y);

指针数组与数组指针：

        指针数组：指针的数组，本质是一个数组；指针数组是指多个指针变量存储在数组当中。

                           例如：int* arr[3];             这是存放了三个 int* 类型的指针数组

        数组指针：指向数组的指针，本质是一个指针变量。

                           例如：int (*a)[3];        这里指  指针变量 a  指向存放三个int 类型数据的数组

指针常量与常量指针：

        指针常量：

                int* const p;

                p 指向的地址不能更改

                但是可以通过 p 改变所指向的地址的变量的值，也就是可以通过指针赋值  *p = 100

        常量指针：

                const int* p;

                p的指向可以更改

                但是不能通过 p 来修改所指向的变量的值，也就是不能通过指针赋值