数据结构（二） 线性链表ADT List基本操作函数

最新推荐文章于 2023-02-21 20:02:02 发布
最新推荐文章于 2023-02-21 20:02:02 发布
阅读量1.1k 收藏 12
点赞数
分类专栏： 数据结构学习笔记 文章标签： 链表 数据结构 list c++ vscode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61598337/article/details/126401362
版权

链表的概念

创建数组时，我们会直接分配出所有我们需要的内存。但是对于链表，我们每次只分配出一个节点（node） 的内存。链表使用指针将各个节点组合到一起，这样就形成了一个连一个的链式的结构，这就是链表（Linked List）这个名称的由来。

链表的每个节点都有两个部分：数据区和指针区。前者用来存储数据，后者用来存储指向下一个节点的指针。我们使用 malloc() 函数来为每个节点分配内存。节点的头部只含有指向第一个节点的指针。

链表结构的构建

其中，DATA数据元素，可以为你想要储存的任何数据格式，可以是数组，可以是int，甚至可以是结构体，Next为一个指针，其代表了一个可以指向的区域，通常是用来指向下一个结点，链表的尾部Next指向NULL（空），其尾部没有任何可以指向的空间了即链表的结束位置，其代码如下

//线性表的链式表示
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
using namespace std;
typedef struct LNode{
    int data;
    struct LNode *next;
}LNode,*LinkList;//定义*LinkList的作用为全局变量连接单个节点，从而组成链表，而LNOde只作为函数的

链表的初始化

初始化主要完成以下工作：创建一个单链表的前置节点并向后逐步添加节点，一般指的是申请结点的空间，同时对一个结点赋空值(NULL)，其代码可以表示为：

LinkedList listinit(){
    Node *L;
    L=(Node*)malloc(sizeof(Node));      //开辟空间 
    if(L==NULL){                     //判断是否开辟空间失败，这一步很有必要
        printf("申请空间失败");
        //exit(0);                  //开辟空间失败可以考虑直接结束程序
    }
    L->next=NULL;       //指针指向空
}

利用头插法向链表赋值

 

//链表赋值
void CreateList_L(LinkList &L,int n)
{
    //cout<<"dd"<<endl;
    L = (LinkList)malloc(sizeof(LNode));//为链表头结点开辟内存空间
    if (L == NULL)
    {
        cout<<"内存空间申请失败"<<endl;
    }
    L->next = NULL;//创建头节点
    //开始链表赋值
    for(int i = n;i>0;--i)
    {
        LNode *p;
        p = (LinkList)malloc(sizeof(LNode));
        cout<<"请输入节点的数据"<<endl;
        scanf("%d",&(p->data));//取值
        //插入到表头
        p ->next = L->next;
        L ->next = p;
        //注意只有p才为真正赋值和具有指针 的节点，而L ->next = p只是利用p赋值，向前面节点循环赋值
        //cout<<p->data<<endl;
    }
}

遍历单链表如打印、修改

从链表的头开始，逐步向后进行每一个元素的访问，称为遍历。

对于遍历操作，我们可以衍生出很多常用的数据操作，比如查询元素，修改元素，获取元素个数，打印整个链表数据等等。

进行遍历的思路极其简单，只需要建立一个指向链表L的结点，然后沿着链表L逐个向后搜索即可，代码如下：

//头插法建立此表,其输出为逆序
void  ListTraverse(LinkList L,int &n)
{
    LNode *p;
    p = L;//就是把让自己定义的Node p = 头结点
    //p = L->next;//p = L->next就是让p = 头结点的后一个节点,p等于L的下一个节点地址
    int j=0;
    while(j<n)//循环的终止条件为p存在且j小于i,即未超出范围
    {
        p = p->next;//p结构体指针中包含了next节点，而循环的时候将i次的next节点(具有值和指针的一种结构体)值取出即可
        cout<<p->data<<endl;
        ++j;
    }
    //printf("链表长度为%d",j);
}

//链表内容的修改，在链表中修改值为x的元素变为为k。
void LinkedListReplace(LinkList L,int x,int k) 
{
    LNode *p=L->next;
    int i=0;
    while(p){
        if(p->data==x){
            p->data=k;
        }
        p=p->next;
    }
}

