[C语言] 单向链表的构建以及翻转算法_图文详解（附双向链表构建代码）

　　[C语言]单向链表的构建以及翻转算法

 

一、基本概念

　　单向链表的链接方向是单向的，其中每个结点都有指针成员变量指向链表中的下一个结点，访问链表时要从头节点（带头节点的链表）或存储首个数据的节点（不带头节点的链表）开始顺序查询。本文将以带头结点的非循环单向链表为例，其链表模型如下：

　　

　　其中head为头结点（不存储数据）、data节点存储数据、pNext存储下一节点的地址。

　　当单项链表不包含头结点时，链表首个节点便是所存储的第一个数据的节点；当单项链表是循环链表时，链表中存储最后一个数据的节点中pNext指向的不是NULL而是链表首部。

 

 

二、构建算法

1、单项链表节点结构体的定义

　　链表节点包含两个部分：①节点所存储的数据。②节点所存储的下一节点地址。

　　其单个节点模型如下：

　　

typedef int T;

typedef struct SLNode
{
    //节点保存的数据
    T data;
    //下一个节点的位置
    struct SLNode* next;
}SLNode,SLLink;

typedef int T;

typedef struct DLNode
{
    //节点保存的数据
    T data;
    struct DLNode* prev;
    struct DLNode* next;
}DLNode;

typedef struct DLLink
{
    struct DLNode* head;
    struct DLNode* tail;
}DLLink;

　　tips：①用 typedef 定义数据类型能有效提高代码的实用性，②一般用 NODE* 定义节点， LINK* 定义链表，便以区分。

 

2、 单项链表的始终

2.1 单项链表的创建

　　单项链表的创建主要包含三个部分：①为申请头结点内存，②使pNext指向下一节点（NULL）。③返回头地址。

　　其头节点模型如下：

　　

//创建一个链表
SLLink* creat_SLLink()
{
    //创建一个节点，表示头节点，该节点并不保存数据
    SLLink* head = (SLLink*)malloc(sizeof(SLNode));
    //让头节点的next置NULL，表示链表为空
    head->next = NULL;
    //返回头的地址
    return head;
}

//创建一个节点
DLNode* creat_DLNode()
{
    //创建一个节点，该节点并不保存数据且前后置空
    DLNode* node = (DLNode*)malloc(sizeof(DLNode));
    node->prev = NULL;
    node->next = NULL;
    //返回节点的地址
    return node;
}

//创建一个链表
DLLink* creat_DLLink()
{
    //创建链表与头尾节点，头尾节点并不保存数据
    DLLink* link = (DLLink*)malloc(sizeof(DLLink));
    link->head = creat_DLNode();
    link->tail = creat_DLNode();
    //让头尾节点的互指
    link->head->next = link->tail;
    link->head->prev = NULL;
    link->tail->next = NULL;
    link->tail->prev = link->head;
    //返回链表地址
    return link;
}

 

2.2 单项链表的清空与销毁

　　单项链表的清空与销毁主要包含两个步骤：①依次释放存储数据的节点内存。②释放头结点的内存，变量置空。

//清空链表
void clear_SLLink(SLLink* link)
{
    SLNode* node = link->next;
    while(node != NULL)
    {
        SLNode* tmp = node;
        node = node->next;
        free(tmp);
    }
    link->next = NULL;
}

//销毁链表
void destroy_SLLink(SLLink* link)
{
    clear_SLLink(link);
    free(link);
    link = NULL;
}

//清空链表
void clear_DLLink(DLLink* link)
{
    DLNode* node = link->head->next;
    while(node != link->tail)
    {
        node = node->next;
        free(node->prev);
    }
    //让头尾节点的互指
    link->head->next = link->tail;
    link->tail->prev = link->head;
}

//销毁链表
void destroy_DLLink(DLLink* link)
{
    clear_DLLink(link);
    free(link);
    link = NULL;
}

 

 

3、 单项链表的判定

3.1 单项判定链表是否为空

//判断链表是否为空
bool emtpy_SLLink(SLLink* link)
{
    return !link->next;
}

//判断链表是否为空
bool emtpy_DLLink(DLLink* link)
{
    return link->tail->next == link->tail;
}

 

4、单向链表的查询

4.1 获取单向链表中数据的个数

　　获取单向链表中数据的个数主要包含三个步骤：①创建变量存储数据个数、创建node记录头节点的下一节位置点用于遍历链表。②循环遍历，当当前节点的pNext指向NULL时代表已达链表末尾，结束循环。③返回数据个数。

