线性表之链表基本操作的实现1

最新推荐文章于 2022-04-03 14:22:05 发布
最新推荐文章于 2022-04-03 14:22:05 发布
阅读量443 收藏 1
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37820491/article/details/90374369
版权

这里，我们首先实现单链表的基本操作。

1.创建单链表

LinkList CreateLinkList(LinkList L)
{
    L=(LinkList)malloc(sizeof(LNode));        //创建一个头结点
    L->next=NULL;         //头结点的指针域为空
    return L;
}

2.采用前插法插入数据

void InsertElem_For(LinkList head,User user)    //即把每次插入的数据都设置为首元结点
{
    LinkList p=(LinkList)malloc(sizeof(LNode));        //创建一个新的结点
    p->user=user;                 //将目标数据放置进入数据域
    p->next=head->next;           //把当前的首元结点与目标结点相连，即目标结点指向首元结点
    head->next=p;                 //把目标结点与头结点相连，即头结点指向目标结点，此时目标结点变成首元结点
}

3.采用后插法插入数据

void InsertElem_Back(LinkList head,User user)   //即把每个插入的数据都放在最后一位
{
    LinkList p=(LinkList)malloc(sizeof(LNode));
    LinkList r=head;          //这里我们采用新建一个空链表，每次加入数据后，r都会指向尾节点
    p->user=user;
    p->next=NULL;           
    r->next=p;                //链表的尾指针指向目标结点
    r=p;                      //指向目标结点的指针成为新的尾指针
}

4.在某个位置插入一个结点

bool AddElem(LinkList head,int index,User user)
{
    int j=0;
    while(head && j<index-1)           //结束循环后head指向目标位置的前一个结点
    {
        head=head->next;
        j++;
    }
    if(!head || j>index+1)
    {
        return false;
    }
    LinkList p=(LinkList)malloc(sizeof(LNode));
    p->user=user;
    p->next=head->next;                //将目标结点指向当前位置的结点
    head->next=p;                      //将当前位置的前一个结点指向目标结点，此时目标结点插入到当前位置
    return true;
}

5，根据某个位置返回对应的结点信息

User GetElemByIndex(LinkList head,int index)
{
    int j=0;
    while(head && j<index)        //返回目标位置的结点
    {
        head=head->next;
        j++;
    }
     if(!head || j>index)
    {
        User user;
        user.id=456;
        strcpy(user.username,"error");
        return user;
    }
    return head->user;
}

6.根据结点信息找到该结点在链表中的位置

int GetIndexByUser(LinkList head,User user)
{
    int index=0;
    bool bo=false;
    while(head)
    {
        User user1=head->user;
        if(strcmp(user1.username,user.username)==0)
        {
            bo=true;
            break;
        }
        index++;
        head=head->next;
    }
    return bo?index:-1;
}

7.修改某个位置对应的结点信息

void UpdateElemByIndex(LinkList head,int index,User user)
{
    int j=0;
    while(head && j<index)
    {
        head=head->next;
        j++;
    }
     if(!head || j>index)
    {
        User user1;
        user1.id=456;
        strcpy(user1.username,"error");
        head->user=user1;
    }
    head->user=user;
}

8.删除某个位置对应的结点

void DeleteElemByIndex(LinkList head,int index)
{
    int j=0;
    while(head && j<index-1)        //当前的head应该指向的是目标结点的前一个结点
    {
        head=head->next;
        j++;
    }
     if(!head || j>index)
    {
        User user1;
        user1.id=456;
        strcpy(user1.username,"error");
        head->user=user1;
    }
    LinkList p=head->next;            //p指向目标结点
    head->next=p->next;               //将目标结点的上一个结点指向目标结点的下一个结点
    free(p);                          //释放目标结点
}

这里我们对插入某个结点进行图形讲解（例4）：

bool AddElem(LinkList head,int index,User user)
{
    int j=0;
    while(head && j<index-1)           //结束循环后head指向目标位置的前一个结点
    {
        head=head->next;
        j++;
    }
    if(!head || j>index+1)
    {
        return false;
    }
    LinkList p=(LinkList)malloc(sizeof(LNode));
    p->user=user;                      //1.将数据放置在数据域
    p->next=head->next;                //2.将目标结点指向当前位置的结点
    head->next=p;                      //3.将当前位置的前一个结点指向目标结点，此时目标结点插入到当前位置
    return true;
}