插入操作

链表的插入操作主要分为查找到第i个位置，将该位置的next指针修改为指向我们新插入的结点，而新插入的结点next指针指向我们i+1个位置的结点。其操作方式可以设置一个前驱结点，利用循环找到第i个位置，再进行插入。

//链表插入节点,s为即将要插入的结点
bool ListInsert_L(LinkList &L,int i,int e)
{
    LNode *p,*s;
    //LinkList s;
    p = L;//将头结点L赋值给p，即L就等于p
    int j = 0;//计数器
    while(p&&j<i-1)//循环条件为p存在，且j<i-1,i为要插入的位置,i为1,j为0,所以终止条件j<i-1
    {
        p = p->next;//p = p->next该语句目的在于深入查找，即寻找第i-1个结点
        ++j;
    }
        if(!p||j>i-1)
        return false;
        s = (LinkList)malloc(sizeof(LNode));
        cout<<"请输入插入结点s的数据值e:"<<endl;
        scanf("%d",&e);
        //-------核心代码--------
        s->data = e;
        s->next = p->next;
        p->next = s;
        //-------核心代码--------
        return true;
}

删除操作

删除元素要建立一个前驱结点和一个当前结点，当找到了我们需要删除的数据时，直接使用前驱结点跳过要删除的结点指向要删除结点的后一个结点，再将原有的结点通过free函数释放掉。如图所示

//删除链表第i个元素
bool ListDelete_L(LinkList &L,int i ,int &e)
{
    //在带有头结点的链表中，删除第i个元素,并且由e返回
    LNode *p,*q;//*q为要删除的结点
    p = L;
    int j = 0;
    while(p->next&&j<i-1)
    {
        p = p->next;//查找第i个位置的结点元素
        ++j;
    }
    if(!(p = p->next)||j>i-1)
    return false;
    //--------核心代码---------
    q = p->next;//q = p->next 即为将p原来所指向的结点赋值给q,即将要删除的结点赋值给q
    p->next = q->next;//若不进行释放内存操作,则删除结点只将q所指向的下一个结点的指针赋值给p即可
    //--------核心代码---------
    e = q->data;
    free(q);
    return true;
}

 取链表某个结点的值

//取链表中第i个元素的值
bool GetElem_L(LinkList L,int i,int &e)
{
    int j=0;//j为序号变量
    LNode *p;
    //*next为节点
    p  = L->next;//初始化,让指针p指向第一个节点
    while(p && j<i-1)//循环的终止条件为p存在且j小于i,即未超出范围
    {
        //p = p->next为查找第i个结点
        p = p->next;//p结构体指针中包含了next节点，而循环的时候将i次的next节点(具有值和指针的一种结构体)值取出即可
        ++j;
    }
    if(!p || j>i-1) return false;
    e = p->data;
    cout<<e<<endl;      
    return true;
}

至此链表的基本函数就编写完成了，其链表最主要的就是对指针的灵活运用，只要理解了 LNode * *p ，LinkList L的作用以及这几句代码，就基本掌握了链表的核心内容

//赋值核心代码
//--------核心代码---------
     p ->next = L->next;
     L ->next = p;
//--------核心代码---------
//插入核心代码
 //-------核心代码--------
        s->data = e;
        s->next = p->next;
        p->next = s;
 //-------核心代码--------
//删除核心代码
//--------核心代码---------
   q = p->next;//q = p->next 即为将p原来所指向的结点赋值给q,即将要删除的结点赋值给q
   p->next = q->next;//若不进行释放内存操作,则删除结点只将q所指向的下一个结点的指针赋值给p即可
//--------核心代码---------

 以下是链表基本操作函数的完整代码

//线性表的链式表示
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
using namespace std;
typedef struct LNode{
    int data;
    struct LNode *next;
}LNode,*LinkList;//定义*LinkList的作用为全局变量连接单个节点，从而组成链表，而LNOde只作为函数的局部变量


