单链表的各种基本运算

最新推荐文章于 2022-07-28 17:38:29 发布
最新推荐文章于 2022-07-28 17:38:29 发布
阅读量1.9k 收藏 9
点赞数 6
分类专栏： 数据结构 c-c++ 计算机基础 文章标签： c语言 单链表 devc++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq923132714/article/details/78623604
版权

单链表的各种基本运算

码文不易，如果帮助到您，希望您可以帮我刷一下点击量，与您无害，与我有益谢谢 支持原创 。

  欢迎大家阅读我的博客，如果有错误请指正，有问题请提问，我会尽我全力改正错误回答问题。在此谢谢大家。下面开始正式内容

單向鍊表（單鍊表）是鍊表的一種，其特點是鍊表的連結方向是單向的，對鍊表的訪問要通過從頭部開始，依序往下讀取。维基百科-单向链表


实验环境

  • 语言c/c++
  • 编译器devc++5.11/5.40


实验内容与要求

  1. 初始化单链表；
  2. 依次插入a,b,c,d,e元素；
  3. 输出单链表L；
  4. 输出单链表L的长度；
  5. 判断单链表L是否为空；
  6. 输出单链表L的第三个元素；
  7. 输出元素a的位置；
  8. 在第4个元素位置上插入f元素；
  9. 输出单链表L；
  10. 删除L的第3个元素；
  11. 输出单链表L；
  12. 释放单链表。


目录

码文不易，如果帮助到您，希望您可以帮我刷一下点击量，与您无害，与我有益谢谢 支持原创 。


实验解析

结构说明

   为了便于实现各种运算，通常在单链表的第一个结点前增设一个附加结点，称为头结点，它的结构与表结点相同，其数据域可不存储信息，也可存储表长等附加信息。单链表的结点结构除数据域外，还含有一个指针域。
  用C语言描述结点结构如下：

typedef  int  Status;
typedef  char    ElemType;
typedef struct  LNode{
    ElemType   data;
    struct  LNode  *next;
}LNode, *LinkList;


定义说明

#define  OK  1
#define  ERROR  0
#define  TRUE  1
#define  FALSE  0
typedef  int  Status;
typedef  char    ElemType;//这里表示链表存的是啥

  定义常用常量，类型别称


函数说明


顺序表函数

初始化顺序表
Status InitList_L (LinkList &L) {
    L = (LinkList)malloc(sizeof(LNode));//分配空间
    if (!L)   exit(0);//问题跳出
    L->next = NULL;//用于判断链表尾
    return  OK;//表示初始化成功
}// InitList_L

   给单项链表L分配空间 ，成功返回1，失败则结束程序。 使用链表一定要先初始化再使用


判空
Status EmptyList_L (LinkList L){
    if(L->next==NULL) //头结点就是尾节点说明什么呢？
        return OK;
    return ERROR;//如果不是呢？
}

  判断单项链表L是否为空，空返回1，不空为0


获取长度
int LengthList_L(LinkList L){
    LinkList p=L;
    int i=0;
    while(p->next!=NULL){//当p节点的下一个是空了说明什么？
        i++;
        p=p->next;
    }
    return i;
}

  返回链表L表长度


打印
Status DisplayList_L ( LinkList L) {
    LinkList p=L->next;
    while(p!=NULL){// 都是一个套路
        printf("%c",p->data);//这是输出嘛
        p=p->next;//又是你
    }
    printf("\n");//\n是啥呢？我觉得bai度一下你会记得更清楚
    return OK;
}

  打印链表中的值到屏幕


插入
Status ListInsert_L(LinkList &L, int i, ElemType e)  {
    LinkList l1=(LinkList)malloc(sizeof(LNode)) ;//又见面了，因为链表每次只给一个节点申请空间，所以要变大变长就要满满积累喽！
    LinkList  p = L;
    int j;
    for(j = 0; j<i-1;j++){//这个可以算是高级版的while
        p = p->next;      
    }   
    if(!p||j>i-1)   //||是或的意思 与或非门学过没，不懂就度度，if要是都不知道就别说学过英语了
        return ERROR;      
    l1->data = e;//data是存值的地方
    l1->next = p->next;//变长
    p->next = l1; //变长
    return OK;
}//ListInsert_L

  将元素e插入链表L的第i位，成功返回1，失败返回0


