数据结构——单链表

最新推荐文章于 2023-07-21 16:37:29 发布
最新推荐文章于 2023-07-21 16:37:29 发布
阅读量3.6k 收藏 85
点赞数 27
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45691686/article/details/104683038
版权

线性表的链式存储结构

目录

在每个节点中除包含有数据域外，只设置一个指针域 ，用以指向其后继节点，这样构成的链接表称为线性单向链 接表，简称单链表，为了便于插入和删除运算的实 现，每个链表带有一个头节点，并通过头节点的指针唯一标识该链表。

单链表的缺点：当访问过一个节点后，只能接着访问它的 后继节点，而无法访问它的前驱节点。

单链表的相关运算

先定定义一下链表的结构体

typedef struct Lnode{
    int data;
    struct Lnode *next;
} LinkList;

插入和删除节点

  1. 插入节点

    LinkList *p //这是指向原来在链表中的
LinkList s //这是需要被插入的节点
s->next = p->next;
p->next = s;
//：只需修改相关节点的指 针域，不需要移动节点

  2. 删除节点

    LinkList *p// 指向链表 假设需要被删的元素是指 的后驱元素
p->next = p->next->next;

建立单链表：

  1. 头插法建表
    特点：新节点插入到当前链表的表头上，最后得到的链表是一个与插入顺序相反的链表

     void CreateHeadList(LinkList *&L,int a[],int n){//头插法建表 
	 LinkList *s;//指向LinkList类型数据的指针
	 int i;
	 L = (LinkList*)malloc(sizeof(LinkList));
	 L->next  = NULL;//创建头节点,他的下一个是，UNLL
 
    for(i = 0;i<n;i++){
 		s = (LinkList*)malloc(sizeof(LinkList));//分配地址后，就是指针型变量；
 		//这里 给s分配地址要写在for循环里面，每次分配新的才是新的节点。 
   	  s->data =a[i];
  	   s->next = L->next;//
  	   L->next = s;
     // free(s); 也不可以释放，不然你刚创建的节点就没有了； 
	 }
 }

  2. 尾插法建表：
    特点：生成的链表中节点的 次序和原数组元素的顺序一样。
    尾插示意图

    void CreateEndList(LinkList *&L,int a[],int n){
    LinkList *s,*r;
    int i;
    L = (LinkList*)malloc(sizeof(LinkList));//创建头节点
    r = L//r时钟指向尾节点，开始的时候，指的是头节点
    for(i = 0;i<n;i++){
        s = (LinkList*)malloc(sizeof(LinkList));
        s->data = a[i];
        r->next = s;
        r=s;
    }
    r->next = UNLL;//尾节点的next为UNLL
}

