链表的完整讲解

于 2024-08-18 16:18:03 发布
阅读量335 收藏 2
点赞数 8
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77143270/article/details/141301354
版权

链表

特点：内存不连续，通过指针进行连接

解决: 长度固定的问题，插入删除麻烦的问题

1）逻辑结构：线性结构

2）存储结构：链式存储

3）操作：增删改查

2.1单向链表

链表结构体：

struct node_t

{

int data;

struct node_t *next;

};

2.1.1分类

1）有头单向链表

存在一个头节点，数据域无效，指针域有效

遍历有头单向链表：

#include <stdio.h>

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

int main(int argc, char const *argv[])
{
    // 1.定义节点并初始化
    struct node_t a = {1, NULL};
    struct node_t b = {2, NULL};
    struct node_t c = {3, NULL};

    // 2.将节点进行连接
    a.next = &b;
    b.next = &c;

    // 3.定义一个头节点，指向第一个节点
    struct node_t s;
    s.next = &a;

    // 4.定义头指针指向头节点
    struct node_t *h = &s;

    // 5.遍历有头单向链表，方法1：
    // while (h->next != NULL)
    // {
    //     h = h->next;
    //     printf("%d ", h->data);
    // }

    //方法2：
    h=h->next;
    while (h != NULL)
    {
        printf("%d ",h->data);
        h=h->next;
    }
    
    printf("\n");
    return 0;
}

2）无头单向链表

所有节点的指针域和数据域都有效

遍历无头单向链表：

#include <stdio.h>

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

int main(int argc, char const *argv[])
{
    //1.定义节点并初始化
    struct node_t a = {1,NULL};
    struct node_t b = {2,NULL};
    struct node_t c = {3,NULL};

    //2.将节点进行连接
    a.next = &b;
    b.next = &c;

    //3.定义头指针指向第一个节点
    struct node_t *h = &a;

    //4.遍历无头单向链表
    while(h!=NULL)
    {
        printf("%d ",h->data);
        h = h->next;
    }
    printf("\n");
    return 0;
}

2.1.2操作函数

linklist.h

#ifndef _LINKLIST_H_
#define _LINKLIST_H_

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

typedef int datatype;
typedef struct node_t
{
	datatype data;//数据域
	struct node_t *next;//指针域,指向自身结构体的指针
}link_node_t,*link_list_t;

//1.创建一个空的单向链表(有头单向链表)
link_node_t *CreateEpLinkList();
//2.向单向链表的指定位置插入数据
//p保存链表的头指针 post 插入的位置 data插入的数据
int InsertIntoPostLinkList(link_node_t *p,int post, datatype data);
//3.遍历单向链表
void ShowLinkList(link_node_t *p);
//4.求单向链表长度的函数
int LengthLinkList(link_node_t *p);
//5.删除单向链表中指定位置的数据 post 代表的是删除的位置
int DeletePostLinkList(link_node_t *p, int post);
//6.判断单向链表是否为空 1代表空 0代表非空
int IsEpLinkList(link_node_t *p);
//7.修改指定位置的数据 post 被修改的位置 data修改成的数据
int ChangePostLinkList(link_node_t *p, int post, datatype data);
//8.查找指定数据出现的位置 data被查找的数据 //search 查找
int SearchDataLinkList(link_node_t *p, datatype data);
//9.删除单向链表中出现的指定数据,data代表将单向链表中出现的所有data数据删除
int DeleteDataLinkList(link_node_t *p, datatype data);
//10.转置链表
void ReverseLinkList(link_node_t *p);
//11.清空单向链表
void ClearLinkList(link_node_t *p);
#endif

1. 创建一个空的（有头）单向链表

2.向post位置插入一个数据

1、 先遍历找到要插入节点的前一个节点，假设这个节点为A；A的下一个节点为B；将C插入A与B之间；

2、 先让C的指针域指向B；

3、 再让A的指针域指向C；

（注意：顺序不可以调换）

3）删除指定位置的数据

1、先遍历找到要删除节点的前一个节点，假设为A；

2、找一个临时指针指向要删除的节点；

3、 将A的指针域指向删除节点的下一个节点；

4、 释放被删除节点

4）单向链表的转置

转置的思想：

(1) 将头节点与当前链表断开，断开前保存下头节点的下一个节点，保证后面链表能找得到，定义一个q保存头节点的下一个节点，断开后前面相当于一个空的链表，后面是一个无头的单向链表

(2) 遍历无头链表的所有节点，将每一个节点当做新节点插入空链表头节点的下一个节点(每次插入的头节点的下一个节点位置)

linklist.c

#include "linklist.h"

