单链表的定义、初始化、建立、插入、删除

已于 2024-05-23 14:57:58 修改
阅读量392 收藏 5
点赞数 11
文章标签： 数据结构 算法
于 2024-05-21 21:21:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65075140/article/details/139102163
版权

单链表的定义

//单链表的定义,数据类型重命名
typedef struct LNode{
    int data;
    struct LNode * next;
}LNode,*LinkList;
//LNode *L与LinkList L表示的意思相同，都是生命一个指向单链表首结点的指针，是等价的
//一般LNode *强调这是一个结点，LinkList强调这是一个单链表

初始化带头结点的单链表

//初始化一个空的单链表——带头结点
bool InitList(LinkList &L){
    L=(LNode *)malloc(sizeof(LNode)*1);//分配一个头结点，不存数据，只是为了方便操作
    if(L==NULL)//内存不足，分配失败
        return false;
    L->next=NULL;//置空，表示还没有任何结点的单链表，避免脏数据
    return true;
}

初始化不带头结点的单链表

//初始化一个空的单链表——不带头结点
bool InitList(LinkList &L){
    L=NULL;//置空，表示还没有任何结点的单链表，避免脏数据
    //由此，判断头指针是否为空->判断单链表是否为空
    return true;
}
//注意不带头结点的单链表处理数据结点的代码逻辑与带头结点的处理逻辑不同
//对空表和非空表的处理逻辑也不同

按位插入元素（带头结点）

//按位插入元素——带头结点
bool ListInsert(LinkList &L,int i,int e){
    //判断插入位置合法性
    if(i<1)
        return false;
    if(p==NULL)
        return false;
    LNode *p;
    p=L;
    int j=0;//这里是0，表示当前p指向的是第0个结点，即头结点。
    //寻找第i个数据元素的前一个数据元素
    while(p!=NULL&&j<i-1){//p==NULL说明此时插入位置不合法，第i-1个元素不存在
        p=p->next;
        j++;
    }
    //申请一个结点存放要插入的数据e
    LNode *s=(LNode *)malloc(sizeof(LNode)*1);
    s->data=e;
    //插入
    s->next=p->next;
    p->next=s;
    return true;
}

按位插入元素——不带头结点

//按位插入元素——不带头结点
//因为不存在”第0个“结点，要注意i=1的情况
bool ListInsert(LinkList &L,int i,int e){
    if(i<1||p==NULL)
        return false;
    if(i=1){
        //不用借助标记LNode *p；
        LNode *s=(LNode *)malloc(sizeof(LNode)*1);
        s->data=e;
        s->next=L;//注意不带头结点，L指向第一个数据元素
        return true;
    }
    LNode *p=L;
    LNode *s=(LNode *)malloc(sizeof(LNode)*1);
        s->data=e;
    //寻找第i-1个数据元素
    int j=1;//注意这里是1，表示当前p指向的是第一个结点
    while(p!=NULL&&j<i-1)
    {
        p=p->next;
        j++;
    }
    s->next=p->next;
    p->next=s;
    return true;
}

在指定结点p之后插入元素e

//在指定结点p之后插入元素e
bool InsertNextNode(LNode * p,int e){
    //判断p的合法性
    if(p==NULL)
        return false;
    LNode *s=(LNode *)malloc(sizeof(LNode)*1);
    if(s==NULL)
        return false;//分配内存失败
    s->data=e;
    s->next=p->next;
    p->next=s;
    retur true;
}

在指定结点p之前插入元素e

//在指定结点p之前插入元素e
//我们在p之后插入元素e，再将两个结点交换即可，从而在O(1)时间复杂度下解决问题
bool InsertPriorNode(LNode * p,int e){
    if(p==NULL)
        return false;
    LNode *s=(LNode *)malloc(sizeof(LNode)*1);
    s->next=p->next;
    p->next=s;
    s->data=p->data;
    p->data=e;
    return true;
}
//法二
bool InsertPriorNode(LNode * p,LNode *s){
    if(p==NULL||s==NULL)
        return false;
    s->next=p->next;
    int temp=p->data;//申请中间变量保存结点的数据部分。
    p->data=s->data;
    s->data=temp;
    return true;

}

按位序删除结点（带头结点）