//获得链表里数据的个数
size_t size_SLLink(SLLink* link)
{    
    size_t i = 0;
    //用node记录头节点的下一个位置
    SLNode* node = link->next;
    //只要node不为NULL,表示该节点存在
    while(node != NULL)
    {
        //让node继续指向下一个节点
        node = node->next;
        i++;
    }
    return i;
}

//获得链表里元素的个数
size_t size_DLLink(DLLink* link)
{    
    size_t i = 0;
    //用node记录头节点的下一个位置
    DLNode* node = link->head->next;
    //只要node不为NULL,表示该节点存在
    while(node != link->tail)
    {
        //让node继续指向下一个节点
        node = node->next;
        i++;
    }
    return i;
}

 

4.2 获取指定下标节点的前一个节点

　　获取指定下标节点的前一个节点主要包含三个步骤：①创建node记录头节点位置用于遍历链表。②循环遍历，当当前节点的pNext指向NULL时代表已达链表末尾，结束循环。③返回指定下标的前一个节点。

//返回下标为index的前一个节点
SLNode* getNode_SLLink(SLLink* link, int index)
{
    SLNode* node = link;
    //如果index=0 其前一个节点就为link ,并不会进入下面循环
    for(int i=0; node != NULL && i<index; i++)
    {
        node = node->next;
    }
    return node;
}

//返回下标为index的个节点
DLNode* getNode_DLLink(DLLink* link, int index)
{
    DLNode* node = link->head->next;
    //如果index=0 其前一个节点就为DLLink ,并不会进入下面循环
    for(int i=0; node != link->tail && i<index; i++)
    {
        node = node->next;
    }
    return node;
}

 

4.3 查找指定数据的下标（第一个）

　　查找指定数据的下标主要包含主要包含三个步骤：①创建node记录头节点的下一节位置点用于遍历链表。②循环遍历，当当前节点的pNext指向NULL时代表已达链表末尾，结束循环。③成功返回数据下标，失败则返回 -1 。

//查找数据value的下标
int indexOf_SLLink(SLLink* link, T value)
{
    SLNode* node = link->next;
    for(int i = 0; node != NULL; i++)
    {
        if(node->data == value)
            return i;
        node = node->next;
    }
    return -1;
}

//查找元素value的下标
int indexOf_DLLink(DLLink* link, T value)
{
    DLNode* node = link->head->next;
    for(int i = 0; node != link->tail; i++)
    {
        if(node->data == value)
        {
            return i;
        }
        node = node->next;
    }
    return -1;
}

 

4.4 遍历显示链表

　　遍历显示链表主要包含主要包含三个步骤：①创建node记录头节点的下一节位置点用于遍历链表。②循环遍历，顺序输出每一个节点中储存的数据，当当前节点的pNext指向NULL时代表已达链表末尾，结束循环。

//遍历链表
void travel_SLLink(SLLink* link)
{
    SLNode* node = link->next;
    while(node != NULL)
    {
        printf("%d ",node->data);
        node = node->next;
    }
    puts("");
}

//顺序遍历链表
void sequenceTravel_DLLink(DLLink* link)
{
    DLNode* node = link->head->next;
    while(node != link->tail)
    {
        printf("%d ",node->data);
        node = node->next;
    }
    puts("");
}

 

5、 单项链表的节点插入

5.1 将一个节点插入指定下标

　　将一个节点插入指定下标（index）主要包含三个步骤：①获取指定下标节点的上一个节点位置。②创建node节点存储需要插入的数据。③让插入节点的下一个节点指向index前一个节点的后节点，让index的前节点的下一个节点指向当前插入的节点。

　　其演示模型如下：

//插入一个元素到指定位置 index取值范围[0,size_SLLink(SLLink* link)]
bool insert_SLLink(SLLink* link, int index, T value)
{
    if(index < 0 || index > size_SLLink(link)) 
        return false;
    //得到下标为index位置的前一个节点
    SLNode* prevSLNode = getNode_SLLink(link, index);
    //申请内存，用于保存需要插入的数据
    SLNode* node = (SLNode*)malloc(sizeof(SLNode));
    node->data = value;
    //插入节点的下一个节点指向index前一个节点的后节点
    node->next = prevSLNode->next;
    //让index的前节点的下一个节点指向当前插入的节点
    prevSLNode->next = node;
    return true;
}
//插入一个元素到链表末尾
bool insertBack_SLLink(SLLink* link, T value)
{
    return insert_SLLink(link, size_SLLink(link), value);
}
//插入一个元素到链表首部
bool insertFront_SLLink(SLLink* link, T value)
{
    return insert_SLLink(link, 0, value);
}