// 1.创建一个空的单向链表(有头单向链表)
link_node_t *CreateEpLinkList()
{
    // 1.开辟一个结构体大小的空间存放头节点
    link_list_t p = (link_list_t)malloc(sizeof(link_node_t));
    if (p == NULL)
    {
        perror("CreateEpLinkList err");
        return NULL;
    }
    // 2.初始化头节点
    p->next = NULL;

    return p;
}
// 4.求单向链表长度的函数
int LengthLinkList(link_node_t *p)
{
    int len = 0;
    while (p->next != NULL)
    {
        len++;
        p = p->next;
    }
    return len;
}

// 2.向单向链表的指定位置插入数据
// p保存链表的头指针 post 插入的位置 data插入的数据
int InsertIntoPostLinkList(link_node_t *p, int post, datatype data)
{
    // 1.容错处理
    if (post < 0 || post > LengthLinkList(p))
    {
        perror("InsertIntoPostLinkList err");
        return -1;
    }
    // 2.移动头指针，指向插入位置前一个节点
    for (int i = 0; i < post; i++)
        p = p->next;

    // 3.创建一个新节点，保存即将插入的数据
    link_list_t pnew = (link_list_t)malloc(sizeof(link_node_t));
    if (pnew == NULL)
    {
        perror("pnew malloc err");
        return -1;
    }
    pnew->data = data;
    pnew->next = NULL;

    // 4.将新节点插入链表中（先连后面，再连前面）
    pnew->next = p->next;
    p->next = pnew;

    return 0;
}
// 6.判断单向链表是否为空 1代表空 0代表非空
int IsEpLinkList(link_node_t *p)
{
    return p->next == NULL;
}

// 5.删除单向链表中指定位置的数据 post 代表的是删除的位置
int DeletePostLinkList(link_node_t *p, int post)
{
    // 1.容错判断
    if (post < 0 || post >= LengthLinkList(p) || IsEpLinkList(p))
    {
        perror("DeletePostLinkList err");
        return -1;
    }
    // 2.移动头指针，让它指向被删除位置的前一个节点
    for (int i = 0; i < post; i++)
        p = p->next;

    // 3.进行删除操作
    // 1）定义一个指针pdel指向被删除节点
    link_list_t pdel = p->next;
    // 2）跨过被删除节点
    p->next = pdel->next;
    // 3）释放被删除节点
    free(pdel);
    pdel = NULL;
    return 0;
}

// 3.遍历单向链表
void ShowLinkList(link_node_t *p)
{
    while (p->next != NULL)
    {
        p = p->next;
        printf("%d ", p->data);
    }
    printf("\n----------------------\n");
}
// 7.修改指定位置的数据 post 被修改的位置 data修改成的数据
int ChangePostLinkList(link_node_t *p, int post, datatype data)
{
    // 1.容错判断
    if (post < 0 || post >= LengthLinkList(p) || IsEpLinkList(p))
    {
        perror("ChangePostLinkList err");
        return -1;
    }
    // 2.移动头指针，让它指向被修改的节点
    for(int i = 0;i<=post;i++)
        p=p->next;
    // 3.修改数据
    p->data=data;

    return 0;
}
//8.查找指定数据出现的位置 data被查找的数据 //search 查找
int SearchDataLinkList(link_node_t *p, datatype data)
{
    //1.定义一个变量记录查找的位置
    int post  = 0;

    //2.遍历有头单向链表
    while(p->next != NULL )
    {
        p=p->next;
        if(p->data == data)
            return post;
        post++;
    }
    return -1;//不存在
}
//9.删除单向链表中出现的指定数据data,代表将单向链表中出现的所有data数据删除
int DeleteDataLinkList(link_node_t *p, datatype data)
{
    //1.定义一个指针q，始终指向p的下一个节点
    link_list_t q = p->next;
    //2.用q遍历无头单向链表
    while(q != NULL)
    {
        if(q->data == data)//找到了要删除的节点
        {
            p->next = q->next;//跨过被删除节点
            free(q);//释放被删除节点
            q=p->next;//q重新指向p的下一个节点（新）
        }
        else  
        {
            p=p->next;//将头指针指向下一个节点
            q=p->next;//始终保证q指向p的下一个节点
        }
    }
    return 0;
}
//11.清空单向链表
void ClearLinkList(link_node_t *p)
{
    link_list_t pdel = NULL;
    while (p->next != NULL)
    {
        //(1)将pdel指向被删除节点即头节点下一个节点
        pdel = p->next;
        //(2)跨过被删除节点
        p->next = pdel->next;
        //(3)释放被删除节点
        free(pdel);
        pdel = NULL;
    } 
}