//按位序删除——带头结点
//要删除的元素结点设为q，q的前一个结点为p；
bool ListDelete(LinkList &L,int i,&e)
{
    if(i<1)//结点位序从1开始
        return false;
    int j=0;//j指向当前第0个结点，即头结点
    LNode * p=L;
    //找到第i-1个数据元素
    while(P!=NULL&&j<i-1){
        p=p->next;
        j++;
    }
    if(p==NULL)//遍历到第i-1个元素发现，前驱结点p不存在
        return false;
    if(p->next=NULL)//要删除的结点q不存在。
        return false;
    LNode *q=p->next;
    e=q->data;
    p->next=q->next;
    free(q);
    return true;
}

按位序删除结点（不带头结点）

//按位序删除——不带头结点
//要删除的元素结点设为q，q的前一个结点为p；
bool ListDelete(LinkList &L,int i,&e)
{
    if(i<1)//结点位序从1开始
        return false;
    int j=1;//j指向当前第1个结点，没有头结点，与带头结点的单链表的不同
    LNode * p=L;
    //找到第i-1个数据元素
    while(P!=NULL&&j<i-1){
        p=p->next;
        j++;
    }
    if(p==NULL)//遍历到第i-1个元素发现，前驱结点p不存在
        return false;
    if(p->next=NULL)//要删除的结点q不存在。
        return false;
    LNode *q=p->next;
    e=q->data;
    p->next=q->next;
    free(q);
    return true;
}

删除指定结点

//指定结点删除,将要删除的结点和其后面的一个结点交换，删除后面的结点即可
//这个方法，如果删除的正好是最后一个结点，没有后继结点交换时，要特殊处理，不方便
bool DeleteNode(LNode *p){
    //判断合法性
    //要删除的结点不存在
    if(p==NULL)
        return false;
    //p是尾结点
    if(p->next==NULL){
        //找到p的前一个结点q并q->next=NULL
        //申请标记指针r
        LNode * r=L;
        while(r->next!=p)
            r=r->next;
        q->next=NULL;
        free(p);
        return true;
    }
    else{
        //申请指针指向p的后一个结点
    LNode *q=p->next;
    p->data=q->data;
    p->next=q->next;
    free(q);
    return true;
    }
}

单链表按位查找（带头结点）返回结点

//单链表按位查找——带头结点
//返回第i个结点 位序
LNode * GetElem(LinkList L,int i){
    if(i<1)
        return NULL;//注意返回值
    //申请指针扫描链表
    LNode *p;
    p=L;
    int j=0;//j是头结点的位置
    while(p!=NULL&&j<i){//保证遍历到第i个元素时，p指向的结点存在
        p=p->next;
        j++;
    }
    //找到第i个元素了
    return p;//遍历到第i个元素时，p指向的结点不存在的话，返回为NULL
}

单链表按位查找（不带头结点）返回结点

//单链表按位查找——不带头结点
//返回第i个结点 位序
LNode * GetElem(LinkList L,int i){
    if(i<1)
        return NULL;//注意返回值
    LNode *p;
    p=L;
    int j=1;//j是第一个结点结点的位置，和带头结点的单链表的区别
    while(p!=NULL&&j<i){
        p=p->next;
        j++;
    }
    return p;
}

单链表按值查找（带头结点）返回结点

//单链表按值查找——带头结点
//返回结点
LNode * LocateElem(LinkList L,int e){
    //指针扫描单链表
    LNode * p=L->next;//带头结点
    //单链表不是空表
    while(p->data!=e&&p!=NULL){
        p=p->next;
    }
    return p;
}

单链表按值查找（不带头结点）返回结点

//单链表按值查找——不带头结点
//返回结点
LNode * LocateElem(LinkList L,int e){
    //指针扫描单链表
    LNode * p=L;//不带头结点
    //单链表不是空表
    while(p->data!=e&&p!=NULL){
        p=p->next;
    }
    return p;
}

尾插法建立单链表（带头结点）

//尾插法建立单链表——带头结点
LNode * List_TailiInsert(LinkList &L){
    int x;//插入的元素类型为整形
    //建立头结点,初始化空表
    L=(LinkList)malloc(sizeof(LNode)*1);
    //申请新结点
    LNode *r;
    r=L;//r为表尾指针，作为标记
    scanf("输入链表元素x= %d",&x);
    while(x!=9999){
        //申请结点加入链表；
        LNode *p=(LNode *)malloc(sizeof(LNode)*1);
        p->data=x;
        p->next=r->next;
        r-next=s;
        r=s;//r作为表尾指针向后挪
        scanf("输链表元素x= %d",&x);
    }
    r->next=NULL;
    return L;
}

尾插法建立单链表（不带头结点）

