单链表的增删改查实现

概述

链表：通过一组任意的存储单元来存储线性表的数据，这组存储单元可以是连续或不连续的，
每个节点包括

• 数据域（当前节点的数值）
• 指针域（存储下一个节点的位置）

各个节点通过指针域串起来，像一条链子，所以叫“链表”。
单链表：每个节点只有一个指向直接后继节点的指针，所以叫“单链表”

实现过程

注：本文均为带头结点的单链表

单链表结构体：

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

#define ARRMALLOCSIZE 5
#define FALSE         0
#define TRUE          1 

typedef struct listNode
{
    int data;                   //数据域
    struct listNode *next;      //指针域
}linkList;

头结点初始化：

void initLinkList(linkList *tempList)
{
    tempList->next = NULL;      //指针域制空
}

创建单链表有两种方法，头插法和尾插法，头插法的特点是：逆序存储的数据，而尾插法则是正序存储的

头插法创建单链表：

int headCreateLinkList(linkList *tempList)
{
    int temp;
    linkList *node;
    node = (linkList *)malloc(sizeof(linkList));
    //创建失败
    if(!node)
        return FALSE;

    scanf("%d", &temp);
    while(temp != -1)
    {
        node->data = temp;
        node->next = tempList->next;
        tempList->next = node;

        node = (linkList *)malloc(sizeof(linkList));
        //创建失败
        if(!node)
            return FALSE;
        scanf("%d", &temp);
    }

    free(node);
    return TRUE;
}

尾插法创建单链表：

int footCreateLinkList(linkList *tempList)
{
    int temp;
    linkList *node, *flag;                              //flag指针永远指向tempList尾部位置
    flag = tempList;
    node = (linkList *)malloc(sizeof(linkList));
    //创建失败
    if(!node)
        return FALSE;

    scanf("%d", &temp);
    while(temp != -1)
    {
        node->data = temp;
        node->next = flag->next;
        flag->next = node;
        flag = node;

        node = (linkList *)malloc(sizeof(linkList));
        //创建失败
        if(!node)
            return FALSE;
        scanf("%d", &temp);
    }
    free(node);
    return TRUE;
}

返回单前操作位置的前一个位置的指针：这样做可以省去好多代码，比如删除指定位置的数据，查找指定位置的数据，修改指定位置的数据

//返回dest-1位置开始的链表指针
linkList *searchLinkListDestBefore(linkList *tempList, int dest)
{
    linkList * p = tempList;
    int i = 0, linkListLength;

    linkListLength = getLinkListLength(tempList);

    //位置合法性判断
    if(dest < 0 || dest > linkListLength)
        return NULL;

    for(i = 0; i < dest; i++)
        p = p->next;
    return p;
}

数据添加（指定位置）：

//向链表的dest位置插入num
int insertLinkList(linkList *tempList, int dest, int num)
{
    linkList *p, *node;
    //调用上文说到的方法
    p = searchLinkListDestBefore(tempList, dest-1);                 //现在p指向dest-1节点
    if(!p)                                                          //dest-1位置不存在判断
        return FALSE;

    node = (linkList *)malloc(sizeof(linkList));
    if(!node)
        return FALSE;

    node->data = num;                                               //dest不存在或不存在不影响
    node->next = p->next;
    p->next = node;

    return TRUE;
}

数据修改（指定位置）：

//把链表dest位置的值改为num
int changeLinkList(linkList *tempList, int dest, int num)
{
    linkList *p = searchLinkListDestBefore(tempList, dest-1);       //现在p指向dest-1节点
    if(!p || !p->next)                                              //dest-1位置不存在判断
        return FALSE;

    p->next->data = num;

    return TRUE;
}

数据删除（指定位置）：

//删除链表中的第dest位置的值
int deleteLinkList(linkList *tempList, int dest)
{
    linkList *p = searchLinkListDestBefore(tempList, dest-1);       //现在p指向dest-1节点

    if(!p || !p->next)                                              //dest-1 或 dest位置不存在判断
        return FALSE;

    if(!p->next->next)                                              //dest存在，但为最后一个节点
        p->next = NULL;
    else                                                            //dest存在，为中间节点
        p->next = p->next->next;

    return TRUE;
}

说到查找，有两种查找方式，一种是按值查找，一种是按位置查找，如果是按值查找的话，有一点我们应该注意，查到的位置有可能有多个，构建一个结构体，用来存储这多个位置

按值查找的结果（结构体）：

typedef struct resultNode
{
    int *arr;           //该数组存储所有的结果
    int length;         //结果数组的长度
}resNode;

按值查找：

//[按值dest]查找,对应节点的位置存储在tempNode里--按值查找
int searchLinkListByValue(linkList *tempList, int num, resNode *tempNode)
{
    linkList *p = tempList->next;
    int j = 1;

    tempNode->length = 0;
    tempNode->arr = (int *)malloc(sizeof(int) * ARRMALLOCSIZE);
    //创建失败
    if(!tempNode->arr)
        return FALSE;
    //循环对链表进行遍历
    while(p)
    {
        //空间不足开辟空间
        if((!(tempNode->length % 5)) && tempNode->length != 0)
        {
            tempNode->arr = (int *)realloc(tempNode->arr,  sizeof(int) * (tempNode->length + 1) * ARRMALLOCSIZE);
            //创建失败
            if(!tempNode->arr)
                return FALSE;
        }
        if(p->data == num)
        {
            tempNode->arr[tempNode->length++] = j;
        }
        p = p->next;
        j++;
    }
    return TRUE;
}

按位置查找：

//查找dest位置的值--按位置查找
int searchLinkListByIndex(linkList *tempList, int dest)
{
    linkList *p = searchLinkListDestBefore(tempList, dest-1);       //现在p指向dest-1节点

    if(!p || !p->next)                                              //dest-1 或 dest位置不存在判断
        return FALSE;

    return p->next->data;
}

获取单链表的表长：

//获取表长(记得包括表头)
int getLinkListLength(linkList *tempList)
{
    int length = 0;
    linkList *p = tempList;
    while(p)
    {
        length ++;
        p = p->next;
    }
    return length;
}

单链表输出：

//输出
void printfLinkList(linkList *tempList)
{
    linkList *p = tempList->next;
    while(p)
    {
        printf("%-4d", p->data);
        p = p->next;
    }   
}

单链表是指针，结构体的一个很好的学习点，我做了个简单的实现上面一些列的功能的demo，需要学习的同学可以运行看看。

实例实现

示例图：

实例代码可以点击Demo查看

更多数据结构与算法实例代码查看（下载）地址：https://github.com/52UUD/Algorithm-Design