//取链表中第i个元素的值
bool GetElem_L(LinkList L,int i,int &e)
{
    int j=0;//j为序号变量
    LNode *p;
    //*next为节点
    p  = L->next;//初始化,让指针p指向第一个节点
    while(p && j<i-1)//循环的终止条件为p存在且j小于i,即未超出范围
    {
        //p = p->next为查找第i个结点
        p = p->next;//p结构体指针中包含了next节点，而循环的时候将i次的next节点(具有值和指针的一种结构体)值取出即可
        ++j;
    }
    if(!p || j>i-1) return false;
    e = p->data;
    cout<<e<<endl;      
    return true;
}

//链表赋值
void CreateList_L(LinkList &L,int n)
{
    //cout<<"dd"<<endl;
    L = (LinkList)malloc(sizeof(LNode));//为链表头结点开辟内存空间
    if (L == NULL)
    {
        cout<<"内存空间申请失败"<<endl;
    }
    L->next = NULL;//创建头节点
    //开始链表赋值
    for(int i = n;i>0;--i)
    {
        LNode *p;
        p = (LinkList)malloc(sizeof(LNode));
        cout<<"请输入节点的数据"<<endl;
        scanf("%d",&(p->data));//取值
        //插入到表头
        p ->next = L->next;
        L ->next = p;
        //注意只有p才为真正赋值和具有指针 的节点，而L ->next = p只是利用p赋值，向前面节点循环赋值
        //cout<<p->data<<endl;
    }
}

//访问并输出每个元素
//头插法建立此表,其输出为逆序
void  ListTraverse(LinkList L,int &n)
{
    LNode *p;
    p = L;//就是把让自己定义的Node p = 头结点
    //p = L->next;//p = L->next就是让p = 头结点的后一个节点,p等于L的下一个节点地址
    int j=0;
    while(j<n)//循环的终止条件为p存在且j小于i,即未超出范围
    {
        p = p->next;//p结构体指针中包含了next节点，而循环的时候将i次的next节点(具有值和指针的一种结构体)值取出即可
        cout<<p->data<<endl;
        ++j;
    }
    //printf("链表长度为%d",j);
}


//链表插入节点,s为即将要插入的结点
bool ListInsert_L(LinkList &L,int i,int e)
{
    LNode *p,*s;
    //LinkList s;
    p = L;//将头结点L赋值给p，即L就等于p
    int j = 0;//计数器
    while(p&&j<i-1)//循环条件为p存在，且j<i-1,i为要插入的位置,i为1,j为0,所以终止条件j<i-1
    {
        p = p->next;//p = p->next该语句目的在于深入查找，即寻找第i-1个结点
        ++j;
    }
        if(!p||j>i-1)
        return false;
        s = (LinkList)malloc(sizeof(LNode));
        cout<<"请输入插入结点s的数据值e:"<<endl;
        scanf("%d",&e);
        //-------核心代码--------
        s->data = e;
        s->next = p->next;
        p->next = s;
        //-------核心代码--------
        return true;
}

//删除链表第i个元素
bool ListDelete_L(LinkList &L,int i ,int &e)
{
    //在带有头结点的链表中，删除第i个元素,并且由e返回
    LNode *p,*q;//*q为要删除的结点
    p = L;
    int j = 0;
    while(p->next&&j<i-1)
    {
        p = p->next;//查找第i个位置的结点元素
        ++j;
    }
    if(!(p = p->next)||j>i-1)
    return false;
    //--------核心代码---------
    q = p->next;//q = p->next 即为将p原来所指向的结点赋值给q,即将要删除的结点赋值给q
    p->next = q->next;//若不进行释放内存操作,则删除结点只将q所指向的下一个结点的指针赋值给p即可
    //--------核心代码---------
    e = q->data;
    free(q);
    return true;
}


//链表内容的修改，在链表中修改值为x的元素变为为k。
void LinkedListReplace(LinkList L,int x,int k) 
{
    LNode *p=L->next;
    int i=0;
    while(p){
        if(p->data==x){
            p->data=k;
        }
        p=p->next;
    }
}

//归并两个链表
void MergeList_L(LinkList &La,LinkList &Lb,LinkList Lc)
{
    LNode *pa,*pb,*pc;
    pa = La->next;
    pb = Lb->next;
    while(pa&&pb)
    {
        if(pa->data <= pb->data)
        {
            pc->next = pa;//将a链表的头结点赋值给pc,准备为c链表赋值
            pc = pa;
            pa = pa->next;//若a>b则将a的结点指针赋值给c链表的结点
            //pc->next = pa->next;
        }
        else
        {
            pc->next = pb;
            pc = pb;
            pb = pb->next;
        }
    }
    pc->next = pa?pa:pb;
    free(Lb);
}

