【C语言】数据结构单向链表

已于 2024-01-22 18:22:03 修改
阅读量444 收藏 11
点赞数 7
分类专栏： C语言 # 链表 文章标签： 数据结构 c语言 链表 开发语言
于 2024-01-22 10:57:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/v13111329954/article/details/135742258
版权

链表的学习

文章目录

1.什么是链表

在这里插入图片描述

一种数据存放的思想，数据结构。方便：增删改查

我们所熟知的数组，他的地址是连续的，一个接着一个，那么如果我想要删除或者修改其中的某一个元素时，那么这个时候数组就及其的不方便，因为的地址是连续的。

那么如果我们在这个时候引入链表，他的每个元素存放着下一个元素的地址，这样删除修改元素时只需修改下一个元素地址走向

2.静态创建链表

1.链表与数组的区别及实现

#include <stdio.h>

struct Test{
    int data;
    struct Test *next;
};//分号不能丢
int main()
{
    int array[]={2,5,9};
    for(int i =0;i<sizeof(array)/sizeof(array[0]);i++){
        printf("%d ",array[i]);
    }
    putchar('\n');//单引号
    struct Test t1 ={5,NULL};
    struct Test t2 ={2,NULL};
    struct Test t3 ={1,NULL};
    t1.next = &t2;//用.运算符给结构体指针赋值
    t2.next = &t3;//t2结构体指针里面存放着t3结构体（属于一个块地址，里面存放着很多变量）的地址
    //链表思想，一个链一个
    printf("%d %d %d",t1.data,t1.next->data,t1.next->next->data);
    return 0;
}

3.链表的遍历

#include <stdio.h>

struct Test{
    int data;
    struct Test *next;
};//分号不能丢
void prinftlink(struct Test *head)
{
    struct Test *point;
    point = head;
    //我们知道链表的第一个指针存放下一个结构体的地址，第二个存放第三个，而第三个，也就是最后一个他的指针是空的，即NULL
    //所以我们可以利用这一特性来写循环
/*********************************
    while(1){
        if(point != NULL){
           printf("%d ",point->data);
            point = point ->next;
        }else{
            break;//跳出while（1）死循环
        }
**********************************/
        while(point != NULL){
            printf("%d ",point->data);
            point = point ->next;//指针偏移，指向下一个结构体指针
        }
    
    
}
int main()
{
    int array[]={2,5,9};
    for(int i =0;i<sizeof(array)/sizeof(array[0]);i++){
        printf("%d ",array[i]);
    }
    putchar('\n');//单引号
    struct Test t1 ={5,NULL};
    struct Test t2 ={2,NULL};
    struct Test t3 ={1,NULL};
    struct Test t4 ={4,NULL};
    t1.next = &t2;//用.运算符给结构体指针赋值
    t2.next = &t3;//t2结构体指针里面存放着t3结构体（属于一个块地址，里面存放着很多变量）的地址
    t3.next = &t4;
//数越多，越傻瓜
  //  printf("%d %d %d",t1.data,t1.next->data,t1.next->next->data);
    prinftlink(&t1);//这个我们只需要把结构体的头地址放入即可遍历出来
    return 0;
}

4.链表的查找

统计链表节点个数及链表查找

#include <stdio.h>

struct Test{
    int data;
    struct Test *next;
};//分号不能丢

void prinftlink(struct Test *head)
{
    struct Test *point;
    point = head;
    while(point != NULL)
    {
        printf("%d ",point->data);
        point = point ->next;//指针偏移，指向下一个结构体指针
    }   
}

int getTotalNodeNum(struct Test *head)//查找链表节点个数
{
	int cnt = 0;
    while(head != NULL)
    {
        cnt++;
        head = head ->next;//指针偏移，指向下一个结构体指针
    } 
    return cnt;
}

