线性表之单链表（C++/C）

最新推荐文章于 2022-12-03 00:22:06 发布
最新推荐文章于 2022-12-03 00:22:06 发布
阅读量250 收藏 3
点赞数 1
分类专栏： C++/C 数据结构与算法 文章标签： 数据结构 算法
JangKeo
本文链接：https://blog.csdn.net/weixin_40924974/article/details/109014265
版权

线性表之单链表（C++/C）

1 基本操作

声明部分：


#include <cstdlib>
#include "stdio.h"

#define ElemType int

typedef struct LNode{
    ElemType data;
    struct LNode *next;

}LNode,*LinkList;
1.//初始化单链表
//不带头结点的单链表
bool InitList(LinkList &L)
//初始化单链表
//***带**头结点的单链表
bool InitListWithHead(LinkList &L)
//后插操作： 在p节点之后插入元素
bool InsertNextNode(LNode*p,ElemType e)
//前插操作 在p节点之前插入e
bool InsertPriorNode(LNode*p,ElemType e)
// 删除节点p的方法1  时间复杂度为O(n)
bool DeleteNode(LNode *p)
//删除节点p的方法2 时间复杂度为O(1) 原理 ：你想删除我节点p,我把q节点的东西都拿来了（继承） 你去删q吧 其中 q为p的下一节点
bool DeleteNodePlus(LNode *p)
//按位查找
LNode *GetElem(LinkList L,int i)
//求表长
int ListLength(LinkList L)
//在第i个位置插入元素e  带头结点   尾插法
bool ListInsetWithHead(LinkList &L,int i,ElemType e)
//按位序插入 不带头结点
bool ListInset(LinkList &L,int i,ElemType e)
//按位序删除 带头节点
bool ListDeleteWithHead(LinkList &L,int i,ElemType &e)
//尾插法建立单链表  用户输入
LinkList List_TailInsert(LinkList &L)
//判断单链表是否为空
bool isEmpty(LinkList L)
//头插法 每次都插在头结点之后
//后插操作：在p接待之后 插入元素e
LinkList List_HeadInsert(LinkList &L)
void LinkListShow(LinkList L)

2.特别说明

//前插操作 在p节点之前插入e
bool InsertPriorNode(LNode*p,ElemType e)

在该函数中：特别说明如下：

 

3.主函数

int main(){
    LinkList L;
    ElemType e;
    InitList(L);
    List_HeadInsert(L);
    printf("The length of the LinkList is %d\n",ListLength(L));
    LinkListShow(L);
    if (ListDeleteWithHead(L,3,e))
        printf("The Node which was delete is %d\n",e);
    else
        printf("Fail to delete Node ");
    LinkListShow(L);
    if(ListInset(L,2,8))
        printf("Insert position 2 successfully \n");
    else
        printf("Fail to insert ！\n");
    LinkListShow(L);

    return  0;
}

4.运行结果

5.源代码 


#include <cstdlib>
#include "stdio.h"

#define ElemType int

typedef struct LNode{
    ElemType data;
    struct LNode *next;

}LNode,*LinkList;

//初始化单链表
//不带头结点的单链表
bool InitList(LinkList &L){
    L=NULL;
    return true;
}

//初始化单链表
//***带**头结点的单链表
bool InitListWithHead(LinkList &L){
    L=(LNode*)malloc(sizeof(LNode)); //分配一个头结点
    if (L==NULL)
        return false;
    L->next=NULL;
    return true;  //头结点之后 暂时还没有节点
}

//后插操作： 在p节点之后插入元素
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;  //将s节点连接到p之后
    return true;
}