第一步（p1=head）：

第二步：

第三步：

这样就完成了链表的插入

这里附上完整的代码：

#include<bits/stdc++.h>
using namespace std;
typedef struct
{
    char username[20];
    int id;
}User;
//单链表的存储结构
typedef struct LNode
{
    User user;           //数据域
    struct LNode *next;  //指针域
}LNode,*LinkList;        //LinkList为指向LNode的指针类型
//创建单链表，创建头节点，指针指向头节点
LinkList CreateLinkList(LinkList L)
{
    L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;
    return L;
}
//前插法向单链表中加入数据
void InsertElem_For(LinkList head,User user)
{
    LinkList p=(LinkList)malloc(sizeof(LNode));
    p->user=user;
    p->next=head->next;
    head->next=p;
}
//后插法向单链表中加入数据
void InsertElem_Back(LinkList head,User user)
{
    LinkList p=(LinkList)malloc(sizeof(LNode));
    LinkList r=head;          //每次加入数据后，r都会指向尾节点
    p->user=user;
    p->next=NULL;
    r->next=p;
    r=p;
}
//在某个位置添加一个节点（插入）
bool AddElem(LinkList head,int index,User user)
{
    int j=0;
    while(head && j<index-1)
    {
        head=head->next;
        j++;
    }
    if(!head || j>index+1)
    {
        return false;
    }
    LinkList p=(LinkList)malloc(sizeof(LNode));
    p->user=user;
    p->next=head->next;
    head->next=p;
    return true;
}
//根据位置查找某个子节点
User GetElemByIndex(LinkList head,int index)
{
    int j=0;
    while(head && j<index)
    {
        head=head->next;
        j++;
    }
     if(!head || j>index)
    {
        User user;
        user.id=456;
        strcpy(user.username,"error");
        return user;
    }
    return head->user;
}
//根据值查找到节点在链表中的位置
int GetIndexByUser(LinkList head,User user)
{
    int index=0;
    bool bo=false;
    while(head)
    {
        User user1=head->user;
        if(strcmp(user1.username,user.username)==0)
        {
            bo=true;
            break;
        }
        index++;
        head=head->next;
    }
    return bo?index:-1;
}
//修改第n个节点的信息
void UpdateElemByIndex(LinkList head,int index,User user)
{
    int j=0;
    while(head && j<index)
    {
        head=head->next;
        j++;
    }
     if(!head || j>index)
    {
        User user1;
        user1.id=456;
        strcpy(user1.username,"error");
        head->user=user1;
    }
    head->user=user;
}
//删除第n个节点的信息
void DeleteElemByIndex(LinkList head,int index)
{
    int j=0;
    while(head && j<index-1)
    {
        head=head->next;
        j++;
    }
     if(!head || j>index)
    {
        User user1;
        user1.id=456;
        strcpy(user1.username,"error");
        head->user=user1;
    }
    //当前的head应该指向的是目标节点的前一个节点
    LinkList p=head->next;
    head->next=p->next;
    free(p);
}
int main()
{
    LinkList L;
    User user;
    //创建单链表
    LinkList head=CreateLinkList(L);
    //前插法插入数据
    user.id=123;
    strcpy(user.username,"gjw");
    InsertElem_For(head,user);
    //后插法插入数据
    //user.id=123;
    //strcpy(user.username,"gjw3");
    //InsertElem_Back(head,user);
    //在某个位置添加一个节点（插入）
    user.id=123;
    strcpy(user.username,"gjw1");
    AddElem(head,1,user);
    //根据位置查找某个子节点
    //User user1=GetElemByIndex(head,1);
    //cout<<user1.username<<endl;
    //根据值查找到节点的位置
    //user.id=123;
    //strcpy(user.username,"gjw");
    //int index=GetIndexByUser(head,user);
    //cout<<index<<endl;
    //修改第n个节点的信息
    //user.id=123;
    //strcpy(user.username,"gjw8");
    //UpdateElemByIndex(head,1,user);
    //删除第n个节点的信息
    User user1=GetElemByIndex(head,1);
    cout<<user1.username<<endl;
    DeleteElemByIndex(head,1);
    user1=GetElemByIndex(head,1);
    cout<<user1.username<<endl;
    return 0;
}

