2. 【单链表】的基本概念 + 单链表的代码实现

已于 2022-08-07 17:16:39 修改
阅读量846 收藏 13
点赞数 6
分类专栏： 2024王道数据结构 文章标签： 链表 数据结构 算法
于 2022-08-04 21:43:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42214698/article/details/126155237
版权

文章目录

单链表的基本概念

① 单链表：用 链式存储 实现了线性结构。一个结点存储一个数据元素，各结点间的前后关系用一个指针表示。

② 特点：

	优点：不要求大片连续空间，改变容量方便。
    缺点：不可随机存取，要耗费一定空间存放指针。

③ 两种实现方式：

	【1】带头结点，写代码更方便。头结点不存储数据，头结点指向的下一个结点才存放实际数据。
	
	【2】不带头结点，麻烦。
	    对第一个数据结点与后续数据结点的处理需要用不同的代码逻辑
	    对空表和非空表的处理需要用不同的代码逻辑。


单链表的实现

1. 单链表的结构体

在这里插入图片描述

"LinkList"等价于"LNode * "前者强调这是链表，后者强调这是结点，合适的地方使用合适的名字，代码可读性更高

2. 不带/带头结点的初始化和判断是否为空：InitList(LinkList &L)、Empty(LinkList L)

不带头结点的单链表 ：

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

//初始化一个空的单链表
bool InitList(LinkList &L){
    L = NULL; //空表，暂时还没有任何结点
    return true;
}

void test(){
    LinkList L;  //声明一个指向单链表的头指针
    //初始化一个空表
    InitList(L);
    ...
}

//判断单链表是否为空
bool Empty(LinkList L){
    return (L==NULL)
}

带头结点的单链表 ：

typedef struct LNode{      
    ElemType data;      
    struct LNode *next;
}LNode, *LinkList;

// 初始化一个单链表（带头结点）
bool InitList(LinkList &L){      
    L = (LNode *)malloc(sizeof(LNode));  //分配一个头结点 
    if (L == NULL)        //内存不足，分配失败    
        return false;    
    L->next = NULL;       //头结点之后暂时还没有结点   
    return true;
}

void test(){     
    LinkList L;  //声明一个指向单链表的头指针 
    //初始化一个空表    
    InitList(L);     
    ...
}

//判断单链表是否为空
bool Empty(LinkList L){  
    if (L->next == NULL) 
        return true;     
    else             
        return false;
}


3. 求表的长度【头结点不算】：Length(LinkList L)

// 计算单链表的长度
int Length(LinkList L){      
    int len=0;       //统计表长  
    LNode *p = L;
    while(p->next != NULL){ 
        p = p->next;      
        len++;       
    }      
    return len;
}

时间复杂度： O(n)


4. 单链表的查找

在这里插入图片描述

4.1 按位查找 ：GetElem(LinkList L, int i)

typedef struct LNode{  
    ElemType data;    
    struct LNode *next;
}LNode, *LinkList;

// 查找指定位序i的结点并返回
LNode * GetElem(LinkList L, int i){   
    if(i<0)            
        return NULL;   
    LNode *p;     
    int j=0;     
    p = L;      
    while(p!=NULL && j<i){   
        p = p->next;     
        j++;      
    }        
    return p;
}

在这里插入图片描述
时间复杂度：

  • 最好时间复杂度： O(1)
  • 最坏时间复杂度： O(n)
  • 平均时间复杂度： O(n)

4.2 按值查找 ：LocateElem(LinkList L , ElemType e)

// 查找数据域为e的结点指针，否则返回NULL
LNode * LocateElem(LinkList L, ElemType e){           
    LNode *P = L->next;     
    // 从第一个结点开始查找数据域为e的结点  
    while(p!=NULL && p->data != e){   
        p = p->next;     
    }     
    return p;
}

在这里插入图片描述
时间复杂度：

  • 最好时间复杂度： O(1)
  • 最坏时间复杂度： O(n)
  • 平均时间复杂度： O(n)


5. 单链表的插入

在这里插入图片描述

5.1 指定结点的后插操作：InsertNextNode(LNode *p, ElemType e)

在这里插入图片描述

5.2 指定结点的前插操作：InsertPriorNode(LNode *p, ElemType e)

思路1：如果传入头指针，就可以循环整个链表找到指定结点p的前驱结点q，再对q进行后插操作；

bool InsertPriorNode (LinkList L, LNode *p, ElemType e)

思路2：如果不传入头指针，在指定结点p后插入一个结点s，并交换两个结点所保存的数据，从而变相实现指定结点的前插操作

typedef struct LNode{     
    ElemType data;      
    struct LNode *next;
}LNode, *LinkList;

// 在结点p前插入元素e
bool InsertPriorNode(LNode *p, ElemType e){  
    if(p==NULL)      
        return false;  
    LNode *s = (LNode *)malloc(sizeof(LNode));  
    // 内存不足分配失败       
    if(s==NULL)       
        return false;    
    // 将s插入结点p之后    
    s->next = p->next;   
    p->next = s;       
    // 交换两个结点中的数据  
    s->data = p->data;   
    p->data = e;       
    return true;
}