添加
Status ListAdd (LinkList L , ElemType e){//明明上面那个货就能做了，要你有个屁用？也就省了一步查链表长度嘛
    LinkList p=L;
    while(p->next){//怎么老有你
        p=p->next;
    }
    LinkList l1  = (LinkList)malloc(sizeof(LNode));//老熟人了
    l1->data = e;
    l1->next = NULL;    
    p->next = l1; 
    return OK;
}

  将元素e加到链表L尾端，成功返回1，失败返回0


删除
Status ListDelete_L(LinkList &L, int i, ElemType &e) {//与插入差不多嘛
    LinkList q ,p = L;  
    int j;
    for(j = 0; j<i-1;j++)
        p =p->next;
    if(!p->next|| j>i-1)   
        return ERROR;  
    q= p->next;
    p->next = q->next;
    e =q->data;
    free(q);
}//ListDelete_L

   删除链表L第i个元素并保存该元素到变量e，成功返回1，失败返回0


倒置
Status ListInverted(LinkList L,LinkList IL){
    LinkList p=L->next;
    while(p!=NULL){ //轻车熟路，老汉推车
        ElemType e = p->data; 
        ListInsert_L(IL, 1, e); //这是在吸取我的资源，不要模仿我，你以为倒立就不认识你了吗
        p = p->next ;
    }   
    return OK;
}

   将链表L中元素顺序倒置并保存为链表IL，成功返回1，失败返回0
   因为单链表只能从前往后找，想回个头很难，想直接倒着输出更是难上加难，不如直接生成一个倒置的，便于倒序。


查询
Status GetElemList_L (LinkList L, int i, ElemType &e) {
    int j=0;
    LinkList p=L;
    while(j<i&&p){//有个新面孔&&这是与，或的兄弟，你懂得
        ++j;
        p=p->next;
    }
    if(!p||j>i)  //这说明什么？你在我心中根本没有位置！
        return ERROR;
    e=p->data;
    return OK;
}

  获取链表L的第i个元素，存到变量e中，成功返回1，失败返回0

Status  LocateElemList_L(LinkList L,ElemType e) {   
    int i=0;
    LinkList p=L;
    while(p!=NULL&&p->data!=e) {
        ++i;
        p=p->next;
    }
    if(p==NULL) 
        return 0;
    else 
        return i;
}

  获取链表L中e元素第一次出现的位置，成功返回元素位置，失败返回0


释放
Status DestroyList_L (LinkList &L)  {
    LinkList p,q;
    p=L;
    q=p->next;
    while(q!=NULL){
        free(p);//这是对指针的操作，释放指针，不懂百度哦
        p=q;
        q=p->next;
    }
    free(p);
    return  OK;
}

   释放传入的顺序表，成功返回1，失败返回0



主函数

码文不易，如果帮助到您，希望您可以帮我刷一下点击量，与您无害，与我有益谢谢 支持原创 。

int main(){
    SqList L;
    ElemType e;
    printf("(1)初始化顺序表\n");
    InitList_Sq(L);

    printf("(2)依次插入a,b,c,d,e元素\n");
    ListInsert_Sq(L,1,'a');
    ListInsert_Sq(L,2,'b');
    ListInsert_Sq(L,3,'c');
    ListInsert_Sq(L,4,'d');
    ListInsert_Sq(L,5,'e');
    ListInsert_Sq(L,3,'q');
    ListInsert_Sq(L,1,'q');

    printf("(3)输出顺序表:"); 
    DisplayList_Sq(L);

    printf("(4)顺序表的长度=%d\n",LengthList_Sq(L));

    printf("(5)顺序表为%s\n",(EmptyList_Sq(L)?"空":"非空"));
    GetElemList_Sq(L,3,e);

    printf("(6)顺序表的第三个元素是%c\n",e);

    printf("(7)元素a的位置=%d\n",LocateElemList_Sq(L,'a'));

    printf("(8)在第四个元素插入元素f\n");
    ListInsert_Sq(L,4,'f');

    printf("(9)输出顺序表:");
    DisplayList_Sq(L);

    printf("(10)删除第三个元素\n");
    ListDelete_Sq(L,3,e);

    printf("(11)f元素第一次出现的位置:");
    printf("%d\n",LocateElemList_Sq(L,'f'));

    printf("(12)输出顺序表:");
    DisplayList_Sq(L);

    printf("(13)释放顺序表\n");
    DestroyList_Sq(L);
}