学到这里，其实发现单链表的实现也不难，是吧？

成长er
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2.2线性表——单链表基本操作的实现
m0_57382477的博客
10-01 1000
本文针对数据结构，线性表的链式表示和实现中部分内容进行了简单的叙述
C++语言实现线性表之链表实例
09-03
总之，这个C++实例提供了一个基础的链表实现，涵盖了链表的基本操作，如插入、删除、查找、打印和获取长度。对于初学者来说，这是一个很好的起点，可以帮助理解链表的工作原理和C++模板类的应用。在实际项目中，根据...
7-3 jmu-ds-单链表的基本运算
rs_seaside的博客
10-13 1350
7-3 jmu-ds-单链表的基本运算（15 分） 实现单链表的基本运算：初始化、插入、删除、求表的长度、判空、释放。 （1）初始化单链表L，输出L->next的值； （2）依次采用尾插法插入元素：输入分两行数据，第一行是尾插法需要插入的字符数据的个数，第二行是具体插入的字符数据。 （3）输出单链表L； （4）输出单链表L的长度； （5）判断单链表L是否为空； （6）输出
线性表基本运算在单链表中的实现
weixin_45959708的博客
08-18 840
#include <stdio.h> #include <malloc.h> #define Maxsize 50; typedef int ElemType; //假设ElemType为int类型，使用以下自定义类型语句： typedef struct LNode { ElemType data; //存放元素值 struct LNode *next;//指向后继节点 }LinkNode; //单链表结点类型 //1.初始化线性表L
【数据结构——线性表之链表】
lflcodeplus的博客
10-04 2286
线性表之《链表的表示及基本操作的实现》 目录线性表之《链表的表示及基本操作的实现》一、单链表（一）单链表的描述（一）单链表的操作实现1、初始化2、查找3、插入4、删除二、循环链表三、循环链表 一、单链表 （一）单链表的描述 typedef struct LNode { ElemType data;//结点数据域 struct LNode* next;//结点指针域 }LNode ,*LinkList; 变量定义： LNode* p, * q LinkList L; p, q, L都是指针变量，
实现单链表的基本操作（1）
weixin_44945537的博客
10-24 214
1.删除链表中指定的所有元素 (https://leetcode-cn.com/problems/removelinked-list-elements/description/) public class LinkedNode{ public ListNode reverseList(ListNode head) { if(head == null) { ...
实验一 线性表基本操作的编程实现
02-09
【实验一 线性表基本操作的编程实现】是一个针对数据结构的验证性实验，旨在让学生掌握线性表的基本操作，包括建立、遍历、插入、删除等，并可以选择实现查找、逆序、排序等功能。实验可以选择顺序结构或链表结构来...
线性表双向链表存储的实现
12-25
单链表结构定义、初始化、插入元素、删除元素、遍历显示、释放空间，易懂，学习。
线性表（双链表）的基本操作实现
06-26
线性表（双链表）的基本操作实现 线性表是数据结构中的一种典型数据结构，它可以存储大量的数据元素，并且可以对这些数据元素进行各种操作。在本次课程设计中，我们主要实现了线性表（双链表）的基本操作，包括创建...
线性表的实现与链表的操作
derbi123123的博客
02-04 416
链表真的麻烦但是真正学会了它其他的数据结构也会迎刃而解。。。 1.线性表用动态链表实现的操作： typedef struct LNode *list; struct LNode{ ELementType data;//ELementType是数据类型的概括 list next; } list ptrl;//链表头指针 （1）创建空链表： list create( ) { list ptr...
线性表 链表的实现
04-20
数据结构和算法分析中的链表 和线性表的实现
（一）线性表的链式实现及相关操作实现
hmzdbql的专栏
03-19 559
（前言）考研在即，数据结构是重头戏，以前学的不是很好，很多东西都是想着还明白但是用代码实现却很困难。为了考研，也为了以后的工作，我觉得有必要花些精力来好好学习一下数据结构同时也希望借此提高自己的编程能力。用日志的方式来记录我的代码，同时也记录我的考研历程，希望我能坚持下去...加油！ ps：也希望各位高手指教！在这里先谢谢了！ #include using namespace std; /
线性链表的一些基本算法
qq_41887753的博客
10-17 595
/*1、假设有两个按元素值递增次序排列的线性表，均以单链表形式存储。请编写算 法将这两个单链表归并为一个按元素值递减次序排列的单链表，并要求利用原来 两个单链表的结点存放归并后的单链表。*/ List *List_merge(List *La, List *Lb) { List *p, *q, *r; p = La->next; //使用p指针指向la的下一个元素 La->next = NULL; //把LA的下一个元素置为空指针 q = Lb->.
线性表链式结构的基本实现
云杉木屋
12-05 241
以下代码是严蔚敏版数据结构的线性表链式结构的基本实现，同时结合王道复习书中的定义方法。函数名是严格按照严蔚敏版的数据结构来的，欢迎大家指正学习。目前各个函数基本测试完毕，能够正确运行，希望大家学习测试，如有错误请联系我。 1.操作集：link_list.h #ifndef link_list_h #define link_list_h #include <cstdlib> typedef struct LNode{ int data;//数据存储部分 struct LNo
单链表的各种操作
weixin_30616969的博客
09-23 146
删除： 　算法思想 查找：通过计数方式找到第i-1个结点，并由指针p指向它（因为删除的是第i个结点） 删除第i个结点并释放结点空间 #include<stdio.h> #include<stdlib.h> #define len sizeof(Node) typedef struct Node { int data; st...
线性表的基本操作和实现
weixin_43408374的博客
03-19 713
鉴于自己的数据结构知识较为薄弱，并且自己常常学完没几天又忘了，每次用起来都要去查阅，所以现在开个博客来记录自己在学数据结构过程中自己的一些学习总结，也可以加深自己的理解。 第一篇要总结的是线性表。 线性表：零个或多个相同特性的数据元素的有限序列。首先它是一个序列，元素之间是有顺序 的，第一个元素无前驱，最后一个元素无后继，其他的都有且只有一个前驱和后继。而所有元素按这种1对1的邻接关系构成的整体就...
线性表之链表基本操作的实现3
小男孩
05-21 299
这里，我们来实现双向循环链表的基本操作。 1.创建双向循环链表 DuLinkList CreateDuLinkList(DuLinkList L) //创建一个双向循环空链表 { L=(DuLinkList)malloc(sizeof(DuLNode)); L->next=L; //它的后驱指向自己 L->pr...
数据结构--线性表之链表实现
铭
06-23 396
参考：《数据结构--Java语言描述》 线性表的链式存储结构是用一组任意的存储单元来存放线性表的数据元素，这组存储单位可以是连续的，也可以是不连续的。 那么对于某一个元素如何找到下一个元素存放的位置？对于任意数据元素ai ,存在本身的的信息之外，还需要存储一个指示其直接后继元素存放位置的指针，这两部分组成数据元素ai的存储映像，被称之为结点 存储数据元素信息的称为数据域，存储直接后继存放位置的域称为指针域。如下图，单链表结点结构 单链表结点类的泛型定义如下： class Nod.
链表的基本操作（建立一有序的链表并实现线性表的基本操作（初始化、插入、删除、查找等）。）
mcxfate的博客
04-03 2192
实验内容 建立一有序的链表并实现线性表的基本操作（初始化、插入、删除、查找等）。 实验要求 （1）根据需求完成程序整体设计。 （2）根据整体设计，设计各个函数。 （3）完成程序代码，上机调试运行，得到实验结果。 （4）整理实验数据，撰写实验报告。 支撑的课程目标 本实验项目可以支撑课程目标1，2，3，4，5。通过本实验使学生掌握线性表的链式存储结构的特点，掌握线性表的基本操作（初始化、插入、删除、查找数据元素等）在链式存储结构上的实现，进行算法设计和程序实现，并能测试验证算法与程序的正确性。 完.
线性表与链表：定义、操作及C语言实现
例如，如果需要频繁地在表的开头或末尾进行操作，链表可能是更好的选择，因为它提供了O(1)的时间复杂度。而如果对随机访问的需求较高，且预知表的大小不会频繁变化，那么顺序表可能更合适，因为它提供了连续的内存...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值