5.3 按位序插入：ListInsert(LinkList &L, int i, ElemType e)

在这里插入图片描述

① 带头结点

在这里插入图片描述
把前面的函数用上：
在这里插入图片描述

② 不带头结点

在这里插入图片描述


6. 单链表的删除

6.1 按位序删除 ：ListDelete(LinkList &L, int i, ElemType &e)

思路：如果传入头指针，就可以循环整个链表找到指定结点p的前驱结点q，再对p进行删除操作

typedef struct LNode{       
    ElemType data;    
    struct LNode *next;}LNode, *LinkList;

// 删除第i个结点并将其所保存的数据存入e
bool ListDelete(LinkList &L, int i, ElemType &e){      
    if(i<1)             
        return false;     
    LNode *p;       //指针p指向当前扫描到的结点     
    int j=0;        //当前p指向的是第几个结点    
    p = L;         
    //循环找到第i-1个结点     
    while(p!=NULL && j<i-1){   
        //如果i>lengh，p和p的后继结点会等于NULL        
        p = p->next;            
        j++;      
    }       
    if(p==NULL)       
        return false;    
    if(p->next == NULL)        
        return false;    	   
    //令q暂时保存被删除的结点   
    LNode *q = p->next;    
    e = q->data;     
    p->next = q->next;      
    free(q)     
    return true;
}

时间复杂度：

  • 最好时间复杂度： O(1)
  • 最坏时间复杂度： O(n)
  • 平均时间复杂度： O(n)

6.2 删除指定结点 ：DeleteNode(LNode *p)

思路：
如果不传入头指针，可以把指定结点p的后继结点q删除，
并使结点p保存结点q存储的数据，从而变相实现删除指定结点的操作。
但是 如果指定结点p没有后继结点，这么做会报错

在这里插入图片描述

// 删除指定结点p
bool DeleteNode(LNode *p){   
    if(p==NULL)           
        return false;     
    LNode *q = p->next; // 令q指向p的后继结点  
    // 如果p是最后一个结点，则q指向NULL，继续执行就会报错  
    p->data = q->data;  
    p->next = q->next;   
    free(q);    
    return true;
}

时间复杂度： O(1)


7. 单链表的建立

7.1 尾插法建立单链表 ：List_TailInsert(LinkList &L)

// 使用尾插法建立单链表L
LinkList List_TailInsert(LinkList &L){   
    int x;			//设ElemType为整型int  
    L = (LinkList)malloc(sizeof(LNode));     //建立头结点(初始化空表)     
    LNode *s, *r = L;                        //r为表尾指针    
    scanf("%d", &x);                         //输入要插入的结点的值   
    while(x!=9999){                          //输入9999表示结束     
        s = (LNode *)malloc(sizeof(LNode));    
        s->data = x;           
        r->next = s;           
        r = s;                               //r指针指向新的表尾结点     
        scanf("%d", &x);       
    }    
    r->next = NULL;                          //尾结点指针置空      
    return L;
}

时间复杂度： O(n)

7.2 头插法建立单链表 ：List_HeadInsert(LinkList &L)

LinkList List_HeadInsert(LinkList &L){       //逆向建立单链表   
    LNode *s;      
    int x;     
    L = (LinkList)malloc(sizeof(LNode));     //建立头结点   
    L->next = NULL;                          //初始为空链表,这步很关键  
    scanf("%d", &x);                         //输入要插入的结点的值  
    while(x!=9999){                          //输入9999表结束     
        s = (LNode *)malloc(sizeof(LNode)); 
        s->data = x;          
        s->next = L->next;      
        L->next = s;          
        //将新结点插入表中，L为头指针   
        scanf("%d", &x);       
    }     
    return L;
}

时间复杂度： O(n)

7.3 重难点：头插法实现链表的逆置 ——Inverse(LNode *L)

// 将链表L中的数据逆置并返回
LNode *Inverse(LinkList L){	
    LNode *p, *r;	  
    p = L->next;     //p指针指向第一个结点	  
    L->next = NULL;  //断链   
    // 依次判断p结点中的数据并采用头插法插到L链表中	
    while (p != NULL){		   
      r=p->next;
      p->next=L->next;
      L->next=p;
      p=r;      
    }	   
    return L;
}

在这里插入图片描述
具体解释详见：单链表逆置图解