//前插操作 在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->next=p->next;     //此处应该这么理解： 1.首先 ‘=’ 既可以理解为赋值 ***也可以理解为 ‘指向’  原本是p-->下一个节点q 此时虽然称为前插法 但是 但是 我们依旧把s节点放在中间;
                         //原本你p的next是要指向q的  现在我毕竟插入了一个s 那我就用s的next 指向 p->next 即下一个节点 q;
    p->next=s;           //注意 我们确实声明 并且给了s节点内存空间 但是 它里面的值 依旧是不确定的 你可以理解为NULL； 既然上一步 你把p->next赋值给了别人 那么我就将s赋值给p->next 就是让p->next你下一次 指向s;
    s->data=p->data;     //原来即便s.data中有一个不确定的值 那那那 我就把p里面的值 给你s节点  这样 s就把 p节点的所有东西给继承过来了；
    p->data=e;           //反正 一开始我e就没赋值给过其他人 现在反正你p->data的值都给 s了 那 e就给p节点的data  有感情  --那味了！
                        //如此看来 是不是 有点像 s 和p 节点互换了位置 此称为前插法
    return true;
}

// 删除节点p的方法1  时间复杂度为O(n)
bool DeleteNode(LNode *p){
    if (p==NULL)
        return false;
//    if (p->next==NULL)
//        return false;
    LNode *q=p->next; //令q指向被删除的节点
    p->next=q->next; //将*q节点从链中断开
    free(q);
    return true;
}
//删除节点p的方法2 时间复杂度为O(1) 原理 ：你想删除我节点p,我把q节点的东西都拿来了（继承） 你去删q吧 其中 q为p的下一节点
bool DeleteNodePlus(LNode *p){
    if (p==NULL)
        return false;
    LNode *q=p->next; //令q指向被删除的节点
    p->data=p->next->data; //和后继节点交换数据域
    p->next=q->next; //将*q节点从链中断开
    free(q);
    return true;

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

    }
    return p;
}

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

//在第i个位置插入元素e  带头结点   尾插法
bool ListInsetWithHead(LinkList &L,int i,ElemType e){
    if (i<1){
        return false;
    }
    LNode *p;  //指针p指向当前扫描到的节点
    int j=0;  //当前p指向的是第几个节点
    p=L;      //L指向头节点 头结点是第0个节点 不存数据
    while (p!=NULL&&j<i-1){  //循环找不到第i-1个节点
        p=p->next;
        j++;

    }
    return InsertNextNode(p,e);
}
//按位序插入 不带头结点
bool ListInset(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;
    }
    LNode *p;  //指针p指向当前扫描到的节点
    int j=0;  //当前p指向的是第几个节点
    p=L;      //L指向头节点 头结点是第0个节点 不存数据
    while (p!=NULL&&j<i-1){  //循环找不到第i-1个节点
        p=p->next;
        j++;

    }
    return InsertNextNode(p,e);
}
//按位序删除 带头节点
bool ListDeleteWithHead(LinkList &L,int i,ElemType &e){
    if (i<1)
        return false;
    LNode *p;
    int j=0;
    p=L;  //L指向头结点  头结点是第0个节点 不存数据
    while (p!=NULL&j<i-1){
        p=p->next;
        j++;
    }
    if (p==NULL)
        return false;
    if (p->next==NULL)
        return false;
    LNode *q=p->next; //令q指向被删除的节点
    e=q->data;
    p->next=q->next; //将*q节点从链中断开
    free(q);
    return true;
}

//尾插法建立单链表  用户输入
LinkList List_TailInsert(LinkList &L){
    ElemType x;
    L=(LinkList)malloc(sizeof(LNode));  //建立头结点
    LNode*s,*r=L;                       //r为表位指针
    scanf("%d",&x);
    while (x!='#'){
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        r->next=s;
        r=s;                             //r指向新的表尾节点  r让其永远指向最后一个节点
        scanf("%d",&x);
    }
    r->next=NULL;                       //尾节点r指针置空
    return L;
}


//判断单链表是否为空
bool isEmpty(LinkList L){
    if (L==NULL)
        return true;
    else
        return false;
}
//头插法 每次都插在头结点之后
//后插操作：在p接待之后 插入元素e
LinkList List_HeadInsert(LinkList &L){
    ElemType x;
    L=(LinkList)malloc(sizeof(LNode));  //建立头结点
    LNode*s;
    L->next=NULL;

    scanf("%d",&x);
    while (x!=9999){
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        s->next=L->next;
        L->next=s;     //将新节点插入表中 L为头指针
        scanf("%d",&x);
    }

    return L;


}
void LinkListShow(LinkList L){
    if (!L)
        printf("The LinkList is Null !");
    else
    {
        printf("The data of the LinkList are\n");
        LNode *p=L->next;
        while (p) {
            printf("%d  ", p->data);
            p = p->next;
        }
        printf("\n");
    }
}