//尾插法建立单链表——不带头结点
LNode * List_TailiInsert(LinkList &L){
    int x;//插入的元素类型为整形
    //不用建立头结点
    //申请新结点
    LNode *r;
    r=L;//r为表尾指针，作为标记
    scanf("输入链表元素x= %d",&x);
    while(x!=9999){//如果输入9999代表单链表建立结束
        //申请结点加入链表；
        LNode *p=(LNode *)malloc(sizeof(LNode)*1);
        p->data=x;
        p->next=r->next;
        r-next=s;
        r=s;//r作为表尾指针向后挪
        scanf("输链表元素x= %d",&x);
    }
    r->next=NULL;
    return L;
}

尾插法建立单链表的后插思路

bool LinkInsert(LinkList &L,int i,int e){
    if(i<1)
        return false;
    LNode *p//表示当前扫描到的结点
    int j=0//有头结点，无头结点的时候j=1
    p=L;
    while(P!=NULL&&j<i-1){
        p=p->next;
        j++;
    }
    if(p==NULL)//i值不合法，找到位置i时，指针p超过表长了
        return false;
    LNode *s=(LNode *)malloc(sizeof(LNode)*1);
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;
}

头插法建立单链表（带头结点）

//头插法建立单链表——带头结点
//带头结点的单链表——对头结点的尾插操作(逆向建立单链表)
LNode * List_HeadInsert(LinkList &L){
    int x;//插入元素类型为整形
    //建立头结点
    LNode * L=(LNode *)malloc (sizeof(LNode)*1);
    L->next=NULL;//初始化为空链表，是一个习惯，防止脏数据
    scanf("输入元素x= ",&x);
    //开始循环输入元素值
    while(x!=9999){
        //申请新结点
        LNode *s=(LNode *)malloc(sizeof(LNode));
        s->data=x;
        s->next=L->next;
        L->next=s;
        //继续输入元素
        scanf("输入元素x= ",&x);
    }
    return L;
}

头插法建立单链表（不带头结点）

//头插法建立单链表——不带头结点
LNode * List_HeadInsert(LinkList &L){
    int x;//插入元素类型为整形
    //建立头结点
    //LNode * L=(LNode *)malloc (sizeof(LNode)*1);
    //L->next=NULL;//初始化为空链表，是一个习惯，防止脏数据
    scanf("输入元素x= ",&x);
    //开始循环输入元素值
    while(x!=9999){
        //申请新结点
        LNode *s=(LNode *)malloc(sizeof(LNode));
        s->data=x;
        s->next=L->next;
        L->next=s;
        //继续输入元素
        scanf("输入元素x= ",&x);
    }
    return L;
}

加油！