int main()
{
    LNode *p;
    LinkList L; int n,e,i;
    //e为data  n,i均为循环变量   
    p = (LinkList)malloc(sizeof(LNode));
    cout<<"请输入元素的个数n"<<endl;
    cin>>n;
    CreateList_L(L,n);
    //此时位序为逆序3-2-1(1-2-3)
    cout<<"请输入查询的元素的位序i"<<endl;
    cin>>i;
    GetElem_L(L,i,e);
    printf("\n");
    //向第i位序插入元素
    cout<<"请输入要插入的位序i"<<endl;
    cin>>i;
    ListInsert_L(L,i,e);
    printf("\n");
    //输出插入后的链表
    n++;
    ListTraverse(L,n);
    //删除链表中的一个结点
    cout<<"请输入删除的位序结点i"<<endl;
    cin>>i;
    ListDelete_L(L,i,e);
    printf("\n");
    //输出删除后的链表
    n--;
    ListTraverse(L,n);

}

 

 

 

大块奶酪----
关注
  • 0
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表ADT(List)
wkwk7600的博客
06-12 3811
线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的。
【数据结构基础/接口函数的编写】链表的基础知识和接口函数全编写
AMor_05的博客
10-01 200
链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。
数据结构（三） 栈 链队列ADT List基本操作函数与应用
m0_61598337的博客
09-24 867
栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。
链表ADT的创建（c语言）
qq_73743836的博客
02-21 276
链表的创建
数据结构与算法学习笔记——List ADT C++实现
weixin_46574339的博客
02-12 1057
这里写目录标题一级目录二级目录三级目录 一级目录 二级目录 三级目录
东北大学 数据结构作业1 链表
06-19
链表是一种线性数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在这个实验中，学生需要通过链表实现一元多项式相加的功能。 链表的抽象数据类型（ADT LinkList）定义了链表的数据对象和...
数据结构教程.docx
12-14
本教程涵盖了数据结构的基础概念，抽象数据类型（ADT）的表示与实现，算法设计与效率评估，以及各种具体数据结构的实现。 首先，数据结构是关于如何在内存中有效地存储和组织数据的方式，以便于高效地访问和操作。...
数据结构ADT.doc
10-03
数据结构中的动态顺序表...总的来说，动态顺序表是线性数据结构的一种高效实现，它结合了数组的随机访问优点和链表的动态扩展特性。在实际应用中，这种数据结构常用于实现栈、队列、符号表等抽象数据类型（ADT）。
《数据结构》教学大纲.docx
10-27
本课程的目标是让学生掌握数据结构的基本原理，学会如何根据问题需求选择合适的数据结构，设计高效的算法，并能进行算法的时间和空间复杂度分析。 课程内容主要包括以下部分： 1. 绪论：讲解数据结构的基本概念，...
数据结构知识点总结(word文档物超所值).pdf
12-18
数据结构知识点总结(word文档物超所值) 数据结构是计算机科学的基石，它是指能够被计算机识别、存储和加工处理的信息的载体。数据元素是数据的基本单位，可以由若干个数据项组成。数据项是具有独立含义的最小标识...
adt_list.txt
04-13
这是一个简单数据结构抽象数据类型的代码，用于作为底层开发的代码
数据结构中线性表的顺序式表示的基本操作函数
01-14 308
线性表的基本操作共有十二个。我们通过对线性表基本操作的有机组合，可以处理较为复杂的线性表。 一、初始化顺序线性表——构造一个空的顺序线性表 1 void InitList(SqList &L) 2 { 3 L.elem = (ElemType*)malloc(LIST_INIT_SIZE *sizeof(ELemType));//malloc函数来...
链表的各种基本函数
白菜
06-24 4722
/* 线性表基本操作的编程实现，掌握线性表的建立、遍历、插入、删除等基本操作的编程 实现，也可以进一步编程实现查找、逆序、排序等操作，需要实现线性表的以下功能: 1、创建单链表 2、删除链表中的某个结点 3、输出单链表(遍历) 4、释放结点所占空间 5、查找第i个结点 6、插入一个结点 7、求链表的长度*/ #include&l...
The List ADT
arilx06604的专栏
09-17 108
1、Definiation A list is a sequence. a0, a1,a2,..., aN (N>0) 2、Character For any list except the empty list, we say that Ai follows(or succeeds)Ai-1(i<N) and that Ai-1 precedes Ai(i&g...
线性表中顺序表的基本操作
xdznb_的博客
01-07 802
线性表的定义和特点 同一线性表中的元素必定有相同的特性，即属于统一数据对象，相邻数据元素之间存在着序偶关系。 由n(n>=0)个数据特性相同的的元素构成的有限序列称为线性表 线性表中元素的个数n(n>=0)定义为线性表的长度，n=0时称为空表 线性结构示意图： 对于非空的线性表或线性结构，其特点是： 存在唯一的一个被称为“第一个”的数据元素； 存在唯一的一个被称为“最后一个”的...
C语言ADT（抽象数据类型编程）
热门推荐
zhangzhi123456789的专栏
09-23 2万+
C语言是一种计算机程序设计语言。它既具有高级语言的特点，又具有汇编语言的特点。它可以作为工作系统设计语言，编写系统应用程序，也可以作为应用程序设计语言，编写不依赖计算机硬件的应用程序。因此，它的应用范围广泛，不仅仅是在软件开发上，而且各类科研都需要用到C语言，具体应用比如单片机以及嵌入式系统开发。（摘自“百度百科”） 在嵌入式系统开发中，随着系统功能要求越来越多，除了硬件系统不断扩展外，芯片中软
线性表链式表示-单链表
m0_49218627的博客
05-19 395
上一节我们所讲的顺序存储其实是有缺陷的，最大的缺点就是数据的增删的时候可能会移动大量的数据，然后链式存储则可以呵呵好解决这个问题 当我们用链式来存储线性表的时候，不需要地址连续的存储单元，即 不要求逻辑相邻的元素在物理位置上也相邻，它通过 链建立起数据元素之间的逻辑关系，因此插入或者删除时候不需要移动元素只需要修该指针，但是也会因此失去 随机存取的特点只能进行 顺序存取 首先要说明的是单链表的实现 线性表中的单链表最为重要的特点我认为还是 如果要寻找目标元素只能找他的前一个结点元素，为了方便单链表的创
实现无头结点单链表的基本操作函数
Quinn0918的博客
06-09 8951
基于单链表经常见的面试题——基础篇 基于单链表的面试题——进阶篇什么是无头结点链表？？？ singlelinkedlist.h头文件#ifndef __SINGLELINKEDLIST_H__ #include<stdio.h> #include<windows.h> #include<assert.h> typedef int DataType;typedef struct ListNode
什么是抽象数据类型？抽象数据类型ADTList 有哪些基本操作？如何遍历ADTList?
最新发布
06-02
抽象数据类型（Abstract Data Type，ADT）指的是一个数据类型以及定义在该数据类型上的一组操作，这些操作是对外可见的，而数据类型的内部实现则是隐藏的。ADT的设计能够使得程序员更加关注问题本身，而不需要过多关注数据的具体实现。 ADTList是一种抽象数据类型，它是一个线性表，具有以下基本操作： 1. InitList(): 初始化线性表。 2. ListEmpty(): 判断线性表是否为空。 3. ListLength(): 获取线性表的长度。 4. GetElem(i): 获取线性表第i个位置上的元素。 5. LocateElem(e): 查找线性表中元素e的位置。 6. ListInsert(i, e): 在线性表的第i个位置上插入元素e。 7. ListDelete(i): 删除线性表的第i个位置上的元素。 8. ClearList(): 清空线性表。 9. DestroyList(): 销毁线性表。 ADTList可以通过遍历来访问其中的元素，遍历主要有两种方式： 1.顺序遍历：从线性表的第一个元素开始，按照顺序依次遍历每一个元素，直到最后一个元素。 2.倒序遍历：从线性表的最后一个元素开始，按照倒序依次遍历每一个元素，直到第一个元素。 在实际应用中，遍历ADTList需要根据具体情况选择合适的方式，以便更加高效地访问其中的元素。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值