单链表 基本操作

已于 2024-04-02 10:03:49 修改
阅读量323 收藏
点赞数 8
文章标签： 数据结构
于 2024-04-02 09:57:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73959411/article/details/137258206
版权

目录

初始化

求表长

按序号查找结点

按值查找结点

插入结点（后插）

插入结点（前插）

删除结点（直接删除）

删除结点（间接删除）

头插法建立单链表

尾插法建立单链表

打印单链表

 总代码

测试样例 

初始化
//单链表
typedef int ElemType;
typedef struct LNode{       //这时这个LNode 不能省略，因为在结构体中有结构体指针
    ElemType data;         //数据域
    struct LNode *next;   // 指针域
}LNode,*LinkList;

//单链表初始化
bool InitList(LinkList &L)
{
    L = (LNode*)malloc(sizeof(LNode));
    L->next=NULL;
    return true;
}
求表长
//求表长
int LengthList(LinkList L)
{
    int len=0;
    LNode *p = L->next;
    while(p!=NULL)
    {
        p=p->next;
        len++;
    }
    return len;
}
按序号查找结点
//按序号查找结点
LNode *GetElem(LinkList L,int i)  //头结点代表第 0 个结点
{
    int j=0;
    LNode *p = L;
    while(p!=NULL && j<i)
    {
        p=p->next;
        j++;
    }
    return p;
}
按值查找结点
//按值查找表结点
LNode *LocateElem(LinkList L,ElemType e)
{
    LNode *p=L->next;                    //因为头结点中没有值，所以不用找，直接从L—>next 开始遍历
    while(p!=NULL && p->data != e)
    {
        p=p->next;
    }
    return p;
}
插入结点（后插）
// 链表中插入结点 ,这是后插操作
bool ListInsert1(LinkList &L,int i,ElemType e)
{
    LNode *p=L;
    int j=0;
    while(p!=NULL && j<i-1)
    {
        p=p->next;
        j++;
    }
    if(p==NULL)                   //判断i的合法性
    {
        return false;
    }
    LNode *s = (LNode*)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}
插入结点（前插）
// 链表中插入结点 ,这是前插操作
bool ListInsert2(LinkList &L,int i,ElemType e)
{
    LNode *p=L;
    int j=0;
    while(p!=NULL && j<i)
    {
        p=p->next;
        j++;
    }
    if(p==NULL)                   //判断i的合法性
    {
        return false;
    }
    LNode *s = (LNode*)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    int temp = p->data;
    p->data =  s->data;
    s->data = temp;
    return true;
}
删除结点（直接删除）
//链表中删除结点
//修改前驱结点的指针域，使其指向要删除元素的后继结点，再把要删元素所占用的空间free掉
bool ListDelete1(LinkList &L,int i,ElemType e)
{
    LNode *p = L;
    int j=0;
    while(p!=NULL && j<i-1)
    {
        p=p->next;
        j++;
    }
    if(p == NULL || p->next == NULL )      //p->next的意思是 最后一个位置的后面一个位置没有东西的怎么删
    {
        return false;
    }
    LNode *q = p->next;
    e=q->data;
    p->next = q->next;
    free(q);
    return true;
}
删除结点（间接删除）

要删结点和其后继结点的数据域交换，而后修改指针的值，最后free后继结点

//链表中删除结点
//可以将要删除结点的后继结点赋值给该结点，而后将后继结点free掉就可以
bool ListDelete2(LinkList &L,int i,ElemType e)
{
    LNode *p = L;
    int j=0;
    while(p!=NULL && j<i)
    {
        p=p->next;
        j++;
    }
    if(p == NULL)
    {
        return false;
    }
    LNode *q = p->next;
    e=p->data;
    p->data = q->data;
    p->next = q->next;
    free(q);
    return true;
}
头插法建立单链表
//头插法新建单链表
LinkList List_HeadInsert(LinkList &L)
{
    LNode *s;
    int x;
    L = (LNode*) malloc(sizeof(LNode));
    L->next = NULL;
    scanf("%d",&x);
    while(x!=9999)
    {
        s=(LNode*) malloc(sizeof (LNode));
        s->data = x;
        s->next = L->next;
        L->next = s;
        scanf("%d",&x);
    }
    return L;
}
尾插法建立单链表