//插入一个元素到指定位置 index取值范围[0,size_DLLink(DLLink* link)
bool insert_DLLink(DLLink* link, int index, T value)
{
    if(index < 0 || index > size_DLLink(link)) 
    {
        return false;
    }
    //得到下标为index节点
    DLNode* currNode = getNode_DLLink(link, index);
    //申请内存，用于保存需要插入的数据
    DLNode* insertNode = (DLNode*)malloc(sizeof(DLNode));
    insertNode->data = value;
    //插入节点的下一个节点指向index当前节点
    insertNode->next = currNode;
    //插入节点的前一个节点指向index节点的前一个节点
    insertNode->prev = currNode->prev;
    //让index当前的前节点的下一个节点指向插入的节点
    currNode->prev->next = insertNode;
    //让index当前节点的上一个节点指向插入的节点
    currNode->prev = insertNode;
    return true;
}
//插入一个元素到链表末尾
bool insertBack_DLLink(DLLink* link, T value)
{
    return insert_DLLink(link, size_DLLink(link)-1, value);
}
//插入一个元素到链表首部
bool insertFront_DLLink(DLLink* link, T value)
{
    return insert_DLLink(link, 0, value);
}

 

5.2 将一个节点替换指定下标节点

　　将一个节点替换指定下标（index）节点只包含一个步骤：创建node节点获取指定下标节点的位置并存储需要插入的数据。

//更新链表下标为index的节点的值
bool update_SLink(SLLink* link, int index, T value)
{
    if(index < 0 || index > size_link(link)-1)
        return false;
    SLNode* node = getNode_SLLink(link, index+1);
    node->data = value;
    return true;
}

//更新链表下标为index的节点的值
bool update_DLLink(DLLink* link, int index, T value)
{
    if(index < 0 || index > size_DLLink(link)-1)
    {
        return false;
    }
    DLNode* node = getNode_DLLink(link, index);
    node->data = value;
    return true;
}

 

6、单项链表的数据删除

6.1 将一个指定下标的节点删除

　　将一个指定下标的节点（index）删除主要包含四个步骤：①获取指定下标节点的上一个节点位置。②保存要删除的节点，用于释放内存。③让要删除节点的前一个节点指向要删除节点的后一个节点。④释放内存。

　　其演示模型如下：

//删除指定下标的元素
bool delete_SLLink(SLLink* link, int index)
{
    if(index < 0 || index > size_SLLink(link)-1) 
        return false;
    //获得需要删除节点的前一个节点
    SLNode* prevSLNode = getNode_SLLink(link, index);
    //保存要删除的节点，用于释放内存
    SLNode* node  = prevSLNode->next;
    //让要删除节点的前一个节点指向要删除节点的后一个节点
    prevSLNode->next = prevSLNode->next->next;
    free(node);
    return true;
}

//删除指定下标的元素
bool delete_DLLink(DLLink* link, int index)
{
    if(index < 0 || index > size_DLLink(link)-1) 
    {
        return false;
    }
    //获得需要删除节点
    DLNode* currNode = getNode_DLLink(link, index+1);
    //保存要删除的节点，用于释放内存
    DLNode* tmp = currNode;
    currNode->prev->next = currNode->next;
    currNode->next->prev = currNode->prev;
    free(tmp);
    return true;
}

 

6.2 删除链表中所有包含指定数据的节点

　　删除链表中所有包含指定数据（value）的节点主要包含三个步骤：①设置标志变量（flag）表示该链表的数据是否发生变化。②循环遍历，顺序删除每一个包含指定数据的节点并将标志变量置位置为1，当当前节点的pNext指向NULL时代表已达链表末尾，结束循环。③返回标志变量。

//删除元素为value的所有节点，返回值表示该链表的数据是否发生变化
bool deleteDatas_SLLink(SLLink* link, T value)
{
    //作为是否删除成功的一个标志
    bool flag = false;
    SLNode* prevNode = link;
    SLNode* currNode = link->next;
    while(currNode != NULL)
    {
        if(currNode->data == value)
        {
            SLNode* tmp = currNode;
            prevNode->next = currNode->next;
            currNode = currNode->next;
            free(tmp);
            flag = true;
        }
        else
        {
            prevNode = prevNode->next;
            currNode = currNode->next;
        }
    }
    return flag;
}