你说的白是什么白_
关注
  • 6
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
订阅专栏
链表的基本概念以及java实现单链表-循环链表-双向链表
mcrwayfun，欢迎你
07-19 1640
前言 线性结构是非常简单且常用的数据结构，而线性表则是一种非常典型的线性结构。 线性表定义 线性表的数据结构 链表 单链表 单链表的定义 单链表的插入和删除 单链表的遍历，清空，判空，获取指定结点 循环链表 循环链表的定义 循环链表的插入和删除 循环链表的遍历，清空 双向链表 双向链表的定义 双向链表的插入和删除 本节代码传送门，欢迎star：https://github...
基于Java实现的单链表基本操作之链表合并.zip
04-26
下面将详细介绍单链表的概念、基本操作以及如何在Java中实现链表合并。 单链表是一种线性数据结构，每个节点包含两部分：数据域，用于存储数据；指针域，用于指向下一个节点。链表不像数组那样在内存中连续存储，...
【数据结构】——单链表超详细介绍（独家介绍，小白必看！！！）
热门推荐
yakiyakiya的博客
09-06 2万+
今天又是认真更新的一天耶！！一万字的文章，带你吃透单链表！文章内含链表的构建、链表构建时的易错点和注意事项以及链表与顺序表的区别，详细讲解到小白都能学会。
单链表（一篇带你掌握单链表）
m0_62692838的博客
11-18 1104
数据结构之单链表
[数据结构]链表之单链表（详解）
m0_63123468的博客
03-28 1万+
[数据结构]链表之单链表的详细解析
【初学数据结构】单链表
qq_62905657的博客
10-13 1010
数据结构之单链表
单链表详解
weixin_63246064的博客
01-31 3187
一、什么是链表 数据结构就是用某种结构去储存数据： 1、物理结构(数据在内存中的存储) 2、逻辑结构(由人为想象出来的) 顺序表就是逻辑和物理都连续的一种线性表。 链表就是逻辑连续，物理不一定连续的线性表。如下图，逻辑上是利用指针将其串联起来的，物理上却是杂乱的。 ...
基于Java实现的单链表基本操作之链表排.zip
最新发布
04-26
这个项目提供了Java实现单链表基本操作，包括链表排序的具体代码，可以帮助初学者深入理解链表数据结构及其操作。通过实践这些操作，可以提升对数据结构的理解，为更复杂的算法和系统设计打下坚实的基础。
基于Java实现的单链表基本操作之获取链表长度.zip
04-26
通过学习如何在Java中实现单链表，包括获取链表长度的方法，你可以更好地理解和运用数据结构，这对于编写高效且优化的代码至关重要。在实际编程中，结合实际场景选择合适的数据结构，将有助于解决各种问题。
java 实现单链表逆转详解及实例代码
08-31
2. **循环实现单链表逆转**： 循环方法通过迭代遍历链表并维护三个指针来实现逆转。`pre`指针记录当前节点的前一个节点，`cur`指针记录当前节点，`next`指针记录当前节点的下一个节点。在遍历过程中，不断更新这三...
java单链表的基本操作.zip
01-09
本资料主要涵盖了Java单链表的基本操作，包括链表的定义、创建、插入、删除、遍历等核心概念。 单链表由一系列节点组成，每个节点包含两部分：数据元素（data）和指向下一个节点的引用（next）。链表的头部是第一个...
创建一个简单的单链表
weixin_45914053的博客
05-15 1万+
数据结构创建单链表的基本操作 一、构造单链表的结构体 typedef struct LNode { ElemType data;//结点的数据域 struct LNode*next;//结点的指针域 }LNode,*LinkList;//LinkList为指针结构体LNode的指针类型 二、初始化单链表 1）、生成新结点作为头结点，用头指针L指向头结点。 2）、头结点的指针域置空。 Status InitList(LinkList& L)//创建一个空的单链表 { L = new LNode
2-2线性表-链表
欢迎来到我的博客
07-05 320
数据结构，线性表，单链表，双链表，静态链表，查找删除建立，基本操作
定义和初始化单链表并判断链表是否为空（带头结点）
qq_42500148的博客
11-08 109
【代码】定义和初始化单链表并判断链表是否为空（带头结点）
单链表的实现代码
m0_51469347的博客
10-06 774
#define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include <stdlib.h> #include <time.h> // 定义 #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef int Status; typedef int ElemType; // 定义结点结构 typedef struct Node {
单链表的实现（详细代码实现）
share
03-11 222
单链表的代码实现
Python数据结构与算法—第三大节课—第3-5课时：单链表的判空、长度、遍历与尾部添加结点的代码实现——day65
asd1103810477的博客
09-10 234
Python数据结构与算法：第3-5课时：单链表的判空、长度、遍历与尾部添加结点的代码实现 判断链表是否为空： class SingleLinkList(object): """单链表""" def __init__(self): self._head = None def is_empty(self): """判断链表是否为空""" return self._head == None 求链表长度 length： 比如，我
【数据结构】—C语言实现单链表（超详细！）
B1ue还在专注
08-02 4216
这是作者对于单链表学习历程的记录，C语言做到了单链表的实现!很详细，细节都很到位！
含头节点单链表(初始化、插入、删除、查询)
qq_42174306的博客
03-29 3472
一、单链表的创建 结点的定义 typedef struct LNode{ int data; struct LNode *next; }LNode, *LinkList; //声明一个节点可以使用 LNode *node; LinkList L; 初始化一个单链表 //初始化一个单链表(包含头节点) bool InitList(LinkList &L) { L = (LNode *) malloc(sizeof(LNode)); ...
线性表与单链表实现：按值查找与基本运算
"这篇资料是关于数据结构导论中第2章线性表的内容，特别是讲解了线性表的基本概念、特点以及在单链表上实现的基本运算，如按值查找（定位）。" 线性表是一种重要的数据结构，它由n（n>=0）个数据元素构成的有穷序列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

你说的白是什么白_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值