int searchlink(struct Test *head,int data)//查找链表中是否有这个元素
{
    while(head != NULL)
    {
    	if(head ->data == data){
            return 1;
        }
        head = head ->next;//指针偏移，指向下一个结构体指针
    } 
    return 0;
}
int main()
{
    int array[]={2,5,9};
    for(int i =0;i<sizeof(array)/sizeof(array[0]);i++){
        printf("%d ",array[i]);
    }
    putchar('\n');//单引号
    struct Test t1 ={5,NULL};
    struct Test t2 ={2,NULL};
    struct Test t3 ={1,NULL};
    struct Test t4 ={4,NULL};
    t1.next = &t2;//用.运算符给结构体指针赋值
    t2.next = &t3;//t2结构体指针里面存放着t3结构体（属于一个块地址，里面存放着很多变量）的地址
    t3.next = &t4;

    prinftlink(&t1);//这个我们只需要把结构体的头地址放入即可遍历出来
    int a = getTotalNodeNum(&t1);
    printf("total num is %d\n",a);
    
    int b = searchlink(&t1,0);
    if(b){
        printf("you found it\n");
    }else{
         printf("you don't found it\n");
    }
    return 0;
}

5.链表的插入

在节点的后方插入新数据

1 2 3 4 这是一个链表，一个链一个，如果我们想在3的后面插入一个100，一共分三步

  1. 找到3这个数
  2. 让新节点的指针指到4
  3. 3的指针指到新节点
#include <stdio.h>

struct Test{
    int data;
    struct Test *next;
};//分号不能丢

void prinftlink(struct Test *head)
{
    struct Test *point;
    point = head;
    while(point != NULL)
    {
        printf("%d ",point->data);
        point = point ->next;//指针偏移，指向下一个结构体指针
    }   
}

int insertlink(struct Test *head,int data,struct Test *New)//在链表中插入新元素
{
    struct Test *p = head;
    while(p != NULL)
    {
    	if(p ->data == data){
            New ->next = p->next;
            p ->next = New;
            return 1;
        }
        p = p ->next;//指针偏移，指向下一个结构体指针
    } 
    return 0;
}
int main()
{
    int array[]={2,5,9};
    for(int i =0;i<sizeof(array)/sizeof(array[0]);i++){
        printf("%d ",array[i]);
    }
    putchar('\n');//单引号
    struct Test t1 ={5,NULL};
    struct Test t2 ={2,NULL};
    struct Test t3 ={1,NULL};
    struct Test t4 ={4,NULL};
    t1.next = &t2;//用.运算符给结构体指针赋值
    t2.next = &t3;//t2结构体指针里面存放着t3结构体（属于一个块地址，里面存放着很多变量）的地址
    t3.next = &t4;

    struct Test New ={100,NULL};
    prinftlink(&t1);//这个我们只需要把结构体的头地址放入即可遍历出来
    puts("after insert behind is  \n");
    insertlink(&t1,1,&New);
	prinftlink(&t1);
}

在节点的前方插入

难点在于链表的头如何插入？如果在链表头插入新元素，这个时候链表的头就发生了改变

#include <stdio.h>

struct Test{
    int data;
    struct Test *next;
};//分号不能丢

void prinftlink(struct Test *head)
{
    struct Test *point;
    point = head;
    while(point != NULL)
    {
        printf("%d ",point->data);
        point = point ->next;//指针偏移，指向下一个结构体指针
    }   
}

int insertlinkfrombehind(struct Test *head,int data,struct Test *New)//在链表中插入新元素
{
    struct Test *p = head;
    while(p != NULL)
    {
    	if(p ->data == data){
            New ->next = p->next;
            p ->next = New;
            return 1;
        }
        p = p ->next;//指针偏移，指向下一个结构体指针
    } 
    return 0;
}

struct 	Test *insertlinkfromforward(struct Test *head,int data,struct Test *New)
{
	struct Test *p = head;
	//如果是头节点的话，直接插入，把New返回回去
    	if(p ->data == data){
            New ->next = head;
            return New;
        }
	//如果不是头节点，那我就可以向下遍历了
    while(p->next != NULL)
    {
        if(p->next->data == data)//这是变化的地方
        {
            New->next =p->next;
            p ->next = New;
            return head;//换完直接返回退出，不用向下走了
        }
        p = p ->next;
    }
    return head;
}