线性表基本运算在单链表上的实现

  1. 初始化线性表 InitList(L)

    void InitList(*&L){
    L = (LinkList*)malloc(sizeof(LinkList));
    L->next = NULL;//不管是头插还是尾插，都一样，
  	  	           //尾插的话后面就改变了，而头插则一直都是UNLL。
}

  2. 销毁线性表 DestroyList(L)

    void DistroyList(*&L){
    LinkList *pre = L,*p = L->next;
    while(p!=NULL){
        free(pre);
        pre = p;
        p = p->next;//遍历整个链表，释放每个节点
    }
    free(pre);//还有一个没被放
}

  3. 判线性表是否为空表 ListEmpty(L)

    bool ListEmpty(*L){
    return (L->next=NULL);
}

  4. 求线性表的长度 ListLength(L)

    int ListLenth(*L){
    int n=0;
    LinkList *p=L;
    while(L!=NULL){
        n++;
        p=p->next;//p移向下一个节点   
    }
    return (n);
}

  5. 输出线性表 DispList(L)

    void DispList(LinkList *L) 
{  LinkList *p=L->next; //p指向开始节点   
 while (p!=NULL){ //p不为NULL,输出*p节点的data值  
     printf("%d ",p->data); 
  	p=p->next; //p移向下一个节点   
 }   
 printf("\n"); 
}

  6. 求线性表 L 中指定位置的某个数据元素 GetElem(L, I , e)

    bool GetElem(*L,int i,int &e){//e来保存该元素的值
    LinkList *p=L;
    for(j=0;j<i&&p!=NULL;j++){
        p=p->next;
    }
    if(p==NULL)
        return false;
    else{
        e = p->data;
        return true;
    }
   		
}

  7. 按元素值查找 LocateElem(L,e)

    int LocateEleme(*L,int e){
    int i=1;
	LinkList *p=L->next;
    while(p->data != e&& p!=NULL){
        i++;
        p = p->next;
    }
    if(p==NULL)
        return(0);
    else
        return (i);
    
}

  8. 插入数据元素 ListInsert(L,i,e)

    bool ListInsert(*&L,int i,int e){
    LinkList *p=L,*s;
    int j=0;
    while(j<i-1&&p!=NULL){//因为单链表只能由前去元素道后驱元素，
   	                      // 所以如果想要在 第3个位置插要先找到第2个
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;        
    else
    {
     	s=(LinkList *)malloc(sizeof(LinkList));
        s->data=e;
        s->next = p->next;
        p->next = s;
        return true;
        
    }
}

  9. ）删除数据元素 ListDelete(L,i,e)

    bool ListDelete(LinkList *&L,int i;&e){
    LinkList *p=L,*s;
    int j = 0;
    while(j<i-1&&p!=NULL){
        j++;
        p = p->next
    }
    if(p==NULL)
        return false;
    else{
        s=p->next;
        if(s==NULL)
            return false;
        else{
            e=s->data;
        	p->next = s->next;
            free(s);//记得释放，是个好习惯
        }        	
    }
}

一道例题

只有上面讲解好像还不理解，把代码合起来看看

有 一 个 带 头 节 点 的 单 链 表 L={a1,b1,a2,b2, …,an,bn} ，设计一个算法将其拆分成两个带头节点的单链表 L1 和 L2 ： L1={a1,a2,…,an} ， L2={bn,bn-1,…,b1} 要求 L1 使用 L 的头节点。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef struct Lnode{
    int data;
    struct Lnode *next;
} LinkList;

void CreateHeadList(LinkList *&L,int a[],int n){//头插法建表 
    LinkList *s;//指向LinkList类型数据的指针
    int i;
    L = (LinkList*)malloc(sizeof(LinkList));
    L->next  = NULL;//创建头节点,他的下一个是，UNLL
    
    for(i = 0;i<n;i++){
    	s = (LinkList*)malloc(sizeof(LinkList));//分配地址后，就是指针型变量；
    	//这里 给s分配地址要写在for循环里面，每次分配新的才是新的节点。 
        s->data =a[i];
        s->next = L->next;//
        L->next = s;
        // free(s); 也不可以释放，不然你刚创建的节点就没有了； 
    }
}

//销毁线性表
void DistroyList(LinkList *&L){
    LinkList *pre = L,*p = L->next;
    while(p!=NULL){
        free(pre);
        pre = p;
        p = p->next;//遍历整个链表，释放每个节点
    }
    free(pre);//还有一个没被放
}

//判断线性表是否为空 
bool ListEmpty(LinkList *L){
    return (L->next=NULL); 
}

//求线性表的长度
int ListLenth(LinkList *L){
    int n=0;
    LinkList *p=L;
    while(L!=NULL){
        n++;
        p=p->next;//p移向下一个节点   
    }
    return (n);
}

//输出线性表 
void DispList(LinkList *L) 
{  LinkList *p=L->next; //p指向开始节点   
 while (p!=NULL){ //p不为NULL,输出*p节点的data值  
    printf("%d ",p->data); 
  	p=p->next; //p移向下一个节点   
 }   
 printf("\n"); 
}

//求线性表指定位置的一个数值 
bool GetElem(LinkList *L,int i,int &e){//e来保存该元素的值
    LinkList *p=L;
    for(int j=0;j<i&&p!=NULL;j++){
        p=p->next;
    }
    if(p==NULL)
        return false;
    else{
        e = p->data;
        return true;
    }
   		
}

//产找第一个值为 e 的元素的位置 
int LocateEleme(LinkList *L,int e){
    int i=1;
	LinkList *p=L->next;
    while(p->data != e&& p!=NULL){
        i++;
        p = p->next;
    }
    if(p==NULL)
        return(0);
    else
        return (i);
    
}

//插入数据元素 
bool ListInsert(LinkList *&L,int i,int e){
    LinkList *p=L,*s;
    int j=0;
    while(j<i-1&&p!=NULL){//因为单链表只能由前去元素道后驱元素，所以如果想要在 第3个位置插要先找到第2个
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;        
    else
    {
     	s=(LinkList *)malloc(sizeof(LinkList));
        s->data=e;
        s->next = p->next;
        p->next = s;
        return true;
        
    }
}

void run(LinkList *L,LinkList *&L1,LinkList *&L2){
    // L1要有尾插法，L2用头插法
    LinkList *p=L->next,*r,*q;
    L1 = L;//L1 用L这个头节点
    r=L1;
    L2 = (LinkList *)malloc(sizeof(LinkList));
    L2->next = NULL;
    while(p!=NULL){
        r->next = p;
        r=p;
        //头插法完成
        
        /*
        q=p->next;
        q->next = L2->next;
        L2->next=q;
        p=p->next->next;
        //这个方法不行，这个虽然插好了，但是，如果要移动p的时候就不可以了
        //因为p->next指的是q,但是q的next已经指的不是原来L里的下一个了
        //这个主要是因为头插法改变插入元素的next值
        */
        

        p=p->next;//把p往后移一个
        q=p->next;
        p->next = L2->next;
        L2->next = p;
        p=q;//这样就保证了P可以连续的在L中移动
    }
    r->next=NULL;
}

int main(){
	int a[]={12,52,64,3,31,58,49,65,61,67,2,8,9,7,6,2,4,64};
	int n = 18;
	LinkList *L,*L1,*L2;
	CreateHeadList(L,a,n);
	DispList(L);
	/*
	int e = 18 ;
	ListInsert(L,10,e);
	DispList(L);
	*/
	run(L,L1,L2);
	DispList(L1);
	printf("***************\n");
	DispList(L2);
	printf("***************\n");
	DispList(L)//这里发现，L打印出来和L1一样
}

单链表原地置逆

最进有伙伴还问单链表怎么原地置逆，我这里提供两种思路，第一中，修改一下 next指针，第二种，我们都知道，头插法得到的单链表是反的，所以我们可以原地头插法；

  1. 法一：有头节点的单链表。

    void turn(LinkList *&L){
LinkList *p=NULL,*pre=NULL,*s=NULL;
s = L->next;
while(s!=NULL){
	p = s;
	s = s->next;
	p->next = pre;
	pre = p;
	}
	L->next = pre;
}

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    根据图中的示例，以此类推，知道s指向NULL就停止啦（撒花）

  2. 原地头插法

void turn2(LinkList *&L){
	LinkList *p,*s;
	p = L->next;
	L->next = NULL;
	while(p!=NULL){
		s = p->next;
		p->next = L->next;
		L->next = p;
		p = s;
	}
	
}

这个就和头插法比较类似了，就不具体画图解释了；

yjr-1100
关注
专栏目录
今天小胡杨手绘28张图只为教会你单链表
m0_67403272的博客
06-21 166
———————————————————————————————————————————
数据结构——单链表多链表基本操作菜单实现(c语言)
weth的存档室
07-19 5611
本文将单链表与双向链表的基本操作在同一个程序中实现。其中单链表头文件中的函数与双向链表头文件中的函数可以分离出来单独使用。菜单程序的实现的程序较为复杂，变量多且作用范围不同，如果修改代码需要对代码非常熟悉，没有很好的做到函数的可分离。见谅！ 一、菜单功能及从属关系 注意： 1.程序设置了两个单链表节点指针和两个双向链表节点指针，但是表现给使用者的链表数同时间内最多两条，最少0条。(我写了一个函数来提示使用者创建链表的情况) 2.进行每一项操作前，程序都需要确认进行操作的是哪一条链表，本质是确认该链表的.
链表中p->next=head->next;语句解析
热门推荐
浅然的专栏
09-30 3万+
在看到一些书上或者网上写的不管是单链表还是双向循环链表等，都会有p->next=q->next;或者p-next=head->next; 这里q是尾指针，head是头指针，p是指向新建结点的指针 该语句作用 这条语句的作用其实就是给新建结点找到它该有的位置 该语句在单链表下的头插法是必须存在的，而在双向循环下可有可无1.单链表的头插法下p-next=head->next;LinkLis
简单理解C++链表结构--单链表
最新发布
denton88的博客
07-21 899
链表是一种数据结构，由若干个节点串联而成，构成一条完整的链表。可以把链表理解成为一列火车，每个节点，就是一节车厢。车厢可以装货物（存储数据），每节车厢有一个挂钩（指针），连接下一节车厢。火车头，就是链表的头节点。头节点没有数据（不装货物），实际第几个节点是从车厢开始算起。链表还可以分为单链表、双链表、循环链表。本文先介绍一下单链表。链表可以动态的存储数据，不需要一开始就把所有的空间创建出来，而且空间也不必连续。而数组则必须一开始就确定数组的大小，创建出数组的完整空间，并且空间必须是连续的。
数据结构单链表
jiyukun1的博客
02-16 218
数据结构单链表代码: 为了避免同一个头文件被包含（include）多次，C/C++中有两种宏实现方式：一种是#ifndef方式；另一种是#pragma once方式。 #pragma once //或者 #ifndef __AAAA__ #define __AAAA__ /* */ #endif #pragma once #include <stdio.h> #include &l...
单链表的定义、特点、结构及其一些基本操作
HelloWorld
10-14 1万+
一，基本运算 1，单链表，双链表的定义： 设计链式存储结构时，每个逻辑节点存储单独存储。 2，单链表的基本结构： 头节点在前，首节点在后。 3，顺序表与链表间存储密度的差异： 顺序表的存储密度为1，而链表的存储密度小于1。 4， typedef struct LNode { ElemType data; //存放元素值 struct LNode *...
数据结构——单链表实验
06-15
熟悉单链表的定义，单链表的建立方法及相关基本操作，理解单链表的基本思想，能够根据实际情况选择合适的存储结构。 2.实验内容 1、利用头插法或尾插法建立单链表 2、对已建立的单链表实现插入、删除等基本操作； 3...
数据结构——单链表.zip
09-16
本资料包"数据结构——单链表.zip"专注于单链表的实现，特别针对严蔚敏教授的数据结构教材内容进行了完整的编程实现。下面，我们将深入探讨单链表及其相关操作。 单链表是一种线性数据结构，每个元素称为节点，每个...
JAVA数据结构——单链表的操作.docx
07-11
单链表是一种基本的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用。在给定的文档中，主要介绍了如何在Java中实现单链表的操作。以下是详细的知识点解析： 1. **节点类(Node....
数据结构——单链表（C语言版）.zip
11-02
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储...
详细且图文并茂的单链表学习教程
domain.5忘初心
10-17 1323
单链表-SinglyLinkedList认识链表什么是链表？在定义中有几个关键字链表为什么这么受欢迎？常见的链表单链表单链表的操作单链表有以下基本操作1. 初始化单链表2. 销毁单链表3. 清空单链表4. 检测单链表是否为空5. 返回单链表的元素个数6. 返回单链表中指定位置元素的值7. 返回单链表中第一个与**指定值相同的元素**的位置8. 向指定位置插入元素9. 删除指定位置的元素10. 遍历...
链表的next指向理解
wcy18629063634的博客
10-20 1403
链表指向语言坑爹
LinkList *p与LinkList p区别
wh3165832165的博客
09-25 751
指针区别
数据结构 之 单链表
cyt
02-08 359
链表 动态数组是一种顺序存储元素的数据结构，其元素存放在一个连续的内存地址中，这样在查找的时候便可以直接根据首元素的地址 + 偏移量 来确定任何位置的元素。动态数组在查找的时候占据优势，但是在删除元素、指定位置添加元素的时候却要面临着移动元素的开销。 链表是一种链式存储元素的数据结构，其节点元素中存放了下一个元素的地址，这样的存储模型便完美解决了在删除和添加操作较多的场景下面使用动态数组而带来的额外开销。 单链表 单链表是最普通的链表，其每个节点由数据部分、下一个元素的指针组成，通过每个节点的next指针
单向链表的创建及p-＞next问题
weixin_74020928的博客
11-25 733
链表是C语言数据结构的难点但同时也是重点。学好它对整个思维的构建都是有帮助的！ 下面是我的一点看法，如有错误，恭请各位大佬指正。 我们都知道在C语言中有数组和链表两种可以存储多个同类型数据的工具，但是学过数组的人应该意识到数组有其局限性：数组在存储数据之前必须声明长度，以便系统为数组分配内存( 数据个数*sizeof(数据类型))，而且长度一经声明就确定，不可更改。这使增删数据，变得异常困难。 但链表不同，在使用链表之前没必要声明长度，如下表： 这只是个结构体，
为什么数据结构中Linklist p等价于LNode *p
Chauncey_Wang的博客
09-13 4337
严蔚敏老师的数据结构书里，有这么一句让人很疑惑 首先需要记住的是 int* i; int *i; 是等价的，也就是说，*的位置其实不重要， 而 typedef struct LNode{} Lnode, *Linklist 是给struct LNode{}定义了两个别称，分别是Lnode和*Linklist 可以改写为 typedef struct LNode{} Lnode; typedef struct LNode{} *Linklist; 而*的位置又是不重.
单链表分离(头插法和尾插法的结合,理解指针变换)
qq_57484399的博客
10-01 937
强调,这两步不能颠倒,我们建立链表肯定会进行这两步操作是无疑的, 但是当我们覆盖一个指针的时候,要考虑这个指针里面是否存着我们需要的信息, 插入前,L2->next 里面存放的是第一个结点 的位置, 我们还要用到, 所以要先进行这一步, 然后再把新节点的位置给 头结点的尾指针.当判断bn 后面没有结点的时候, 我们就可以结束了, 刚才我们用 q 来存放 b 断开联系后的下一个结点 ,那当bn的尾指针是NULL的时候 , 我们就可以结束了, 意思就是不用连接了, 因为 bn 断开后, 没有后继节点了.
【数据结构从菜鸟到大牛】链表（画图教你手撕单链表）
K_04_10的博客
04-30 1814
📑前言 🌝顺序表优点 之前我们学习了顺序表，其本质就是数组 了解了顺序表是有自己的优点的： 物理空间连续 下标随机访问 我只要知道了首元素的地址，就可以访问顺序表的所有的元素 😅顺序表缺点 空间不够，需要扩容。扩容就有一定的性能消耗，其次一般扩容2倍，存在一些空间浪费 头部或者中间位置插入删除的效率低下，需要挪动---O(N)，尾插尾删比较容易 ⚒️改善方案 1.按需申请释放空间 需要一个就申请一个 ，哪一个不用了我们就释放哪一个 这样开辟的是一个一个的单独独立的空间，...
【初阶数据结构】单链表(C语言实现+动图演示)
Clumsy、笨拙的博客
08-25 2055
首先我们需要对单个结点进行定义就像这个图一样，一个空间存放数据，一个空间存放下一个结点的地址单链表在逻辑上是连续的，但在物理上不一定连续，可以做到按需所取，但不支持随机访问。上述实现单链表是传的二级指针，若不想传二级指针，可以使用以下两种方法：1.使用带头结点的链表，链表没有元素时头指针指向头结点，不需要对头指针修改2. 调用函数时以返回值的形式返回头指针，让头指针在调用时赋值（非常麻烦）
多项式相加算法实现及数据结构——单链表解析
"两个多项式的相加算法-数据结构课件" 在数据结构中，多项式是一种常见的数学概念，它可以通过链表结构来有效地表示和处理。这篇课件主要讲解了如何实现两个多项式的相加算法，这个算法是基于链表的数据结构设计的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值