数据结构：有头单向不循环链表的16种操作，代码详细

最新推荐文章于 2023-03-22 09:52:43 发布
最新推荐文章于 2023-03-22 09:52:43 发布
阅读量217 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57535837/article/details/126331518
版权

一、概念

逻辑结构：线性结构

存储结构：链式存储

链表又分为有头节点的和无头节点的，区别就是头结点是否存储数据。

又分为单向链表和双向链表，还有循环链表。

有头单向不循环链表的示意图

 

二、 链表相关操作

1. 创建链表 

2. 清空链表 

3. 销毁链表 

4. 头插法 

5. 尾插法 

6. 任意位置插入法 

7. 头删法 

8. 尾删法 

9. 任意位置删除法 

10. 查询链表中是否有想要的数据(在链表中获取指定位置的数据) 

11. 按照位置修改链表中的数据 

12. 按照值修改链表中的数据 

13. 两个链表合并 

14. 链表的排序

15. 链表的翻转

16. 遍历链表的节点----学习阶段看现象用的 

二、代码实现 

2.1 link_list.h

#ifndef __LINK_LIST_H__
#define __LINK_LIST_H__
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct __Node{
    int data;
    struct __Node *next;
}node_t;

//1.创建新节点的函数
int create_node(node_t **p, int in_data);
//2.头插法
int insert_data_by_head(node_t *phead, int in_data);
//3.遍历链表
int print_link_list(node_t *phead);
//4.尾插法插入数据
int insert_data_by_tail(node_t *phead, int in_data);
//5.任意位置插入法
int insert_data_by_pos(node_t *phead, int in_data, int pos);
//6.头删法
int del_from_list_by_head(node_t *phead);
//7.尾删法
int del_from_list_by_tail(node_t *phead);
//8.任意位置删除法
int del_from_list_by_pos(node_t *phead, int pos);
//9.根据位置从链表中获取数据
int get_data_from_list(node_t *phead, int pos, int *num);
//10.根据位置修改链表中的数据
int update_list_by_pos(node_t *phead, int pos, int new_data);
//11.根据值修改链表中的数据
int update_list_by_value(node_t *phead, int old_value, int new_value);
//12.清空链表--释放所有数据节点 保留头结点
int clean_list(node_t *phead);
//13.销毁链表
int destroy_list(node_t **p);
//14.两个链表合并
int merge_two_list(node_t *phead1, node_t **phead2);
//15.链表的翻转
int overturn_list(node_t *phead);
//16.链表的排序 -- 以升序为例
int sort_list(node_t *phead);

#endif

2.2 link_stack.c

#include "link_list.h"