//删除元素为value的第一个元素
bool deleteData_SLLink(SLLink* link, T value)
{
    SLNode* prevNode = link;
    SLNode* currNode = link->next;
    while(currNode != NULL)
    {
        if(currNode->data == value)
        {
            SLNode* tmp = currNode;
            prevNode->next = currNode->next;
            currNode = currNode->next;
            free(tmp);
            return true;
        }
        else
        {
            prevNode = prevNode->next;
            currNode = currNode->next;
        }
    }
    return false;
}

//删除元素为value的所有节点，返回值表示该链表的数据是否发生变化
bool deleteDatas_DLLink(DLLink* link, T value)
{
    //作为是否删除成功的一个标志
    bool flag = false;
    DLNode* node = link->head->next;
    while(node != link->tail)
    {
        if(node->data == value)
        {
            DLNode* tmp = node;
            node->prev->next = node->next;
            node->next->prev = node->prev;
            node = node->next;
            free(tmp);
            flag = true;
        }
        else
        {
            node = node->next;
        }
    }
    return flag;
}

//删除元素为value的第一个元素
bool deleteData_DLLink(DLLink* link, T value)
{
    DLNode* node = link->head->next;
    while(node != link->tail)
    {
        if(node->data == value)
        {
            DLNode* tmp = node;
            node->prev->next = node->next;
            node->next->prev = node->prev;
            free(tmp);
            return true;
        }
        else
        {
            node = node->next;
        }
    }
    return false;
}

 

 

三、拓展应用

1、单项链表的整体翻转

　　单向链表的整体翻转具体步骤见“代码注释”，其演示模型如下（建议先了解代码）：

　　0：记录前一个节点与当前节点

　　   

　　1.1：先记录当前节点的后一个节点

 

　　

　　2.1：让当前节点(node)的下一个节点(node->next)指向前一个节点(prev)

 

　　

　　3.1：让前一个节点指向当前节点、当前节点指向原先记录的下一个节点

 

　　

　　1.2：先记录当前节点的后一个节点

 

　　

　　2.2：让当前节点(node)的下一个节点(node->next)指向前一个节点(prev)

 

　　

　　3.2 : 让前一个节点指向当前节点、当前节点指向原先记录的下一个节点

 

　　

　　4 : 让原来的第一个元素变为尾元素，尾元素的下一个置NULL

 

　　  

　　5 : 让链表的头节点指向原来的尾元素

 

　　  

//链表逆序
void reverse(Link link)
{
    if(link == NULL || link->next == NULL)
        return;
    //0、记录前一个节点与当前节点
    Node* prevNode = link->next;
    Node* node = prevNode->next;//NULL
    //只要当前节点存在
    while(node != NULL)
    {
        //1、先记录当前节点的后一个节点
        Node* nextNode = node->next;
        //2、让当前节点(node)的下一个节点(node->next)指向(=)前一个节点(prev)
        node->next = prevNode;
        //3、让前一个节点指向当前节点、当前节点指向原先记录的下一个节点
        prevNode = node;
        node = nextNode;
    }
    //4、让原来的第一个元素变为尾元素，尾元素的下一个置NULL
    link->next->next = NULL;
    //5、让链表的头节点指向原来的尾元素
    link->next = prevNode;
}

 

2、链表中每k个节点进行翻转，若最后一组节点数量不足k个，则按实际个数翻转。

　　具体流程参考“单项链表的整体翻转”。

//链表中每k个节点进行翻转，若最后一组节点数量不足k个，则按实际个数翻转。
void reverseByNum(Node* prev,Node* node,int num)
{
    if(node == NULL)
        return;
    Node* prevNode = node;
    Node* curNode = node->next;
    int count = 1;
    while(curNode != NULL)
    {
        Node* nextNode = curNode->next;
        curNode->next = prevNode;
        prevNode = curNode;
        curNode = nextNode;
        count++;
        if(count == num)
        {
            Node* tmp = prev->next;
            prev->next->next = curNode;
            prev->next = prevNode;
            reverseByNum(tmp,curNode,num);
            return;
        }
    }
    prev->next->next = curNode;
    prev->next = prevNode;
}

 

---

 

　　以上是个人对链表的一些认识及理解，若有错误欢迎各位指出。