需要一个尾指针不断指向当前位置（即尾结点）

//尾插法新建单链表   必须增加一个尾指针，记录上一个插入节点的位置
LinkList List_TailInsert(LinkList &L)
{
    LNode *s;
    int x;
    L= (LNode*) malloc(sizeof(LNode));
    LNode *r = L;
    L->next = NULL;
    scanf("%d",&x);
    while(x!=9999)
    {
        s=(LNode*) malloc(sizeof(LNode));
        s->data = x;
        r->next =s;
        r=s;
        scanf("%d",&x);
    }
    r->next = NULL;
    return L;
}
打印单链表
//打印单链表
void print(LinkList L)
{
    LNode *s = L;
    while(s->next != NULL)
    {
        s =s->next;
        printf("%d ",s->data);
    }
    printf("\n");
}
 总代码
#include <stdio.h>
#include <stdlib.h>

//单链表
typedef int ElemType;
typedef struct LNode{       //这时这个LNode 不能省略，因为在结构体中有结构体指针
    ElemType data;         //数据域
    struct LNode *next;   // 指针域
}LNode,*LinkList;

//单链表初始化
bool InitList(LinkList &L)
{
    L = (LNode*)malloc(sizeof(LNode));
    L->next=NULL;
    return true;
}

//求表长
int LengthList(LinkList L)
{
    int len=0;
    LNode *p = L->next;
    while(p!=NULL)
    {
        p=p->next;
        len++;
    }
    return len;
}

//按序号查找结点
LNode *GetElem(LinkList L,int i)  //头结点代表第 0 个结点
{
    int j=0;
    LNode *p = L;
    while(p!=NULL && j<i)
    {
        p=p->next;
        j++;
    }
    return p;
}

//按值查找表结点
LNode *LocateElem(LinkList L,ElemType e)
{
    LNode *p=L->next;                    //因为tnd 头结点中没有值，所以不用找，直接从L—>next 开始遍历
    while(p!=NULL && p->data != e)
    {
        p=p->next;
    }
    return p;
}

// 链表中插入结点 ,这是后插操作
bool ListInsert1(LinkList &L,int i,ElemType e)
{
    LNode *p=L;
    int j=0;
    while(p!=NULL && j<i-1)
    {
        p=p->next;
        j++;
    }
    if(p==NULL)                   //判断i的合法性
    {
        return false;
    }
    LNode *s = (LNode*)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}
// 链表中插入结点 ,这是前插操作
bool ListInsert2(LinkList &L,int i,ElemType e)
{
    LNode *p=L;
    int j=0;
    while(p!=NULL && j<i)
    {
        p=p->next;
        j++;
    }
    if(p==NULL)                   //判断i的合法性
    {
        return false;
    }
    LNode *s = (LNode*)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    int temp = p->data;
    p->data =  s->data;
    s->data = temp;
    return true;
}

//链表中删除结点
//修改前驱结点的指针域，使其指向要删除元素的后继结点，再把要删元素所占用的空间free掉
bool ListDelete1(LinkList &L,int i,ElemType e)
{
    LNode *p = L;
    int j=0;
    while(p!=NULL && j<i-1)
    {
        p=p->next;
        j++;
    }
    if(p == NULL || p->next == NULL )      //p->next的意思是 最后一个位置的后面一个位置没有东西的怎么删
    {
        return false;
    }
    LNode *q = p->next;
    e=q->data;
    p->next = q->next;
    free(q);
    return true;
}
//链表中删除结点
//可以将要删除结点的后继结点赋值给该结点，而后将后继结点free掉就可以
bool ListDelete2(LinkList &L,int i,ElemType e)
{
    LNode *p = L;
    int j=0;
    while(p!=NULL && j<i)
    {
        p=p->next;
        j++;
    }
    if(p == NULL)
    {
        return false;
    }
    LNode *q = p->next;
    e=p->data;
    p->data = q->data;
    p->next = q->next;
    free(q);
    return true;
}