int main(){
    LinkList L;
    ElemType e;
    InitList(L);
    List_HeadInsert(L);
    printf("The length of the LinkList is %d\n",ListLength(L));
    LinkListShow(L);
    if (ListDeleteWithHead(L,3,e))
        printf("The Node which was delete is %d\n",e);
    else
        printf("Fail to delete Node ");
    LinkListShow(L);
    if(ListInset(L,2,8))
        printf("Insert position 2 successfully \n");
    else
        printf("Fail to insert ！\n");
    LinkListShow(L);

    return  0;
}

 

linszjava@gmail.com
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构 线性表 实验代码 C++ 数组
11-16
数据结构 线性表 实验代码 C++ 数组 hust 赵明
guofu11111111111111.rar_单链表_单链表 c语言_线性链表程序
07-13
用c＋＋语言编写的程序，实现一个带头节点的非递减单链表存储结构的线性表。此程序能实现的基本算法有：初始化单链表，销毁单链表，插入元素，删除元素，清空单链表，打印线性表表和合并单链表。
数据结构：单链表的就地逆置
weixin_30615767的博客
10-07 1570
6-1带头结点的单链表就地逆置（10分） 本题要求编写函数实现带头结点的单链线性表的就地逆置操作函数。L是一个带头结点的单链表，函数ListReverse_L(LinkList &L)要求在不新开辟节点的前提下将单链表中的元素进行逆置，如原单链表元素依次为1,2,3,4，则逆置后为4,3,2,1。 函数接口定义： void ListReve...
C++实现单链表【每一步详细深入讲解，代码清晰、简单、易懂】
weixin_55755506的博客
12-03 4506
例如：我们需要在伪头节点（不包含数据）和含有1的节点之间插入一个节点，发现，只需要改变dummy的指针和需要插入的指针即可。通过对插入和删除的讨论，我们了解到，插入调用find函数时，并不需要操作其返回值，所以，返回值具体是该元素的节点还是其前面的节点并没有影响；，而第一个节点的前一个节点是dummy，这也是为什么我们需要dummy这个伪头节点。，因此，删除操作时我们必须得到需要删除节点的前一个节点，因此。先将要添加的元素的指针指向dummy节点的后一个节点。将要添加节点的指针指向之前的下一个节点。
数据结构—单链表的操作与实现—c++代码（含全部代码）
Initial_Mind的博客
01-21 6076
单链表的操作与实现
链表（详解）- C++（逆序创建链表-头插法）
m0_54158068的博客
03-30 978
链表（详解）- C++（逆序创建链表-头插法）
C++ class实现单链表(完整代码)
m0_51955470的博客
05-02 1005
#include <iostream> using namespace std; typedef int ElemType; #define NO 0 class Node { friend class LinkList; private: ElemType data; Node *next; Node (): next(NULL) { }; }; class LinkList { private: Node *head; public: LinkList(
数据结构与算法之线性表基础——单链表（C与C++双人打） 定义线性表节点的结构.pdf
04-18
数据结构与算法之线性表基础——单链表（C与C++双人打） 定义线性表节点的结构.pdf
sLinkList.zip_C/C++__C/C++_
08-09
单链表的基本形式，包括头文件和主函数，实现了线性表的基本功能
实验一终稿_基本操作_C++_线性表_
10-01
线性表存储结构（五选一）：1、 带头结点的单链表2、 不带头结点的单链表3、 循环链表4、 双链表5、 静态链表线性表的基本功能：1、 构造：使用头插法、尾插法两种方法2、 插入：要求建立的链表按照关键字从小到大...
单链表的代码实现（C++）
qq_46601680的博客
08-01 1257
依据严蔚敏数据结构教材编写。 编写了以下功能：初始化、头插法创建表、尾插法创建表、输出链表、按位置查找、按值查找返回地址、按值查找返回位置、插入、删除、判断链表是否为空、求表长、清空链表、销毁链表。 完整代码如下： #include <iostream> using namespace std; typedef struct LNode{ //定义单链表存储结构 int data; //数据域 struct LNode *next; //指针域 }LNode
c++(1): c++单链表的创建、查找、插入、删除
@bangbang的博客
07-22 9749
但各个节点还是独立的，并没有关系，并没有上个节点的next存放了下个节点的地址。上个节点next存放了下个节点的关系，就可以从当前节点找到下个节点，所以我们说各个节点是连着的，这样才能称为一个链表。实现指向下个节点，当j=i时，输出找到节点p_i对应的数据。按照生成head节点的方法，生成子节点也可以用类似的方法。，链表的前一个节点的指针域，存放的是下一个节点的地址。,也就是说随着节点的移动，他们的上一个节点。的值，对于下个节点的pre就是当前节点。存放下个节点的地址，下个节点的类型为。...
c++实现单链表基本操作
热门推荐
u011200403的博客
02-13 1万+
程序媛决定好好学习写代码 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种
线性表之单链表的c++实现
mfcbest的专栏
09-25 1486
单链表是线性表的一种链式存储结构,它同顺序表(由于顺序表实现比较简单,本文不做讲述了)不同,是用一组任意地址的存储单元,存放线性表中的元素。为了表示结点之间的关系,每个结点不仅要存储它表示的元素，还要存储它下一个结点的信息。 下面我们用C++的模版来实现以下单链表: 结点定义 template struct Node { Node* pNextNode; T m_value; }; 单
数据结构-单链表的两种实现方式
ytuyzh的博客
03-22 531
单链表的两种实现方式：带头结点和不带头结点 需要注意的地方： 1、带头结点和不带头结点在实现插入和删除操作时的区别 2、封装的方便之处（见InsertPriorNode(LNode *p,ElemType e)），能够使代码更简洁，更加清晰 3、带头结点方式中，头结点不装入数据，并且看作成第0个结点。不带头结点方式，没有头结点，从第1个结点开始。 4、注意一些特判情况 例如： 按位序...
【数据结构】链表的基本操作
m0_53171456的博客
03-11 8208
规划 /* 链表的基本操作 */ #include<iostream> #include<algorithm> #define ElemType int using namespace std; typedef struct LNode{ ElemType data; //数据域 LNode *next; //指针域 } *LinkList; //链表的初始化 void IniteList(LinkList &L){ L = new LNode; //创建头结点
数据结构线性表——单链表实现
qq_43246915的博客
10-16 265
单链表是用一组任意的存储单元存放线性表的元素，这组存储单元可以连续也可以不连续，甚至可以零散的分布在内存的任意位置。（这里就是和顺序表的一个区别）。 这里需要注意的是在构造一个单链表时，就是向里面插入元素时，存在两种方法：头插法和尾插法。 在下面的代码实现中特意指出。 #include <iostream> using namespace ...
1.4.1线性表的链式实现-单链表的建立
CppYyds的博客
02-23 89
知识总览单链表的建立：尾插法建立单链表头插法建立单链表 单链表的建立： #mermaid-svg-jDMYi0coFP7t6ZXI .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-family);fill:#333;color:#333}#mermaid-svg-jDMYi0coFP7t6ZXI .label text{fill:#333}#mermaid-svg-jDMYi0coFP7t6
C语言数据结构如何从线性表得到单链表
最新发布
03-31
3. 遍历线性表中的所有元素，为每个元素创建一个单链表节点，并将其数据赋值为线性表中对应的元素。 4. 将每个单链表节点的指针指向下一个节点，直到遍历完整个线性表。 5. 返回单链表的头节点。 具体实现可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

linszjava@gmail.com

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

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

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

打赏作者

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

抵扣说明：

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

余额充值