2.2 单链表

于 2022-03-27 20:55:24 发布
阅读量588 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48048598/article/details/123781265
版权

2.2 线性表的链式表示

1.单链表的定义

1.1 什么是单链表

​ 线性表的链式存储又称单链表，它是通过一组任意的存储单元来存储线性表中的数据元素

单链表结点结构

datanext

优点：不要求大片连续空间，改变容量方便

缺点：不可随机存取，要耗费一定空间存放指针

1.2 定义单链表
//定义单链表结点类型
struct LNode{
    //每个结点存放一个数据元素,ElemType写数据类型
    ElemType data;
    //指针指向下一结点
    struct LNode *next;
};
//为后面调用方便将struct LNode改名为LNode，LNode*改名为LinkList
typedef struct LNode LNode;
typedef struct LNode* LinkList;

//简写
//定义单链表结点类型
typedef struct LNode{
    //每个结点存放一个数据元素,ElemType写数据类型
    ElemType data;
    //指针指向下一结点
    struct LNode *next;
}LNode,*LinkList;

在强调是一个单链表时，使用LinkList

在强调是一个结点时，使用LNode*

1.3 初始化单链表
1.3.1不带头结点的单链表
//初始化一个空的单链表
bool InitList(LinkList &L){
    //空表，暂时没有任何结点，防止之前留下的脏数据
    L = NULL;
    return true;
}

void test(){
    //声明一个指向单链表的指针
    LinkList L;
    //初始化一个空表
    InitList(L);
}
1.3.2 带头结点的单链表
//初始化一个空的单链表(带头结点)
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;
    }
}

带头结点和不带头结点的区别

不带头结点：头指针指向的下一个结点是实际用于存放数据的结点

带头结点：头指针指向的是头结点，头结点不存放实际数据，头结点的下一个才会存储实际数据

2.单链表的插入和删除

2.1 插入
2.1.1 按位序插入（头结点）

ListInsert(&L,i,e)：在表L中的第i个位置上插入指定元素e

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; 
}

bool ListInsert(LinkList &L,int i,ElemType e){
    if (i<1){
        return false;
    }
    //指针p指向当前扫描到的结点
    LNode *p;
    //j用来表示当前p指向的结点
    int j = 0;
    //L指向头结点，头结点不存放数据
    p = L;
    while (p!=NULL&&j<i-1){
        p = p->next;
        j++;
    }
    //i值不合法
    if (p==NULL){
        return false;
    }
    //为插入的数据设置指针s，并开拓存储空间
    LNode *s = (LNode *)malloc(sizeof(LNode));
    //这两个顺序不能改，不然s指向的是s自己
    s->data = p->next;
    p->next = s;
    return true;
}

平均时间复杂度为O(n)

  • 按位插入（不带头结点）
//LNode为结点
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

bool ListInsert(LinkList &L,int i,ElemType e){
    if (i<1){
        return false;
    }
    if (i==1){
        LNode *s = (LNode *)malloc(sizeof(LNode));
        s->data = e;
        s->next = L;
        L = s;
        return true; 
    }
    //指针p指向当前扫描到的结点
    LNode *p;
    //j用来表示当前p指向的结点
    int j = 1;
    //L指向头结点，头结点不存放数据
    p = L;
    while (p!=NULL&&j<i-1){
        p = p->next;
        j++;
    }
    //i值不合法
    if (p==NULL){
        return false;
    }
    //为插入的数据设置指针s，并开拓存储空间
    LNode *s = (LNode *)malloc(sizeof(LNode));
    //这两个顺序不能改，不然s指向的是s自己
    s->data = p->next;
    p->next = s;
    return true;
}
2.1.2 指定结点的后插操作
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