//头插法新建单链表
LinkList List_HeadInsert(LinkList &L)
{
    LNode *s;
    int x;
    L = (LNode*) malloc(sizeof(LNode));
    L->next = NULL;
    scanf("%d",&x);
    while(x!=9999)
    {
        s=(LNode*) malloc(sizeof (LNode));
        s->data = x;
        s->next = L->next;
        L->next = s;
        scanf("%d",&x);
    }
    return L;
}

//尾插法新建单链表   必须增加一个尾指针，记录上一个插入节点的位置
LinkList List_TailInsert(LinkList &L)
{
    LNode *s;
    int x;
    L= (LNode*) malloc(sizeof(LNode));
    LNode *r = L;
    L->next = NULL;
    scanf("%d",&x);
    while(x!=9999)
    {
        s=(LNode*) malloc(sizeof(LNode));
        s->data = x;
        r->next =s;
        r=s;
        scanf("%d",&x);
    }
    r->next = NULL;
    return L;
}

//打印单链表
void print(LinkList L)
{
    LNode *s = L;
    while(s->next != NULL)
    {
        s =s->next;
        printf("%d ",s->data);
    }
    printf("\n");
}
int main() {
    LinkList L;
    List_TailInsert(L);
    print(L);
    ListInsert1(L,3,8);
    print(L);
    return 0;
}

//7 8 2 5 6 9999
测试样例 

9999 表示结束

注：本文仅个人笔记，欢迎讨论交流