int main()
{
	struct Test *head = NULL;
    
    struct Test t1 ={5,NULL};
    struct Test t2 ={2,NULL};
    struct Test t3 ={1,NULL};
    struct Test t4 ={4,NULL};
    t1.next = &t2;//用.运算符给结构体指针赋值
    t2.next = &t3;//t2结构体指针里面存放着t3结构体（属于一个块地址，里面存放着很多变量）的地址
    t3.next = &t4;

    head = &t1;
    
    struct Test New ={100,NULL};
    prinftlink(head);//这个我们只需要把结构体的头地址放入即可遍历出来
    puts("after insert behind is  \n");
    insertlinkfrombehind(head,1,&New);
	prinftlink(head);
    
    struct Test New2 ={200,NULL};
    head = insertlinkfromforward(head,1,&New2);
    puts("after insert forword is  \n");
    prinftlink(head);
}

6.链表的删除

假设目前五个数 1 2 3 4 5 想要删除某个节点

情况一：如果是头节点呢？删除之后头节点会变

情况二：不是头节点，if（p->next->data == data） p->next = p->next->next

#include <stdio.h>
#include <stdlib.h>
struct Test{
    int data;
    struct Test *next;
};//分号不能丢

void prinftlink(struct Test *head)
{
    struct Test *point;
    point = head;
    while(point != NULL)
    {
        printf("%d ",point->data);
        point = point ->next;//指针偏移，指向下一个结构体指针
    }   
}

struct Test* deleteNote(struct Test *head,int data)
{
    struct Test *p = head;
    if(p->data == data)
    {
        head = head->next;
        free(p);
    }
    while(p->next != NULL)
    {
        if(p->next->data == data)
        {
            p->next = p->next->next;
            return head;
        }
        p = p->next;
    }
    return head;
}


int main()
{
	struct Test *head = NULL;
    
    //struct Test t1 ={5,NULL};
    struct Test *p =(struct Test*)malloc(sizeof(struct Test));//动态创建，继续用以前的静态创建会报错
    struct Test t2 ={2,NULL};
    struct Test t3 ={1,NULL};
    struct Test t4 ={4,NULL};
    
   // t1.next = &t2;//用.运算符给结构体指针赋值
    p->data = 1;
    p->next = &t2;
    
    t2.next = &t3;//t2结构体指针里面存放着t3结构体（属于一个块地址，里面存放着很多变量）的地址
    t3.next = &t4;

   // head = &t1;
    head = p;
    prinftlink(head);//这个我们只需要把结构体的头地址放入即可遍历出来
    putchar('\n');
	head = deleteNote(head,2);
	prinftlink(head);
}

7.链表的修改

直接在查找的基础上改不就行了吗？

#include <stdio.h>

struct Test{
    int data;
    struct Test *next;
};//分号不能丢

void prinftlink(struct Test *head)
{
    struct Test *point;
    point = head;
    while(point != NULL)
    {
        printf("%d ",point->data);
        point = point ->next;//指针偏移，指向下一个结构体指针
    }   
}

int getTotalNodeNum(struct Test *head)//查找链表节点个数
{
	int cnt = 0;
    while(head != NULL)
    {
        cnt++;
        head = head ->next;//指针偏移，指向下一个结构体指针
    } 
    return cnt;
}