//10.转置链表
void ReverseLinkList(link_node_t *p)
{
    //临时保存q节点的下一个节点
    link_list_t temp = NULL;
    //1.断开前，保存头节点的下一个节点的地址（此时q相当于指向无头单向链表的头指针）
    link_list_t q  = p->next;
    //2.断开链表
    p->next = NULL;
    //3.遍历无头链表
    while (q != NULL)
    {
        //提前保存q的下一个节点
        temp=q->next;

        //先连后面再连前面(头插)
        q->next = p->next;
        p->next = q;

        //让q重新指向当前无头单向链表的第一个节点
        q = temp;
    }
    
}

main.c

#include"linklist.h"

int main(int argc, char const *argv[])
{
    link_list_t p =CreateEpLinkList();
    InsertIntoPostLinkList(p,0,1);
    InsertIntoPostLinkList(p,1,2);
    InsertIntoPostLinkList(p,2,3);
    ShowLinkList(p);//1 2 3 
    ReverseLinkList(p);
    ShowLinkList(p);//3 2 1
    printf("len is %d\n",LengthLinkList(p));//3
    DeletePostLinkList(p,0);
    ShowLinkList(p);// 2 1
    printf("%d post is %d\n",2,SearchDataLinkList(p,2));//2  0
    DeleteDataLinkList(p,2);
    ShowLinkList(p);//1
    DeletePostLinkList(p,0);
    if(IsEpLinkList(p))
        printf("IsEpLinkList\n");
    free(p);
    p = NULL;
    return 0;
}

Makefile

CC=gcc
CFLAGS=-c -g -o
OBJS=main.o linklist.o

linklist:$(OBJS)
	$(CC) $^ -o $@
%.o:%.c 
	$(CC) $(CFLAGS) $@ $<

.PHONY:clean
clean:
	rm *.o linklist -f