结果展示

顺序表的各种基本运算


附录

相关资料

  1. 维基百科-单向链表


源代码

码文不易，如果帮助到您，希望您可以帮我刷一下点击量，与您无害，与我有益谢谢 支持原创 。

#include<stdio.h>   //EOF,NULL
#include<malloc.h>  //malloc()
#include<process.h>  //exit()

#define  OK  1
#define  ERROR  0
#define  TRUE  1
#define  FALSE  0

typedef  int  Status;
typedef  char    ElemType;
typedef struct  LNode{
    ElemType   data;
    struct  LNode  *next;
}LNode, *LinkList;

Status InitList_L (LinkList &L) {
    L = (LinkList)malloc(sizeof(LNode));
    if (!L)   exit(0);
    L->next = NULL;
    return  OK;
}// InitList_L  

Status DestroyList_L (LinkList &L)  {
    LinkList p,q;
    p=L;
    q=p->next;
    while(q!=NULL){
        free(p);
        p=q;
        q=p->next;
    }
    free(p);
    return  OK;
}

Status EmptyList_L (LinkList L){
    if(L->next==NULL) 
        return OK;
    return ERROR;
}

Status LengthList_L(LinkList L){
    LinkList p=L;
    int i=0;
    while(p->next!=NULL){
        i++;
        p=p->next;
    }
    return i;
}

Status DisplayList_L ( LinkList L) {
    LinkList p=L->next;
    while(p!=NULL){
        printf("%c",p->data);
        p=p->next;
    }
    printf("\n");
    return OK;
}

Status ListInsert_L(LinkList &L, int i, ElemType e) {
    LinkList l1=(LinkList)malloc(sizeof(LNode)) ;
    LinkList  p = L;
    int j;
    for(j = 0; j<i-1;j++){
    p = p->next;     
    }      
    if(!p||j>i-1)   
        return ERROR;      
    l1->data = e;
    l1->next = p->next;
    p->next = l1;
    return OK; 
}//ListInsert_L

Status ListDelete_L(LinkList &L, int i, ElemType &e) {
    LinkList q ,p = L;  
    int j;
    for(j = 0; j<i-1;j++)
        p =p->next;
    if(!p->next|| j>i-1)   
        return ERROR;  
    q= p->next;
    p->next = q->next;
    e =q->data;
    free(q);
}//ListDelete_L

Status ListAdd (LinkList L , ElemType e){
    LinkList p=L;
    while(p->next){
        p=p->next;
    }
    LinkList l1  = (LinkList)malloc(sizeof(LNode));
    l1->data = e;
    l1->next = NULL;    
    p->next = l1; 
} 

Status ListInverted(LinkList L,LinkList IL){
    LinkList p=L->next;
    while(p!=NULL){ 
        ElemType e = p->data; 
        ListInsert_L(IL, 1, e); 
        p = p->next ;
    }   
} 

Status GetElemList_L (LinkList L, int i, ElemType &e) {
    int j=0;
    LinkList p=L;
    while(j<i&&p){
        ++j;
        p=p->next;
    }
    if(!p||j>i)  
        return ERROR;
    e=p->data;
    return OK;
}