pumkinnnan
关注
  • 11
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
C语言-数据结构-单链表的初始化，插入和输出
w_nxsxs的博客
10-31 5539
【问题描述】 设有头结点单链表，实现单链表的初始化、插入和输出算法。 【输入形式】 第一行输入一个N（N大于等于1，小于1000），一个M（N大于等于1，小于1000）； 第二行输入N个整数，以空格作为分隔，创建长度为N的单链表； 接着输入M组数据：pos和e，以空格分隔，分别表示插入位置和插入元素的值。 【输出形式】 若插入成功，输出yes；若插入不成功，输出error。 最后输出单链表所有元素（以空格分隔）。 【样例输入1】 5 3 -4 5 2 7 0 2 100 ...
数据结构单链表插入、删除和修改实验报告
09-09
初始化状态：单链表可以不为空集；操作结果：插入一个空的单链表L。 　（2）decelt 　操作结果：删除已有的单链表的某些结点。 （3）display 　操作结果：将上述输入的元素进行排列显示。 　（4）modify 　操作结果...
02 单链表的初始化、插入、删除
qq_59524897的博客
01-07 189
02 单链表的初始化、插入、删除
【单链表】初始化、插入、删除、查找
qq_52639249的博客
06-01 1690
单链表基本操作
单链表定义初始化 c语言,循环单链表定义初始化及创建（C语言）
weixin_29041443的博客
05-21 1095
#include #include/*** 含头节点循环单链表定义，初始化 及创建*/#define OK 1;#define ERROR 0;//函数返回类型，表示函数运行结果的状态typedef intStatus;//定义数据元素类型typedef charElemType;//循环单链表定义typedef structLoopLnode {ElemType data;//数据域，这里是ch...
单链表的初始化 建立 插入 查找 删除（转自newwy）
weixin_30632899的博客
12-21 241
//////////////////////////////////////////// //单链表的初始化，建立，插入，查找，删除。// //Author:Wang Yong // //Date: 2010.8.19 // //////////////////////////////...
含头节点单链表(初始化、插入、删除、查询)
qq_42174306的博客
03-29 3437
一、单链表的创建 结点的定义 typedef struct LNode{ int data; struct LNode *next; }LNode, *LinkList; //声明一个节点可以使用 LNode *node; LinkList L; 初始化一个单链表 //初始化一个单链表(包含头节点) bool InitList(LinkList &L) { L = (LNode *) malloc(sizeof(LNode)); ...
数据结构——单链表的初始化、建立、插入、删除
热门推荐
TSY_1222的博客
09-25 1万+
目录 1、单链表初始化 2、建立单链表 3、单链表的插入运算 4、单链表的删除运算 线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素（这组存储单元可连续、也可不连续）。 链表优点 链表缺点 1、不要求占用连续的存储空间，可动态进行分配。 2、插入和删除操作效率高，不需要移动元素。 1、不能随意访问任一元素。...
单链表的初始化、插入、删除、查找
qq_28397005的博客
04-20 1247
单链表的存储结构描述 typedef struct LNode { int data; struct LNode *next; }LNode,*LinkList; LNode为结点的类型，LinkList为指向LNode节点类型的指针类型。定义一个LinkList类型的变量 L，作为单链表的头指针，若L==NULL，表长为0，即为空表单链表的初始化 LNode *LinkListI
数据结构链表的初始化插入删除_数据结构——单链表讲解
weixin_39836803的博客
10-22 248
单链表单链表的创建分为头插入法和尾插入法两种，两者并无本质上的不同，都是利用指针指向下一个结点元素的方式进行逐个创建，只不过使用头插入法最终得到的结果是逆序的。1.单链表概念&设计单链表是一种链式存取的数据结构，，链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列...
单链表的初始化，建立，插入，查找，删除。
YIU
04-20 1万+
//单链表的初始化，建立，插入，查找，删除。 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef int ElemType; //////////////////////////////////////////// //定义结点类型 typedef struct Node { ElemType...
链表的基本操作，包括插入数据和删除数据
10-28
关于c语言中链表的基本操作，有删除和插入2种
建立学生信息无头结点单链表C语言版.pdf
06-10
"建立学生信息无头结点单链表C语言版" 本文档介绍了使用 C ...本文档介绍了使用 C 语言建立学生信息无头结点单链表的实现，包括单链表的定义、初始化、销毁、清空、判空、长度、元素访问、前驱、后驱和插入等操作。
数据结构单链表实验报告实用文档.doc
11-30
1. 初始化链表：在init_linklist函数中，我们申请了一个结点的空间，并将其next域置为空，表示链表为空。 2. 创建链表：在CreateFromHead函数中，我们使用尾插法创建链表，我们不断输入元素值，直到输入“$”时，...
Python单链表原理与实现方法详解
01-20
本文实例讲述了Python单链表原理与实现方法。分享给大家供大家参考，具体如下： Python实现单链表 关于链表 链表（Linked List）是由许多相同数据类型的数据项按照特定顺序排列而成的...初始化值为None class Node
排序---归并排序（简单优化前后比较）
sunshine350的博客
06-08 301
简单优化
如何使用Python中的collections模块提供的数据结构，如deque、Counter、OrderedDict等
2402_84885073的博客
06-09 445
Python 的模块提供了一些额外的数据结构，这些数据结构在内置的数据类型（如列表、字典、集合等）的基础上，增加了额外的功能或优化了性能。下面是如何使用模块中的dequeCounter和这三种数据结构的简单示例。
数据结构02 队列及其应用【C++实现】
bigbigli的博客
06-14 293
队列是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，前端一般叫做队头，后端叫队尾。队列就像学校做操站队一样，来的人一个一个往后站，走的时候从前往后一个一个走。
[C++][数据结构][AVL树]详细讲解
最新发布
SnowK博客
06-16 1321
[C++][数据结构][AVL树]详细讲解
用C++代码写单链表的初始化、插入、输出以及倒置
04-29
以下是使用 C 代码实现单链表的初始化、插入、输出以及倒置的示例： ```c #include #include // 定义单链表节点结构体 typedef struct Node { int data; struct Node *next; } Node; // 初始化单链表 Node *...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

pumkinnnan

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

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

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

打赏作者

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

抵扣说明：

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

余额充值