敲代码的鹏鹏
关注
  • 8
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言链表操作详解
qq_41481924的博客
12-29 14万+
为什么要使用链表 在未学习链表时，我们常用的存储数据的方式无非就是数组。使用数组存储数据的好处就是查询快，但是它的弊端也很明显： 使用前需声明数组的长度，一旦声明长度就不能更改 插入和删除操作需要移动大量的数组元素，效率慢 只能存储一种类型的数据. 而链表则可以实现以上这些数组所不具备的功能，此时引入了结构体来实现创建链表的操作。 链表的特点： n个节点离散分配 每一个节...
共享链表讲解
11-27
共享链表讲解 共享链表是指将数据域和指针域进行分离管理的一种数据结构。这种结构可以帮助更好地管理资源。在本文档中，我们将详细讲解共享链表的创建和删除过程。 共享链表的创建过程可以分为两个步骤：初始化和...
C语言链表超详解
热门推荐
k666499436的博客
05-17 11万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
C语言链表讲解
anjibgdexuexi的博客
04-18 1023
然后把他的next与newhead。
数据结构之链表深度讲解
2302_80418176的博客
05-04 1362
eg.prev = prev->next 表示指针指向下一个节点，指针已经移动至下一个节点3. prev = pcur 表示pcur指针已经将它的地址和数值全传给了prev4. 链表思路上的小妙招：去寻找插入以及删除节点时哪一个链条或哪几条链条被影响了，找到被影响的链条后，将其修改一下链接对象即可5.关于pphead、 *pphead、**pphead还不清楚的同学可以参考一下下图最后也祝大家在这个五一玩的开心。
链表逆置详细讲解（图文）
qq_51366188的博客
02-26 3万+
链表逆置   前言 链表逆置是初学时有困扰到我的难点. 由于链表头结点可放可不放数据，所以写代码时候**->next**用的云里雾里。 这里讲解头结点与第一结点区分的情况，即头结点你把它看作这个 链表的“文件名” 就行。 若头结点为L，则第一结点为L->next。   代码 void listReverse(linkedList &L) { node *p,*s; //1. p = L->next; L->next = NULL; while
链表的分类与讲解
Azalea__chunzi的博客
03-17 383
链表的8种分类，关键字：带头、不带头、单向、双向、循环、不循环。
[C语言刷题篇]链表运用讲解
choice~的博客
07-28 939
给大家推荐一款神器以下题型及方法牛客都有,及企业面试高频题。
链表（C语言版）超详细讲解
h220321204的博客
08-15 1万+
而如果使用头插法，则需要遍历到链表的第一个节点，时间复杂度为O(n)，而且尾插法是由数据插入的顺序依次存储的，查找起来会更加方便。1、首先我们定义两个指针（x1,p）,x1作为头指针指向头结点（尾插法时不要移动头指针，我们只需移动p即可），p始终指向尾结点（这里我们初始化指向头结点），再申请一块结点并用x指向它。这样我们基础工作完成。
链表OJ题讲解2
bushibrnxiaohaij的博客
08-02 1349
💓博主个人主页:不是笨小孩👀 ⏩专栏分类:数据结构与算法👀 🚚代码仓库:笨小孩的代码库👀 ⏩社区：不是笨小孩👀 🌹欢迎大家三连关注，一起学习，一起进步！！💓 链表OJ链表的回文结构链表分割两个链表的交集链表循环思考[链表周期 II](https://leetcode.cn/problems/linked-list-cycle-ii/description/)方法一方法二 链表的回文结构 回文节后是对称的，所以这个题目我们可以先找到中间节点，然后将中间反转，然后两个指针，一个从头开始，一个从反转后的
反转链表详解
Weirdo的博客
06-14 1200
这些数据项通常以链表的形式组织起来，其中最近使用的数据项位于链表的头部，最久未使用的数据项位于链表的尾部。反转链表指的是将链表的头尾节点对调，使得原本链表的第一个节点变为最后一个节点，原本链表的最后一个节点变为第一个节点，其他节点的相对位置也进行相应调整。通过对反转链表算法的深入理解和实践应用，我们可以更好地掌握链表的基本操作和指针的使用，并提高编程能力和解决问题的能力。然而，锁的使用会降低程序的性能。在实际应用中，我们可能需要在反转链表的同时进行其他操作，例如计算链表长度、检查链表中的重复元素等。
链表的讲解
04-19
数据结构中的链表，将的还算不错，大家可以参考下的。
LeetCode 141 环形链表讲解 PPT
03-12
LeetCode 141 环形链表讲解 PPT提供了检测链表中是否存在环形结构的一种解决方案。该PPT通过样例和代码，展示了检测链表中是否存在环形结构的过程。 样例一： 输入：head = [3,2,0,-4] 输出：true 哈希表：3,2,0,-...
PHP从尾到头打印链表实例讲解
10-17
在计算机科学中，链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和一个指向下一个节点的指针。在PHP中处理链表时，有时需要实现从链表尾部到头部逆序打印节点值的功能。这通常可以通过递归或使用...
单向链表的逆转-详细讲解
05-21
本篇将详细讲解如何逆转单向链表。 首先，让我们了解单向链表的基本结构。链表由一系列节点组成，每个节点包含两个部分：数据域（用于存储数据）和指针域（用于指向下一个节点）。假设我们有一个如下的单向链表： ...
【数据结构】二叉树篇
2303_79015671的博客
08-14 1134
深入解析数据结构二叉树
uva1586分子量（Molar Mass,ACM/ICPC Danang 2007）
2301_80844586的博客
08-14 246
然后代码具体要考虑i++每次进行i++自动i++这样避免算完字母后碰到数字然后会多算一次字母。就是一位算数字后i++如果【i+2】就是匹配到两位数的话再次i++；这样可以有效避免数字越界（你可以好好思考一下）如果都没有就是1直接定义1即可。第一个是有四个字母然后把for循环中匹配到的字母进行确认到z里面后面进行。第二的大逻辑就行下面的if那个三大判断条件第一个是一位数并且是。也是改了小两天，然后说一下核心代码逻辑两大块的核心。就是没有数字的就是1的。
数据结构：栈
最新发布
2301_80744520的博客
08-17 352
顺序栈的表示存储方式：利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素。栈底一般在低地址。top：指示栈顶元素位置base：指示栈底元素位置stacksize：表示栈的最大容量接下来，我们用更详细的一幅图来描述顺序栈：起始状态，top和base都指向0的位置，此时是空栈：base==top，且栈的容量stacksize=4。接下来为空的栈添加元素（入栈），将新的元素添加到top所指位置，再将top移向下一位置，我们最终可以观察到top并没有指向D，而是栈的外面，即4的位置。
【Java & 数据结构】LinkedList介绍
qq_42150700的博客
08-14 1125
回答这个问题前, 首先我们需要了解一下这个头节点是干什么的. 这个头节点实际上和寻常的节点没有什么两样, 但是它的数据域, 是不存储真正的数据的, 你可以在这个数据域中存储任意的数据, 例如存储链表的长度, 或者根本不使用这个数据域都是可以的. 它的作用就是用于作为链表的头, 便于链表的操作和管理而设计的.首先我们要想这个节点和链表是什么关系?很明显如果要插入一定要前一个位置的引用, 因为要令其 next 指向当前节点, 因此我们需要找到前一个节点. 那么我们如何找到前一个节点呢?
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值