Status  LocateElemList_L(LinkList L,ElemType e) {   
    int i=0;
    LinkList p=L;
    while(p!=NULL&&p->data!=e) {
        ++i;
        p=p->next;
    }
    if(p==NULL) 
        return 0;
    else 
        return i;
}

int main(){
    LinkList L,IL;
    ElemType e;
    printf("(1)初始化单链表\n");
    InitList_L(L);
    InitList_L(IL);
    printf("(2)依次插入a,b,c,d,e元素\n");
    ListInsert_L(L,1,'a');
    ListInsert_L(L,2,'b');
    ListInsert_L(L,3,'c');
    ListInsert_L(L,4,'d');
    ListInsert_L(L,5,'e');
    ListInsert_L(L,1,'b');//头插入法
    ListAdd(L,'q');//尾插入法 
    printf("(3)输出单链表:");
    DisplayList_L(L);
    ListInverted(L,IL);//倒置 
    printf("(3.5)输出倒置单链表:");
    DisplayList_L(IL);
    printf("(4)单链表的长度=%d\n",LengthList_L(L));
    printf("(5)单链表为%s\n",(EmptyList_L(L)?"空":"非空"));
    GetElemList_L(L,3,e);
    printf("(6)单链表的第三个元素是%c\n",e);
    printf("(7)元素a的位置=%d\n",LocateElemList_L(L,'a'));
    printf("(8)在第四个元素插入元素f\n");
    ListInsert_L(L,4,'f');
    printf("(9)输出单链表:");
    DisplayList_L(L);
    printf("(10)删除第三个元素\n");
    ListDelete_L(L,3,e);
    printf("(11)输出单链表:");
    DisplayList_L(L);
    printf("(12)释放单链表\n");
    DestroyList_L(L);
}

码文不易，如果帮助到您，希望您可以帮我刷一下点击量，与您无害，与我有益谢谢 支持原创 。