//在p结点之后插入元素e
bool InsertNextNode(LNode *p,ElemType e){
    if (p==NULL){
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if (s==NULL){
        return false;
    }
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}
//使用时直接调用return InsertNextNode(p,e);
2.1.3 指定结点的前插操作
bool InsertPriorNode(LNode *p,ElemType e){
    if (p == NULL){
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if (s==NULL){
        return false;
    }
    s->next = p->next;
    p->next = s;
    s->data = p->data;
    p->data = e;
    return ture;
}
//时间复杂度为O(1)
2.2 删除结点
2.2.1 按位序删除（带头结点）
bool ListDelete(LinkList &L,int i,EleType &e){
    if (i<1){
        return false;
    }
    LNode *p;
    int j = 0;
    p = L;
    while (p!=0||j<i-1){
        p = p->next;
        j++;
    }
    if (p==NULL){
        return false;
    }
    if (p->next == NULL){
        return false;
    }
    //令q指向被删除的结点
    LNode *q = p->next;
    //用e返回元素的值
    e = q->data;
    //将*q结点从链中断开
    p->next = q->next;
    //释放结点存储空间
    free(q);
    return ture;
}

最坏、平均时间复杂度O(n)

最好时间复杂度：O(1)

2.2.2 指定结点的删除
bool ListDelete(LinkList &L,int i,EleType &e){
    if (i<1){
        return false;
    }
    LNode *p;
    int j = 0;
    p = L;
    while (p!=0||j<i-1){
        p = p->next;
        j++;
    }
    if (p==NULL){
        return false;
    }
    if (p->next == NULL){
        return false;
    }
    //令q指向被删除的结点
    LNode *q = p->next;
    //用e返回元素的值
    e = q->data;
    //将*q结点从链中断开
    p->next = q->next;
    //释放结点q
    free(q);
    return ture;
}

时间复杂度为O(1)

3. 单链表的查找

3.1 按位查找

GetElem(L,i)：按位查找，获取表L中第i个位置的元素的值

LNode * GetElem(Linkline L,int i){
    if (i<0){
        return NULL;
    }
    //指针p指向当前扫描到的结点
    LNode *p;
    //当前p指向的是第几个结点
    int j = 0;
    //L指向头结点，头结点是第0个结点（不存数据）
    p = L;
    //循环找到第i个结点
    while (p!=NULL&&j<i){
        p = p->next;
        j++;
    }
    return p;
}
3.2 按值查找

LocateElem(L,e)：按值查找，在表L中查找具有给定关键字值的元素

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

求表的长度

int Length(Linkline L){
    int len = 0;
    LNode *p = L;
    while (p->next != NULL){
        p = p->next;
        len++;
    }
    return len;
}

4. 单链表的建立

4.1 尾插法建立单链表
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 ture;
}

//在第i个位置插入元素e（带头结点）
bool ListInsert(LinkList &L,int i,ElemType e){
    if (i<1){
        return false;
    }
    //指针p指向当前扫描到的结点
    LNode *p;
    //当前p指向的是第几个结点
    int j = 0;
    //L指向头结点，头结点是第0个结点（不存数据）
    p = L;
    while (p!=NULL && j<i-1){
        p = p->next;
        j++;
    }
    if (p==NULL){
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}
4.2 头插法建立单链表
4.2.1 对头结点的后插操作
//对头结点的后插操作
bool InsetNextNode(LNode *p,ElemType e){
    if (p==NULL){
        return false;
    }
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if (s==NULL){
        return false;
    }
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}
weixin_48048598
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
顺序表的C++实现
wx1677967754的博客
08-08 491
顺序表的C++实现
数据结构-链表
qq_43817065的博客
03-11 173
/* 链表与顺序表的区别？ 链表--单链表还是双链表？ 链表是否带头结点？ 常规操作： 注意各个操作都有带头结点和不带头结点的两个类型 InitList（LinkList &L）初始化一个单链表-- ListInsert(LinkList &L,int i,ElemType e)在链表L的第i个位置插入元素e； InsertNextNode(LNode*p,ElemType e)在p结点后面插入元素e InsertPirorNode(LNode*p,ElemType e)在p结点前面插入.
408数据结构学习笔记——链表
JiangNan_1002的博客
03-23 1452
1.单链表 2.双链表 3.循环链表 4.循环双链表 5.链表和顺序表的区别 6.王道课后题
数据结构 第3讲 顺序表
rainchxy的博客
09-12 4216
数据结构 第3讲 顺序表 顺序表是最简单的一种线性结构，逻辑上相邻的数据在计算机内的存储位置也是相邻的，可以快速定位第几个元素，中间不允许有空，所以插入、删除时需要移动大量元素。 顺序表可以分配一段连续的存储空间Maxsize，用elem记录基地址，用length记录实际的元素个数，即顺序表的长度， 结构体的定义： 结构体定义后，如果要定义个顺序表L，就可以写： SqLis
C++ 强大的内功（链表）
qq_45743563的博客
06-09 196
大致结构 C++基础(奇牛学院) 链表是线性表的链式存储方式，逻辑上相邻的数据在计算机内的存储位置不必须相邻，那么 怎么表示逻辑上的相邻关系呢？可以给每个元素附加一个指针域，指向下一个元素的存储位 置。如图所示： 相比数组而言可以在堆上申请空间，大家都知道栈的空间是有限的 而堆的空间相对来说会大很多 数组需要的内存是连续的，如果申请过大很有可能申请不成功，在这个时候链表就产生了 结构定义： 其结构体定义： *Typedef struct LinkNode { ElemType data; struct L
实验二 单链表1
08-03
2.1 删除年龄为 18 的成员，打印链表 2.2 删除年龄为 20 的成员，打印链表 2.3 删除年龄为 15 的成员，打印链表 2.4 删除年龄为 21 的
数据结构第二章2.1-2.2
最新发布
11-23
2.2 顺序表的定义与操作 顺序表是线性表的一种具体实现，用一维数组来存储数据。它的优点是访问速度快，因为数组支持随机访问。顺序表的定义包括数组的初始化、长度的获取等。插入操作一般在末尾进行，称为append...
单链表地基本操作C语言课程设计.doc
12-05
### 2.2 插入节点 插入节点需要找到插入位置，并将新节点插入到链表中。插入操作需要考虑链表的顺序性和节点的指针域。 ### 2.3 删除节点 删除节点需要找到删除节点，并将其从链表中删除。删除操作需要考虑链表的...
Python数据结构与算法之链表定义与用法实例详解【单链表、循环链表】
12-26
本文实例讲述了Python数据结构与算法之链表...2.2 删除 空链表 链表长度为1 删除末尾元素 （3）从单链表到单链表的一众变体： 带尾节点的单链表 循环单链表 双链表 1. 链表节点的定义 class LNode: def __init__(s
数据结构2.12程序
09-18
2.12程序源码，绝对正版，注释详细
单链表的初始化代码
一个随时准备弃坑的博客
03-24 3208
①无头结点 //初始化一个空的单链表 bool InitList(LinkList &L) { L=NULL; //空表，暂时还没有任何结点（防止脏数据遗留） return true; } ②有头节点 //初始化一个空的单链表（带头结点） bool InitList(LinkList &L) { L=（LNode*)malloc(sizeof(LNode...
单向链表的节点创建和头插、尾插、任意位置插入节点的实现
Zhoujy1996的博客
06-06 2460
单向链表的节点创建和头插、尾插、任意位置插入节点的实现 今天复习了以下链表的知识，决定通过自己的理解直接手撕代码，不去参考已经写过的链表代码，在不断的调试中，总算写出来了同时发现对指针和单向链表有了更深的理解。 实现代码： //单向链表 struct Node //用结构体作为链表的节点 { Node *next; //用于存储下一个节点的地址 string data...
单链表的两种类型及其判别方式
m0_49886488的博客
02-25 1511
一、两种单链表 首先定义一个单链表结点类型： #include<stdio.h>typedef struct LNode{ ElemType data; struct LNode *next; //指针指向下一个节点。 }LNode,*LinkList; 在这个代码中我们使用typedef重命名了struct LNode型为 LNode和*LinkList。 LNode与*Linklist本质相同，但一般我们将其做如下代表： LNode* 强调所引用的为电联表上的结点。
单链表的定义
qq_36314864的博客
10-18 1131
单链表的定义 单链表：线性表的链式存储，通过一组任意的存储单元来存储线性表中的数据元素。 typedef struct LNode // 定义单链表结点类型 { ElemType data; // 数据域，每个节点存放一个数据元素 struct LNode *next; // 指针域，指针指向下一个节点 }LNode, *LinkList; // 别名 不带头结点的单链表 typedef struct LNode // 定义单链表结点类型 { ElemType data; //
数据结构—单链表的实现（c语言版）
南方硅人的博客
06-22 918
1、线性表的单链表表示 链式存储线性表时，不需要使用地址连续的存储单元，即不要求逻辑上相邻的元素在物理位置上也相邻，它通过“链”建立起来数据元素之间的逻辑关系，因此插入和删除操作不需要移动元素，而只需要修改指针，但也会失去顺序表可随机存取的优点。 2、单链表的基本操作 函数 说明 void InitList(LinkList &L); //初始化顺序表 int Length(LinkList &L); //返回当前长度； bool Empty(LinkList &am
数据结构：双向链表
cri5768的博客
09-18 149
原创：转载请注明 在前面介绍了单项链表， http://blog.itpub.net/7728585/viewspace-2125007/ 在实际的应用中双向链表应用也是非常多的，因为我本生是一名DBA，我知道的在数据库中...
c 语言数据结构系列，单链表常见操作之几种插入和删除的实现
阔码人生
02-17 2863
c 语言数据结构之单链表1，定义一个单链表1，不带头结点的单链表2，带头结点的单链表2，单链表的基本操作1，插入1，按位序插入（ListInsert(&L,i,e)）2，指定结点的后插操作（InsertNextNode(LNode *p,ElemType e)3，指定结点的前插操作（ InsertPrioNode(LNode *p,ElemType e) ）2，删除1，按位序删除（带头结点）2，指定结点的删除 1，定义一个单链表 基础定义先了解一下： struct LNode{ //定义单链表结点类
删除单链表的第i个结点
04-01
2.2 将第i-1个结点的next指针指向第i+1个结点。 3. 释放第i个结点的内存空间，完成删除操作。 代码实现如下： ``` void deleteNode(ListNode* head, int i) { ListNode* p = head; if (i == 1) { head = head...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值