向前滴滴
关注
  • 8
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构-单链表基本操作-C语言代码
suxiaorui的博客
01-22 6万+
单链表基本操作 1.头插法建立单链表 2.尾插法建立单链表 3.查找结点 3.修改结点 4.插入结点 5.删除结点 本篇只有c语言代码，具体思路讲解请看这篇博客：数据结构-线性结构-单链表 1.头插法建立单链表 #include<stdio.h> #include<stdlib.h> //单链表的结构定义 typedef struct LNode { int data...
单链表基本操作.rar
04-01
这个压缩包文件“单链表基本操作.rar”包含了一个名为“单链表基本操作.docx”的文档，我们可以从中学习到关于单链表的各种核心概念和操作。 单链表是由一系列节点构成的线性数据结构，每个节点包含两部分：数据域...
单链表的操作
2301_80001547的博客
03-12 662
链表是一种线性存储结构，是一种物理上的非连续的通过链表中的指针链接顺序的存储结构。链表的特点：链表是由一系列节点（元素）所构成，创建节点是需要动态（malloc）开辟空间。每个节点包含两个部分：1、数据域（用来存储元素的数据域）2、指针域（用来存储下一个节点的地址的指针域）本文仅仅简单介绍了链表，我是初学者如有错误或指点请联系我。
单链表的查找(按值查找、按位查找)(数据结构与算法)
AII_IIA的博客
11-03 4482
什么是单链表？单链表是一种常见的链式数据结构，用于存储和操作数据元素的集合。它由一系列的节点组成，每个节点包含两个部分：数据域和指针域。单链表的每个节点包含了存储数据的数据域，以及指向下一个节点的指针域。通过这些指针域，节点之间可以按顺序连接起来，形成一个链式结构。链表的最后一个节点通常指向一个特殊的空节点（NULL或nullptr），表示链表的结束。相比于数组，链表的一大优势是它的动态性。在链表中，节点的添加、删除可以通过修改指针的指向来完成，不需要像数组那样进行元素的移动。
单链表的基本操作
热门推荐
meng_lemon的博客
08-25 2万+
链表：一种链式存储的线性表，用一组地址任意的存储单元存放线性表的数据元素，称为存储单元为一个节点。 单链表的存储结构 typedef int DataType; typedef struct ListNode { DataType _data; //当前节点中所保存的元素 struct ListNode* _pNext; //指向...
单链表基本操作
Sti1lWater的博客
12-24 1万+
单链表的基本操作
c语言单链表基本操作
qq_59328991的博客
08-16 635
单链表基本操作
PTA-单链表基本操作
qq_62931246的博客
09-11 3073
请编写程序实现单链表插入、删除结点等基本算法。给定一个单链表和一系列插入、删除结点的操作序列，输出实施上述操作后的链表。单链表数据域值为整数。
基于Java实现的单链表基本操作之链表排.zip
04-26
在这个基于Java实现的单链表基本操作项目中，我们主要关注的是链表的排序。下面将详细讲解单链表的基本概念、Java中如何实现单链表以及如何进行链表排序。 **一、单链表的基本概念** 单链表是由一系列节点组成的...
基于Java实现的单链表基本操作之链表合并.zip
04-26
本项目聚焦于Java实现的单链表基本操作，特别是链表的合并这一关键操作。下面将详细介绍单链表的概念、基本操作以及如何在Java中实现链表合并。 单链表是一种线性数据结构，每个节点包含两部分：数据域，用于存储...
数据结构--二叉树和堆
binhyun的博客
07-07 835
1.基本概念 2.树的遍历方法 3.满二叉树&&完全二叉树 4.逻辑结构&&物理结构 5.推理公式 6.二叉树应用--堆 7.简单实现堆
数据结构第14节 加权图
hummhumm的专栏
07-07 1309
( V ) 是顶点的集合。( E ) 是边的集合，每条边连接 ( V ) 中的一对顶点。( W ) 是一个函数，将每条边映射到一个实数上，即 ( W: E \rightarrow \mathbb{R} )。
[数据结构] 基于插入的排序 插入排序&希尔排序
水墨不写bug
07-06 1146
插入排序&&希尔排序 实现原理
D1.排序
2302_79232710的博客
07-07 191
快速排序和归并排序
6、Redis系统-数据结构-03-压缩列表
qq_29434541的博客
07-07 1803
由于压缩列表需要进行空间扩展操作，这就需要重新分配内存，因此连锁更新一旦发生，会导致压缩列表占用的内存空间多次重新分配，直接影响到压缩列表的访问性能。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。而当新插入的元素较大时，可能会导致后续元素的。
【排序 - 堆排序】
最新发布
2302_80393814的博客
07-10 295
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
(三)前端javascript中的数据结构之链表上
峰会路转的博客
07-08 301
在js中，没有为我们提供原生的数据结构支持的，但是在java中是有提供的。所以需要我们去模拟这种结构实现。链表中最关键的一个元素，就是头节点，头节点不存储数据，指向第一个节点链表中几乎所有的操作都要从头结点开始。
数据结构--单链表实现
LH__1314的博客
07-05 1412
链表和顺序表都是线性表的一种，但是顺序表在物理结构和逻辑结构上都是连续的，但链表在逻辑结构上是连续的，而在物理结构上不一定连续；来看以下图片来认识链表与顺序表的差别这里以动态顺序表为例，和链表中的单链表对比一下动态顺序表单链表这里就可以很清晰的看到顺序表的底层其实就是一个数组，数据的是连续存储的（顺序表物理结构连续）；而链表它每一个数据都不是连续的（链表物理结构上不一定连续）。链表节点通过观察上图，我们会发现链表每一个节点都存放在数据和下一个节点的地址。
单链表基本操作的实现
09-29
单链表的基本操作包括单链表的初始化、判断空链表、销毁、清空以及求表长等操作。在单链表的初始化中，我们生成一个只有头指针的单链表，并将其指向的头结点的指针域置空。判断单链表是否为空表时，我们可以通过判断头结点的指针域是否为空来确定。 以下是单链表基本操作的实现代码： ```c /* 初始化链式线性表 */ Status IniList(LinkList *L) { *L = (LinkList)malloc(sizeof(Node)); /* 产生头结点，并使L指向此头结点 */ (*L)->next = NULL; /* 指针域为空 */ return OK; } /* 判断单链表是否为空表 */ Status IsEmpty(LinkList L) { return L->next == NULL ? OK : ERROR; } /* 销毁单链表 */ Status DestroyList(LinkList *L) { LinkList p, q; p = *L; while (p) { q = p->next; free(p); p = q; } *L = NULL; return OK; } /* 清空单链表 */ Status ClearList(LinkList L) { LinkList p, q; p = L->next; while (p) { q = p->next; free(p); p = q; } L->next = NULL; return OK; } /* 求单链表的长度 */ int Length(LinkList L) { int len = 0; LinkList p = L->next; while (p) { len++; p = p->next; } return len; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值