int searchlink(struct Test *head,int data,int newdata)//查找链表中是否有这个元素
{
    while(head != NULL)
    {
    	if(head ->data == data){
            head ->data = newdata;
            return 1;
        }
        head = head ->next;//指针偏移，指向下一个结构体指针
    } 
    return 0;
}
int main()
{
    int array[]={2,5,9};
    for(int i =0;i<sizeof(array)/sizeof(array[0]);i++){
        printf("%d ",array[i]);
    }
    putchar('\n');//单引号
    struct Test t1 ={5,NULL};
    struct Test t2 ={2,NULL};
    struct Test t3 ={1,NULL};
    struct Test t4 ={4,NULL};
    t1.next = &t2;//用.运算符给结构体指针赋值
    t2.next = &t3;//t2结构体指针里面存放着t3结构体（属于一个块地址，里面存放着很多变量）的地址
    t3.next = &t4;

    prinftlink(&t1);//这个我们只需要把结构体的头地址放入即可遍历出来
    int a = getTotalNodeNum(&t1);
    printf("total num is %d\n",a);
    
    int b = searchlink(&t1,0);
    if(b){
        printf("you found it\n");
    }else{
         printf("you don't found it\n");
    }
    return 0;
}

8.动态创建链表

头插法

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

struct Test{
    int data;
    struct Test *next;
};//分号不能丢

void printflink(struct Test *head)
{
    struct Test *point;
    point = head;
    while(point != NULL)
    {
        printf("%d ",point->data);
        point = point ->next;//指针偏移，指向下一个结构体指针
    }   
}

struct Test *insertFormHead(struct Test *head)
{
    struct Test* New;
    
	while(1)
    {
            New = (struct Test *)malloc(sizeof(struct Test));
            printf("input your new node data:\n");
            scanf("%d,",&(New->data));
			
        	if(New ->data ==0){
                printf("0 quit\n");
                return head;
            }
            if(head == NULL){
                head = New;
            }else{
                New->next = head;
                head = New;   
            }        
    }
    return head;
}
int main()
{
    struct Test *head = NULL;
	head = insertFormHead(head);
	printflink(head);
    return 0;
}

对上优化

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

struct Test{
    int data;
    struct Test *next;
};//分号不能丢

void printflink(struct Test *head)
{
    struct Test *point;
    point = head;
    while(point != NULL)
    {
        printf("%d ",point->data);
        point = point ->next;//指针偏移，指向下一个结构体指针
    }   
}

struct Test *insertFormHead(struct Test *head,struct Test *New)
{
    if(head == NULL){
        head = New;
    }else{
        New->next = head;
        head = New;   
    }        
    return head;
}
struct Test *creatlink(struct Test *head)
{
    struct Test* New;
     
	while(1)
	{
        New = (struct Test *)malloc(sizeof(struct Test));
        printf("input your new node data:\n");
        scanf("%d,",&(New->data));

        if(New ->data ==0){
            printf("0 quit\n");
            return head;
        }
        head = insertFormHead(head,New);
     }
}
int main()
{
    struct Test *head = NULL;
	head = insertFormHead(head);
	printflink(head);
    return 0;
}

尾插法

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

struct Test{
    int data;
    struct Test *next;
};//分号不能丢

void printflink(struct Test *head)
{
    struct Test *point;
    point = head;
    while(point != NULL)
    {
        printf("%d ",point->data);
        point = point ->next;//指针偏移，指向下一个结构体指针
    }   
}

struct Test *insertFormHead(struct Test *head,struct Test *New)
{
    if(head == NULL){
        head = New;
    }else{
        New->next = head;
        head = New;   
    }        
    return head;
}
struct Test *creatlink(struct Test *head)
{
    struct Test* New;
     
	while(1)
	{
        New = (struct Test *)malloc(sizeof(struct Test));
        printf("input your new node data:\n");
        scanf("%d,",&(New->data));

        if(New ->data ==0){
            printf("0 quit\n");
            return head;
        }
        head = insertFormHead(head,New);
     }
}
struct Test *insertbehind(struct Test *head,struct Test *new)
{
    struct Test *p = head;
    if(p == NULL){
        head = new;
        return head;
    }
    while(p ->next != NULL)//没有到尾巴前一直偏移指针
    {
        p = p->next;
    }
    p->next = new;
    return head;
}
struct Test *creatlink2(struct Test *head)
{
    struct Test* New;
     