//1.创建新节点的函数
int create_node(node_t **phead, int in_data){
    if(NULL == phead){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    *phead = (node_t *)malloc(sizeof(node_t));
    if(*phead == NULL){
        printf("内存分配失败\n");
        exit(-1);
    }
    (*phead)->data = in_data;
    (*phead)->next = NULL;
    return 0;
}
//2.头插法
int insert_data_by_head(node_t *phead, int in_data){
    if(NULL == phead){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    //创建新节点
    node_t *pnew = NULL;
    create_node(&pnew, in_data);
    //执行头插操作
    pnew->next = phead->next;
    phead->next = pnew;
}
//3.遍历链表
int print_link_list(node_t *phead){
    if(NULL == phead){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    node_t *ptemp = phead;
    while(ptemp->next != NULL){ 
        ptemp = ptemp->next;
        printf("%d  ", ptemp->data);    
    }
    printf("\n");
    return 0;
}
//4.尾插法插入数据
int insert_data_by_tail(node_t *phead, int in_data){
    if(NULL == phead){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    //创建新节点
    node_t *pnew =  NULL;
    create_node(&pnew,in_data);
    //执行尾插操作
    node_t *ptemp = phead;
    //遍历链表找到链表的尾节点
    while(ptemp->next != NULL){
        ptemp = ptemp->next;
    }
    //让尾节点的指针域指向新节点
    ptemp->next = pnew;
    return 0;
}
//5.任意位置插入法
int insert_data_by_pos(node_t *phead, int in_data, int pos){
    if(NULL == phead){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    if(pos <= 0){
        printf("插入位置不合理，请检查\n");
        return -1;
    }
    //找到待插入位置的前一节点
    node_t *ptemp = phead;
    int i = 0;
    for (i = 0; i < pos-1; i++){
        ptemp = ptemp->next;
        if(NULL == ptemp->next){
            break;
        }
    }
    //如果是由于break导致的循环结束 说明位置不合理
    if(i < pos-1){
        printf("插入位置不合理，请检查\n");
        return -1;
    }
    //位置合理 创建新节点
    node_t *pnew = phead;
    create_node(&pnew, in_data);
    //将新节点插入
    pnew->next = ptemp->next;
    ptemp->next = pnew;
    return 0;
}
//6.头删法
int del_from_list_by_head(node_t *phead){
    if(NULL == phead){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    //判断是否有数据用来删除
    if(NULL == phead->next){
        printf("链表中没有数据 头删失败\n");
        return -1;
    }
    //定义一个指针 pdel 保存 第一个数据节点的地址
    node_t *pdel = phead->next;
    phead->next = pdel->next;
    free(pdel);
    pdel = NULL;
    return 0;
}
//7.尾删法
int del_from_list_by_tail(node_t *phead){
    if(NULL == phead){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    //判断是否有数据用来删除
    if(NULL == phead->next){
        printf("链表中没有数据 头删失败\n");
        return -1;
    }
    //找到最后一个节点的前一节点
    node_t *ptemp = phead;
    while(ptemp->next->next != NULL){
        ptemp = ptemp->next;
    }
    free(ptemp->next);
    ptemp->next = NULL; 
    return 0;
}
//8.任意位置删除法
int del_from_list_by_pos(node_t *phead, int pos){
    if(NULL == phead){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    if(pos <= 0){
        printf("删除位置不合理，请检查\n");
        return -1; 
    }
    node_t *ptemp = phead;
    int i = 0;
    //找到待删除位置的前一节点
    for(i = 0; i < pos-1; i++){
        ptemp = ptemp->next;
        if(NULL == ptemp->next){
            break;
        }
    } 
    if(i < pos-1){
        printf("删除位置不合理，请检查\n");
        return -1; 
    }  
    //执行删除操作
    node_t *pdel = ptemp->next;
    ptemp->next = pdel->next;
    free(pdel);
    pdel = NULL;
    return 0;
}
//9.根据位置从链表中获取数据
int get_data_from_list(node_t *phead, int pos, int *num){
    if(NULL == phead){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    if(pos <= 0){
        printf("删除位置不合理，请检查\n");
        return -1; 
    }
    node_t *ptemp = phead;
    int i = 0;
    //找到要获取数据的节点  并做位置合理性的检查
    for(i = 0; i < pos; i++){
        ptemp = ptemp->next;
        if(NULL == ptemp){
            printf("获取数据的位置不合理，请检查\n");
            return -1;
        }
    } 
    //如果运行到这儿了 说明位置合理
    *num = ptemp->data;
    printf("该位置查找的数据为：%d\n", *num);
    return 0;
}
//10.根据位置修改链表中的数据
int update_list_by_pos(node_t *phead, int pos, int new_data){
    if(NULL == phead){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    if(pos <= 0){
        printf("删除位置不合理，请检查\n");
        return -1; 
    }
    node_t *ptemp = phead;
    int i = 0;
    //找到要修改数据的节点  并做位置合理性的检查
    for(int i = 0; i < pos; i++){
        ptemp = ptemp->next;
        if(NULL == ptemp){
            printf("修改数据的位置不合理，请检查\n");
            return -1; 
        }
    } 
    //如果运行到这儿了 说明位置合理
    ptemp->data = new_data;
    return 0;
}
//11.根据值修改链表中的数据
int update_list_by_value(node_t *phead, int old_value, int new_value){
    if(NULL == phead){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    //遍历链表
    node_t *ptemp = phead->next;
    while(ptemp->data != old_value){
        ptemp = ptemp->next;
        if(NULL == ptemp){
            printf("链表中不存在该值，请检查\n");
            return -1;  
        }
    }
    ptemp->data = new_value;
    return 0;
}
//12.清空链表--释放所有数据节点 保留头结点
int clean_list(node_t *phead){
    if(NULL == phead){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    //循环头删所有数据节点
    node_t *pdel = NULL;
    while(phead->next != NULL){
        pdel = phead->next;
        phead->next = pdel->next;             
        free(pdel);
    }
    pdel == NULL;
    return 0;
}
//13.销毁链表
int destroy_list(node_t **phead){
    if(NULL == phead){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    //防止先调用销毁没调用清空导致的内存泄漏
    //可以在释放头结点之前  先调用一下清空的函数
    clean_list(*phead);
    free(*phead);
    *phead = NULL;
    return 0;
}
//14.两个链表合并
int merge_two_list(node_t *phead1, node_t **phead2){
    if(NULL == phead1 || NULL == phead2 || NULL == *phead2){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    //先找到第一个链表的最后一个节点
    node_t *ptemp = phead1;
    while(ptemp->next != NULL){
        ptemp = ptemp->next;
    }
    //让第一个链表的最后一个节点的指针域指向第二个链表的第一个数据节点
    ptemp->next = (*phead2)->next;
    //释放第二个链表的 头结点
    free(*phead2);
    *phead2 = NULL;
    return 0;
}
//15.链表的翻转
int overturn_list(node_t *phead){
    if(NULL == phead){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    if(phead->next == NULL){
        printf("链表为空，无需翻转\n");
        return -1;
    }
    if(phead->next->next == NULL){
        printf("链表只有一个数据节点 无需翻转\n");
        return -1;
    }
    node_t *p = phead->next;
    node_t *q = p->next;
    p->next = NULL;
    while(q != NULL){
        p = q->next;
        q->next = phead->next;
        phead->next = q;
        q = p;
    }
    printf("翻转完成\n");
    return 0;
}

//16.链表的排序 -- 以升序为例
int sort_list(node_t *phead){
    if(NULL == phead){
        printf("入参为NULL, 请检查\n");
        return -1;
    }
    if(phead->next == NULL){
        printf("链表为空，无需排序\n");
        return -1;
    }
    if(phead->next->next == NULL){
        printf("链表只有一个数据节点 无需排序\n");
        return -1;
    }
    int temp = 0;
    node_t *p = phead->next;
    node_t *q = p->next;  
    while(p->next != NULL){
        while(q != NULL){
            if(p->data > q->data){
                //交换数据域
                temp = q->data;
                q->data = p->data;
                p->data = temp;
            }
            q = q->next;
        }
        p = p->next;
        q = p->next;
    }
    printf("升序排序完成\n");
    return 0;
}

2.3  main.c

#include "link_list.h"
                 
int main(int argc, const char *argv[])
{
    node_t *phead = NULL;
    //1.创建头节点
    create_node(&phead,-1);
    //2.头插法
    insert_data_by_head(phead, 20);
    insert_data_by_head(phead, 10);
    insert_data_by_head(phead, 30);
    //4.尾插法插入数据
    insert_data_by_tail(phead, 50);
    //3.遍历链表
    print_link_list(phead);

    //5.任意位置插入法
    insert_data_by_pos(phead, 40, 3);
    insert_data_by_pos(phead, 60, 2);
    //3.遍历链表
    print_link_list(phead);

    //6.头删法
    del_from_list_by_head(phead);
    //3.遍历链表
    print_link_list(phead);

    //7.尾删法
    del_from_list_by_tail(phead);
    //3.遍历链表
    print_link_list(phead);

    //8.任意位置删除法
    del_from_list_by_pos(phead, 2);
    //3.遍历链表
    print_link_list(phead);

    int num = 0;
    //9.根据位置从链表中获取数据
    get_data_from_list(phead, 2, &num);

    //10.根据位置修改链表中的数据
    update_list_by_pos(phead, 1, 70);
    //3.遍历链表
    print_link_list(phead);

    //11.根据值修改链表中的数据
    update_list_by_value(phead, 40, 80);
    //3.遍历链表
    print_link_list(phead);

    node_t *phead2 = NULL;
    //1.创建头节点
    create_node(&phead2,-1);
    //2.头插法
    insert_data_by_head(phead2, 25);
    insert_data_by_head(phead2, 15);
    insert_data_by_head(phead2, 35);
    //3.遍历链表
    print_link_list(phead2);

    //14.两个链表合并
    merge_two_list(phead, &phead2);
    //3.遍历链表
    print_link_list(phead);

    //15.链表的翻转
    overturn_list(phead);
    //3.遍历链表
    print_link_list(phead);

    //16.链表的排序 -- 以升序为例
    sort_list(phead);
    //3.遍历链表
    print_link_list(phead);

    //12.清空链表--释放所有数据节点 保留头结点
    clean_list(phead);
    //13.销毁链表
    destroy_list(&phead);
    return 0;
}

四、代码运行效果 

码猫Mrr
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构---不带头结点的单项非循环链表
weixin_43219708的博客
03-03 315
如果对元素进行大量的任意位置添加或删除，在顺序表里就要移动很多的元素，（底层空间是连续的）效率很低，所以可以利用链表这个结构 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的链接次序实现的 找到第一个节点，就可以通过链式结构找到下一个节点 链表： 1.单链表（从前往后）、双链表（） 2.带头（把第一个节点保存起来、不带头（） 3.循环、非循环 ...
数据结构：单向循环链表源码
07-04
单向循环链表是计算机科学中一种基本的数据结构，它在数据存储和处理中起着重要作用。本资源提供了单向循环链表的源码实现，旨在帮助读者更好地理解和掌握这一概念。下面，我们将深入探讨单向循环链表的定义、特性、...
数据结构(带头结点的单向非循环链表的相关操作)
库蒂尼奥的博客
07-23 327
链表的概念：物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链实现。 今天，我们就谈谈单向非循环链表（包括带头结点和不带头结点） 1.单向非循环链表结构定义以及初始化 //结构定义 typedef int Datatype; typedef struct ListNode { Datatype Data; //数据域 struct ListNode *Next; //指针域 }ListNode,*List; //初始化 //1.不带头结点 void Lis
C语言单向不循环链表
weixin_48984572的博客
07-30 341
链表的两种结构 物理结构和逻辑结构 物理 存储单元 上非连续、非顺序的 存储结构， 逻辑上是连续的，他们之间用指针连续起来 链表中每一个元素称为节点，由一系列的节点组成
链表之单向有头不循环链表
ffsiwei的博客
06-04 379
链表是一种链式存储线性表，用一组地址任意的存储单元存放数据表的数据元素，称为存储单元的一个节点 节点的结构体定义为： typedef struct ListNode { struct ListNode* pNext; TypeDate data; }ListNode; 下面就是一些构造链表的一些 函数，包括删除，插入，销毁等： 创建一个节点 ListNode*...
单向有头不循环链表
TTX_jiayou的博客
09-22 193
链表是一种常见的基础数据结构，是一种线性表，是一种物理存储单元上非连续、非顺序的存储结构。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括存储数据元素的数据域和存储下一个结点地址的指针域两个部分。 相比于线性表顺序结构，操作复杂。数据元素的逻辑顺序也是通过链表中的指针链接次序实现的。 给出头文件： #ifndef __SLIST_H__ #define __...
JavaScript数据结构之双向链表和双向循环链表的实现
01-19
双向链表和普通链表的区别在于，在链表中，一个节点只有链向下一个节点的链接，而在双向链表中，链接是双向的：一个链向下一个元素，另一个链向前一个元素。 双向链表提供了两种迭代列表的方法：从头到尾，或者反...
数据结构：单向链表源码
07-02
在计算机科学和编程领域，理解并能够实现单向链表的源码是至关重要的，因为它是构建更复杂数据结构（如双向链表、循环链表等）的基础。 在单向链表中，每个节点有两个部分：数据域和指针域。数据域存储实际的数据，...
list-2_单链表_speakgfp_数据结构_循环链表_
10-02
在本项目中，我们将探讨三种不同的链表类型：单链表、单向循环链表和双向循环链表。下面将详细阐述这些链表的实现和它们的特性。 首先，单链表是一种线性数据结构，每个节点包含两个部分：数据元素和指向下一个节点...
单向链表 代码架构
12-29
单向链表是一种基本的数据结构，它在计算机科学和编程中有着广泛的应用。与数组不同，链表中的元素不是在内存中连续存储的，而是通过指针或引用连接在一起，形成一个逻辑上的线性序列。单向链表的每个节点包含两部分...
单向不循环链表
学，用！
06-26 275
0> 数据类型： 结点类型： struct node_st { int date; struct node_st  *next; }   头指针：struct node_st *list; Xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 1> 有头单向不循环链表：    1》创建链表： …………………………………
单向不循环链表(创建、遍历、增、删、查找、判空）
qq_21944445的博客
08-18 192
# coding: utf-8 # 链表节点 class Node(object): def __init__(self, item): self.item = item self.next = None # 单向不循环链表 class LinkList(object): def __init__(self): self._h...
从零开始写一个单向不循环链表
李辉的博客
09-02 1937
从零开始写一个单向不循环链表 总结：郝斌数据结构与算法课程 数据结构概述： 定义： 我们如何把现实中大量的而复杂的问题以特定的数据类型和特定的存储结构保存到主存储器（内存）中，以及在此基础上为实现某个功能，（比如查找某个元素，删除某个元素，对所有的元素的进行排序） 数据结构= 个体的存储 + 个体的关系存储 算法：对存储数据的操作。 再次讨论什么是数据结构？ 狭义：数据结构是专门研究数...
单向非循环链表
qq_41213290的博客
02-18 130
带一个头节点的单向非循环链表实现 C语言结构体实现 typedef int SLTDataType; typedef struct SListNode //链表中的每一个节点 { SLTDataType _data; //链表储蓄的数据 struct SListNode* _next; //指向下一个节点 }SListNode; typedef struct SList //链表...
6-带头单向非循环链表
最新发布
titanium的博客
03-22 182
带头单向非循环链表
【数据结构】线性表（二）：链表 之 单向非循环链表
宫瑞阳的博客
07-22 466
单向非循环链表的基本概念+基本操作+代码实现
数据结构之无头单向不循环链表
qq_53822523的博客
07-02 293
数据结构之无头单向不循环链表详解
单向不循环链表就地转置算法
elikang的博客
02-10 729
单向不循环链表就地转置算法示例： A->B->C->D->E->F->G->NULL //这里至少需要定义三个临时变量 定义3个指针temp1, temp2, temp3 temp1=A,temp2=B,temp3=C; temp1->next = NULL; while(temp3 != NULL) { temp2->next = temp1;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值