logic923
关注
  • 6
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
三、单链表的基本运算
正义
06-04 2274
查找运算(带头结点) （1）按结点序号查找 在单链表中要查找第 i 个结点，就必须从链表的第1个结点(开始结点，序号为1)开始，序号为0的是头结点，p指向当前结点，j为计数器，初始值为1，当p扫描下一个结点时，计数器加1。当 j=i 时，指针 p 指向的节点就是要找的节点。 /* 按节点序号查找 head 为带头节点的单链表的头指针， i为要查找的节点序号 */ ListNo...
单链表的基本操作及实现详解
ENSHADOWER的博客
10-01 2756
链表是最基本的线性数据结构之一，单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。  一、单链表的概述     1.单链表的分类           单链表的最大特点是可以将物理地址上不连续的数据连接起来，通过指针来对物理地址进行操作，实现增删改查等功能。           单链表分为两种：无头单链表和有头单链表。        ...
单链表的基本运算
m0_38129299的博客
08-22 225
数据结构 typedef struct LNode { int data; struct LNode* next; }LNode; 生成 void CreateLList( LNode**head) { *head = (LNode*)malloc(sizeof(LNode)); (*head)->next = NULL; LNode* Tail = *head; int n; printf("输入元素个数"); scanf_s("%d", &n); LNode*
【考研数据结构之】——3.单链表及基本运算
zhangchuanyang_的博客
07-28 291
对于求一个链表的长度，我们只需要对链表进行遍历。令暂存指针 p=head，使其进行后移操作，用 i 进行计数，直到p->next为空（也就是后面没有元素为止）。
单链表——单链表的定义及基本操作（初始化、头插法尾插法建表、查找、插入、删除、判空等）
热门推荐
薛定谔的猫的博客
04-17 9万+
文章目录单链表的定义单链表上的操作初始化建立单链表头插法建立单链表尾插法建立单链表遍历单链表求单链表的长度查找操作按值查找按位查找插入操作删除操作完整代码及实例 单链表的定义   由于顺序表的插入删除操作需要移动大量的元素，影响了运行效率，因此引入了线性表的链式存储——单链表。单链表通过一组任意的存储单元来存储线性表中的数据元素，不需要使用地址连续的存储单元，因此它不要求在逻辑上相邻的两个元素在物理位置上也相邻。   单链表的特点： 单链表不要求逻辑上相邻的两个元素在物理位置上也相邻，因此不需要连续的存储
数据结构 实验一：实现单链表各种基本运算的算法.doc
05-30
数据结构实验一实现单链表各种基本运算的算法 本文档是关于数据结构实验的一部分，旨在实现单链表各种基本运算的算法。实验的主要目的是掌握单链表存储结构的类型定义，并实现单链表各种基本运算的算法。 实验环境...
单链表操作基本运算_单链表的基本操作_
10-03
这个压缩包文件“单链表操作基本运算”包含了关于如何在编程中实现单链表基本操作的详细内容，特别是插入和删除操作。 单链表的插入操作通常分为头插法和尾插法。头插法是在链表的开头添加新节点，这需要更新头节点...
单链表的各种基本运算的算法.zip
04-23
这个名为"单链表的各种基本运算的算法.zip"的压缩包文件显然包含了一些关于C语言实现单链表基本操作的算法。我们将深入探讨这些知识点。 首先，单链表是由一系列节点组成的，每个节点包含两部分：数据域（用于存储...
单链表的基本运算.cpp
最新发布
09-18
单链表的基本运算.cpp
实现循环单链表的各种基本运算的算法
04-17
数据结构与算法 李春葆 第五版实验报告2.22 含代码和结果
数据结构单链表的基本操作及实现(C/C++)
06-03
数据结构单链表的基本操作及实现(C/C++)，包括初始化、创建链表、插入元素、删除元素、获取指定位置的元素等
单链表作业，包括链表的声明及主函数的实现
10-03
单链表的作业，包括了链表的声明和主函数的实现。编译测试都成功了，这是我的作业，传上来与大家分享。我体会大家的难处.....
数据结构——C语言实现单链表各种基本运算的算法
Mencre的博客
10-16 8387
 linklist.cpp #include "stdio.h" #include "malloc.h" typedef char ElemType; typedef struct LNode{ ElemType data; struct LNode *next; //指向后继结点 } LinkNode; //声明单链表节点类型 //头插法建立单链表 void Create...
数据结构-单链表的基本操作
西风的博客
11-01 2816
题目要求： 编写一个程序，实现以下单链表的基本操作（单链表的元素类型elem type为char） （1）初始化单链表 h  (2)依次插入a,b,c,d,e五个元素  (3)输出单链表h  (4)  输出单链表h的长度  (5)判断单链表h是否为空  (6)  输出单链表h的第3个元素  (7)输出元素a的位置  (8)在第4个元素位置上插入元素f  (9)输出单链表h  (10)删除h的第
C语言实现单链表（带头结点）的基本操作
乞力马扎罗的雪CYF的博客
03-01 1万+
我在之前一篇博客《C语言实现单链表（不带头结点）的基本操作》中具体实现了不带头结点的单链表的11种操作：如计算链表长度、初始化、创建链表、清空链表等等。但是在实际使用中，带头结点的单链表往往比不带头结点的单链表用的更多，使用也更为方便。因为不用单独考虑第一个节点的情况了，第一个节点和其他后续节点的处理全都一样了，简化操作。这篇博客将会来实现带头结点的单链表的11种操作。代码上传至： https:/
实现链栈各种基本运算的算法
小凤的博客
01-27 5575
/*algo3-2.cpp*/ #include #include typedef char ElemType; typedef struct linknode {  ElemType data;/*数据域*/  struct linknode *next;/*指针域*/ }LiStack; void InitStack(LiStack * &s) {  s=(LiStack
C语言 循环单链表各种基本运算的算法
xiaoduo
09-06 4413
//实现循环单链表各种基本运算的算法 #include #include typedef struct LNode {  int data;  struct LNode *next; }LinkList; //新建一个只含头结点的空循环链表 void InitList(LinkList *&L) {  L=(LinkList *)malloc(sizeof(LinkList)

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值