	while(1)
	{
        New = (struct Test *)malloc(sizeof(struct Test));
        printf("input your new node data:\n");
        scanf("%d,",&(New->data));

        if(New ->data ==0){
            printf("0 quit\n");
            return head;
        }
        head = insertbehind(head,New);
     }
}
int main()
{
    struct Test *head = NULL;
	head = creatlink2(head);
	printflink(head);
    //头插法
    struct Test t1 ={1000,NULL};
    head = insertFormHead(head,&t1);
    printflink(head);
    //尾插法
    struct Test t2 ={2000,NULL};
    head = insertbehind(head,&t2);
    printflink(head);
    return 0;
}

至此，单向链表完结啦！！ “请不要相信胜利就像山坡上的蒲公英一样唾手可得，但是请相信生活中总有美好值得我们全力以赴，哪怕粉身碎骨！”

橘猫.exe
关注
  • 7
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【C语言】数据结构-单链表
m0_74292919的博客
01-27 1779
同样是线性存储结构，顺序表是连续的，而链表是离散的，顺序表的内存申请是有多余消耗的，而链表是没有的（按需索取），顺序表在插入与删除数据上的时间消耗是巨大的，而链表则是简易的这就是本次单链表的全部内容了，接下来就是双链表的学习，结束之后我们就正式进入数据结构初阶的内容学习了，这段内容还是要多多做题，多多画图，多多思考，不怕浪费时间的，我在单链表。
C语言数据结构单链表
houruluoli的博客
04-15 155
前言： 自己做的单链表，供大家参考共同研究。 程序代码： #include<stdio.h> #include<stdlib.h> #define LEN sizeof(ListNode) typedef int DataType; typedef struct node //结点类型定义 { DataType data; //结点的数据域 struct node *next; //结点的指针域 }ListNode,*LinkList; void logo(); void
C语言数据结构——链表
wxk2227814847的博客
01-28 1837
在计算机科学中，数据结构是存储和组织数据的一种方式，它不仅影响数据的存储，也影响数据的检索和更新效率。C语言，作为一种经典的编程语言，提供了灵活的方式来处理数据结构，其中链表是最基本且重要的一种。
C语言链表超详解
热门推荐
k666499436的博客
05-17 11万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
数据结构——单向链表（C语言实现）
2402_82711634的博客
01-18 1704
无头链表：以结点为开头的链式结构——————同时也是非循环链表typedef struct SListNode//定义的是结点的结构//存放数据//存放下一个位置的地址}SLTNode;//pos就是节点的指针。
C语言数据结构旋转链表的实现
12-31
C语言数据结构旋转链表的实现 实例： 给出链表1->2->3->4->5->null和k=2 返回4->5->1->2->3->null 分析： 感觉很直观，直接把分割点找出来就行，记得k可能大于len,要取模 代码： /** * Definition for singly-...
C语言实现单向链表及操作
03-24
数据结构，c语言实现的单向链表。代码分享 struct LinkNode { int data; struct LinkNode *next; }; typedef struct LinkNode *Lnode;
C语言单向链表的表示与实现实例详解
12-31
C语言中的单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。 链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的...
数据结构笔记：单向链表
12-22
分类目录——数据结构笔记 离散存储，手拉手，每一块有指向下一块的指针（形象描述，python中没有指针），就好像形成了一条链 一个元素包括两部分：value 和 next 链表与顺序表都是线性表 知识点补充 b = 20 a = 'a...
学习记录day18——数据结构 算法
weixin_64918301的博客
07-24 916
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
数据结构之《栈》
2303_81098358的博客
07-24 1302
在之前我们已经学习了数据结构中线性表里面的顺序表与链表，了解了如何实现顺序表与链表增、删、查、该等功能。其实在线性表中除了顺序表和链表还有其他的类别，在本篇中我们就将学习另外一种线性表——栈，在通过本篇的学习后，你将会对栈的结构有充足的了解，在了解完结构后我们还将进行栈的实现。
【数据结构】：用Java实现链表
Yechiel的博客
07-24 1362
本篇文章用Java介绍了：链表的概念，以及单链表的主要功能的具体实现方法
数据结构——双向链表及其总结
2406_83392683的博客
07-23 427
1.概述链表根据是否带头、是否双向、是否循环可以分为八种，双向链表是典型的带头双向循环链表。2.双向链表的实现过程及其解析双向链表的实现依旧包含List.h，List.c，test.c2.1 链表初始化双向链表为空的情况：只有一个哨兵位。2.2插入数据。
【数据结构】单链表&带头双向循环链表的实现
t5y22的博客
07-24 447
链表
数据结构-C语言-排序（4）
h_number_1的博客
07-23 1203
归并排序、计数排序
2024.7.24 作业
qq_64434282的博客
07-24 1997
【代码】2024.7.24 作业。
数据结构和算法入门
weixin_67852890的博客
07-25 1503
链表（Linked List）是一种线性数据结构，由一系列节点（Node）组成。每个节点包含两部分：元素值（Element Value）和指向下一个节点的指针（Pointer）。链表可以分为多种类型，如单向链表、双向链表、循环链表等。元素在存储上并不连续。队列是一种基础且广泛应用的线性数据结构，它模拟了现实生活中的排队现象，遵循“先进先出”（First-In-First-Out, FIFO）原则。
C 语言动态链表
qq_68495605的博客
07-25 1023
动态链表是通过结点（Node）的集合来非连续地存储数据，结点之间通过指针相互连接。动态链表本身就是一种动态分配内存的数据结构。每个结点都包含数据部分和指向下一个节点的指针。这种结构允许在运行时动态地添加、删除或修改结点，而不需要像数组那样担心容量问题。
thinkPHP开发的彩漂网站源码，含pc端和手机端
最新发布
jiyc2008的博客
07-30 1万+
thinkPHP开发的菜票网站源码，含pc端和手机端
c语言数据结构单向链表使用malloc分配空间
01-28
在C语言中，使用malloc函数可以动态地分配内存空间。下面是一个示例，演示了如何使用malloc函数来分配空间并创建一个单向链表： ```c #include <stdio.h> #include <stdlib.h> // 定义链表节点结构体 typedef struct Node { int data; struct Node* next; } Node; // 创建链表节点 Node* createNode(int data) { Node* newNode = (Node*)malloc(sizeof(Node)); if (newNode == NULL) { printf("内存分配失败\n"); return NULL; } newNode->data = data; newNode->next = NULL; return newNode; } // 初始化链表 Node* initList() { Node* head = createNode(0); // 创建头节点 if (head == NULL) { return NULL; } return head; } // 在链表末尾插入节点 void insertNode(Node* head, int data) { Node* newNode = createNode(data); if (newNode == NULL) { return; } Node* temp = head; while (temp->next != NULL) { temp = temp->next; } temp->next = newNode; } // 打印链表 void printList(Node* head) { Node* temp = head->next; // 跳过头节点 while (temp != NULL) { printf("%d ", temp->data); temp = temp->next; } printf("\n"); } // 释放链表内存 void freeList(Node* head) { Node* temp = head; while (temp != NULL) { Node* nextNode = temp->next; free(temp); temp = nextNode; } } int main() { Node* head = initList(); // 初始化链表 if (head == NULL) { return 0; } insertNode(head, 1); // 在链表末尾插入节点 insertNode(head, 2); insertNode(head, 3); printList(head); // 打印链表 freeList(head); // 释放链表内存 return 0; } ``` 这段代码演示了如何使用malloc函数来分配空间并创建一个单向链表。首先，我们定义了一个链表节点结构体，包含数据和指向下一个节点的指针。然后，我们实现了创建节点、初始化链表、插入节点、打印链表和释放链表内存的函数。在主函数中，我们初始化链表，插入节点，打印链表，最后释放链表内存。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

橘猫.exe

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值