单链表的基本操作

于 2024-09-12 16:25:00 发布
阅读量833 收藏 16
点赞数 14
文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64334556/article/details/142164222
版权

文章目录

前言

例如：随着不段的学习深入，我们发现，线性表虽然可以随机存取表中任意一个元素，但是插入删除操作需要移动大量的元素，为此，引入了单链表。

提示：以下是本篇文章正文内容，下面案例可供参考

一、单链表是什么？

线性表的链式存储，即单链表。它通过一组任意的存储单元来存储线性表中的元素。

1.单链表结点结构

在单链表中，对于每一个结点，有着存放数据信息的data,和指向后继的null。
下面展示一些代码。

单链表结构特征

#include <stdio.h>
#include <stdlib.h>
#define ElemType int
struct LNode{ //定义单链表的结点的结构体
ElemType data; //数据域
struct LNode *next; //指针阈
};

二、单链表的基本操作

1.单链表初始化

方式1

int InitList1(){
struct LNode *L;
L=(struct LNode*)malloc(sizeof(LNode));
if (L==NULL){
return 0;}
L->next=NULL;
return 1;
}

方式2

//方式2
int Initlist2(struct LNode **L){
*L=(LNode*)malloc(sizeof(LNode));
if(*L==NULL){
return 0;
}
(*L)->next=NULL;
return 1;
}

方式3
在王道的书籍中，其对单链表的初始化操作为

//方式3
bool Initlist3(LinkList &L){  //带头结点单链表的初始化
L=(LNode*)malloc(sizeof(LNode)); //创建头结点
L->next=NULL;                //头结点后暂时无元素结点
return ture;
}

但是在C语言中，不能够这样使用，上为C++的操作。因为在C语言中，没有bool类型，且C语言中形参不可用&，但是可以使用*操作来替代。上述代码中的LinkList实际上是对struct LNode *的简写即重命名。此操作需要在定义结构体时，使用typdef进行修饰。具体操作如下

typdef struct LNode{
Elemtype data;
struct LNode *next;
}LNode,*LinkList;  //其中LNode表示结点。
//LinkList 是 struct LNode * 的别名，表示指向链表结点的指针。
//通常，LinkList 被用来表示整个链表的 头指针，即指向链表第一个结点的指针。

方式4
如果在C语言下实现单链表的初始化，则需要下面的操作，实际上就是将方式2中的struct LNode*替换成了LinkList，体现了代码的简洁性。

//方式4
int Initlist4(LinkList *L){//L为指向链表的指针的指针。选择*L作为参数，是为了访问并修改指向链表的指针
*L=(LNode*)malloc(sizeof(LNode));  //*L为指向结点的指针。
//在动态为结构体分配内存时，我们需要一个指向结构体的指针，该指针用于存储内存地址。
if(*L==NULL){
return 0;
}
(*L)->next=NULL;
return 1;
}

上述代码中出现了很多的指针，应该如何去理解呢？
对于一级指针*n
&n 自身地址
n 指向地址
*n 指向地址值
对于二级指针**n
&n 自身地址
n 一级指针地址
*n 一级指针指向地址
**n 一级指针指向地址值
如方式4中L指向指向链表的指针，即一级指针地址。
*L指向链表的第一个结点，即一级指针指向的地址。

2.单链表求表长

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

3.单链表按序号查找结点

//按序号查找  结点,即寻找的是Lnode。找什么就设什么。
LNode* GetElem(LinkList L,int i) {
   LNode*P=L;     //指针P指向当前扫描到的结点。因为若按序号查找，若序号为0，即头结点，所以令指针指向头结点。
    int j=0;     // 记录当前结点的位序，头结点是第0个结点
   while (P!=NULL&&j<i) {//循环找到第i个结点
       P=P->next;
       j++;
   }
    return P;    //返回第i个结点的指针或Null。
}

4.单链表按值查找结点


//按值查找结点
LNode* LocateElem (LinkList L,ElemType e) {
    LNode *P=L->next;       //头结点一定不存储数据，于是便让指针从序号为1的结点开始
    while (P!=NULL&&e!=L->data) {
        P=P->next;
    }
    return P;
}

5.单链表插入结点操作


//插入结点操作
int Listinsert(LinkList *L,int i,ElemType e) {  //L为被插入的结点，因为值发生改变，所以需要使用&。i为插入序号，e为插入数据。
    LNode *P=*L;   //指针P指向当前扫描到的结点。
    int j=0;
      while (P!=NULL&&j<i-1) {
          P=P->next;
          j++;
      }//这一步的操作即按照序号查找结点。不过结点需要找的是结点i的前一个结点，新结点的前驱即P(i-1)，后驱是曾经的P(i-1)->next。
    if(P==NULL) {
        return 0;  //i值不合法
    }
    else {
        LNode *S=(LNode*)malloc(sizeof(LNode));
        S->data=e;
        S->next=P->next;
        P->next=S;
        return 1;
    }

}

6.单链表删除结点操作

//删除结点操作
int  ListDelete(LinkList *L,int i,ElemType *e) {  //e储存被删除结点的数据，可以加*也可以不加*，不影响结点的删除。
    LNode*P=*L;
    int j=0;
    while (P!=NULL&&j<i-1) {
        P=P->next;
        j++;
    }
    if(P==NULL) {
        return 0;
    }else {
       LNode*Q=P->next;  //Q指向被删除结点
        *e=Q->data;     //将删除结点的 数据储存到e中
        P->next=Q->next;  //将删除结点断开
        free(Q);    //释放删除结点内存
        return 1;
    }
}

7.头插法建立单链表

//利用头插法建立单链表
LinkList List_HeadInsert(LinkList *L) {  //逆项建立单链表
    LNode*s;
    int x;      //设置元素类型为整型。
    *L=(LNode*)malloc(sizeof(LNode));//创建头结点
if (*L == NULL) {  // 检查内存分配是否成功
    printf("Memory allocation failed.\n");
    exit(1);
}
    (*L)->next=NULL;  //初始化为空链表。
    scanf("%d",&x);
    while (x!=9999) {
        s=(LNode*)malloc(sizeof(LNode));
if (s == NULL) {  // 检查内存分配是否成功
    printf("Memory allocation failed.\n");
    exit(1);
}
        s->data=x;
        s->next=(*L)->next;
        (*L)->next=s;
        scanf("%d",&x);
    }
    return *L;
}

8.尾插法建立单链表

LinkList List_TailInsert(LinkList *L) {  //逆项建立单链表
    int x;      //设置元素类型为整型。
    *L=(LNode*)malloc(sizeof(LNode));//创建头结点
    if (*L == NULL) {  // 检查内存分配是否成功
        printf("Memory allocation failed.\n");
        exit(1);
    }
    (*L)->next=NULL;
LNode *r=*L;  //r为尾指针
    printf("Enter elements (enter 9999 to stop):\n");
    scanf("%d",&x);
    while (x!=9999) {
    LNode*    s=(LNode*)malloc(sizeof(LNode));
        if (s == NULL) {  // 检查内存分配是否成功
            printf("Memory allocation failed.\n");
            exit(1);
        }
        s->data=x;
        s->next=NULL;
        r->next=s;
      r=s;
        scanf("%d",&x);
    }
    return *L;
}

三、总结

下为完整的代码部分。

#include <stdio.h>
#include <stdlib.h>

typedef int ElemType; // 定义 ElemType 为 int
typedef struct LNode {
    ElemType data;          // 数据域
    struct LNode *next;     // 指针域，指向下一个结点
} LNode, *LinkList;         // LNode 表示单个结点，LinkList 表示指向链表头指针

// 1. 单链表初始化操作
int Initlist(LinkList *L) {
    *L = (LNode *)malloc(sizeof(LNode)); // 分配内存给头结点
    if (*L == NULL) {
        return 0; // 内存分配失败
    }
    (*L)->next = NULL; // 初始化为空链表
    return 1; // 初始化成功
}

// 2. 求单链表长度
int length(LinkList L) {
    int len = 0;
    LNode *P = L->next; // 从第一个数据结点开始遍历
    while (P != NULL) {
        len++;
        P = P->next;
    }
    return len;
}

// 3. 按序号查找结点
LNode* GetElem(LinkList L, int i) {
    int j = 0;
    LNode *P = L; // 从头结点开始查找
    while (P != NULL && j < i) {
        P = P->next;
        j++;
    }
    return P; // 返回第i个结点的指针或NULL
}

// 4. 按值查找结点
LNode* LocateElem(LinkList L, ElemType e) {
    LNode *P = L->next; // 从第一个数据结点开始
    while (P != NULL && P->data != e) {
        P = P->next;
    }
    return P; // 返回存储数据e的结点指针或NULL
}

// 5. 单链表插入结点操作
int ListInsert(LinkList *L, int i, ElemType e) {
    LNode *P = *L;
    int j = 0;
    while (P != NULL && j < i - 1) { // 找到第i-1个结点
        P = P->next;
        j++;
    }
    if (P == NULL) {
        return 0; // i值不合法
    }
    LNode *S = (LNode *)malloc(sizeof(LNode)); // 分配新结点的内存
    if (S == NULL) {
        return 0; // 内存分配失败
    }
    S->data = e;     // 插入数据
    S->next = P->next; // 新结点指向原来的后继
    P->next = S;     // 第i-1个结点指向新结点
    return 1;
}

// 6. 单链表删除结点操作
int ListDelete(LinkList *L, int i, ElemType *e) {
    LNode *P = *L;
    int j = 0;
    while (P != NULL && j < i - 1) { // 找到第i-1个结点
        P = P->next;
        j++;
    }
    if (P == NULL || P->next == NULL) {
        return 0; // i值不合法
    }
    LNode *Q = P->next; // 找到待删除结点
    *e = Q->data;       // 保存待删除结点数据
    P->next = Q->next;  // 将第i-1个结点指向第i+1个结点
    free(Q);            // 释放第i个结点
    return 1;
}

// 7. 头插法建立单链表
LinkList List_HeadInsert(LinkList *L) {
    LNode *s;
    int x;      // 设置元素类型为整型
    *L = (LNode *)malloc(sizeof(LNode)); // 创建头结点
    if (*L == NULL) {  // 检查内存分配是否成功
        printf("Memory allocation failed.\n");
        exit(1);
    }
    (*L)->next = NULL;  // 初始化为空链表
    scanf("%d", &x);
    while (x != 9999) {
        s = (LNode *)malloc(sizeof(LNode));
        if (s == NULL) {  // 检查内存分配是否成功
            printf("Memory allocation failed.\n");
            exit(1);
        }
        s->data = x;
        s->next = (*L)->next;
        (*L)->next = s;
        scanf("%d", &x);
    }
    return *L;
}

// 8. 尾插法建立单链表
LinkList List_TailInsert(LinkList *L) {
    int x;      // 设置元素类型为整型
    *L = (LNode *)malloc(sizeof(LNode)); // 创建头结点
    if (*L == NULL) {  // 检查内存分配是否成功
        printf("Memory allocation failed.\n");
        exit(1);
    }
    (*L)->next = NULL;
    LNode *r = *L;  // 尾指针
    scanf("%d", &x);
    while (x != 9999) {
        LNode *s = (LNode *)malloc(sizeof(LNode));
        if (s == NULL) {  // 检查内存分配是否成功
            printf("Memory allocation failed.\n");
            exit(1);
        }
        s->data = x;
        s->next = NULL;
        r->next = s;
        r = s;
        scanf("%d", &x);
    }
    return *L;
}

int main() {
    LinkList L;
    int init_result = Initlist(&L);
    if (init_result) {
        printf("单链表初始化成功！\n");
    } else {
        printf("单链表初始化失败！\n");
    }

    int len = length(L);
    printf("单链表长度为：%d\n", len);

    LNode* found_node = GetElem(L, 2);
    if (found_node) {
        printf("按序号查找成功，第 2 个节点的数据为：%d\n", found_node->data);
    } else {
        printf("按序号查找失败！\n");
    }

    found_node = LocateElem(L, 5);
    if (found_node) {
        printf("按值查找成功，值为 5 的节点找到。\n");
    } else {
        printf("按值查找失败！\n");
    }

    int insert_result = ListInsert(&L, 3, 10);
    if (insert_result) {
        printf("插入节点成功！\n");
    } else {
        printf("插入节点失败！\n");
    }

    int delete_result;
    ElemType deleted_data;
    delete_result = ListDelete(&L, 4, &deleted_data);
    if (delete_result) {
        printf("删除节点成功，删除的数据为：%d\n", deleted_data);
    } else {
        printf("删除节点失败！\n");
    }

    LinkList head_insert_list = List_HeadInsert(&L);
    printf("头插法建立单链表结果：\n");
    LNode* temp = head_insert_list->next;
    while (temp) {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("\n");

    LinkList tail_insert_list = List_TailInsert(&L);
    printf("尾插法建立单链表结果：\n");
    temp = tail_insert_list->next;
    while (temp) {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("\n");

    return 0;
}
数据结构-单链表基本操作-C语言代码
suxiaorui的博客
01-22 6万+
单链表基本操作 1.头插法建立单链表 2.尾插法建立单链表 3.查找结点 3.修改结点 4.插入结点 5.删除结点 本篇只有c语言代码，具体思路讲解请看这篇博客：数据结构-线性结构-单链表 1.头插法建立单链表 #include<stdio.h> #include<stdlib.h> //单链表的结构定义 typedef struct LNode { int data...
单链表的基本操作！！！
weixin_41445507的博客
06-06 331
//定义typedef int DataType;typedef Sstruct SListNode { DataType data;  struct ListNode *pNext; // 指向下一个结点 } SListNode;//开辟新结点SListNode _GreateNewNode(DataType data){ SListNode*pNewNode = (SListNode*)mal...
单链表的常用基本操作
lutongbin的专栏
12-18 472
<br />//单链表的常用基本操作.cpp<br />#include<iostream><br />using namespace std;<br />typedef struct Node{<br /> char name[10];<br /> int age,score;<br /> struct Node* next;<br />}ListNode;<br />ListNode* Create_emptylist(void)   //创建空链表，带头结点------------1<br />{<b
单链表的一些基本操作
pigff的博客
06-19 394
顺序表与链表各自的优缺点： 1. 顺序表支持随机访问，单链表不支持随机访问。 2. 顺序表插入 / 删除数据效率很低，时间复杂度为O(N)（除尾插尾删），单链表插入 / 删除效率更高，时间复杂度为O(1)。 3. 顺序表的CPU高速缓存效率更高，单链表CPU高速缓存效率低 1.倒着打印单链表 void PrintTailToHead(ListNode* pList)//倒着打印单
单链表的基本操作（创建、销毁、增删查改等）
qq_44631587的博客
01-05 2008
链表分类 链表主要有下面三种分类方法： 单向或者双向 带头或者不带头 循环或者非循环 综合来看链表有八种类型，本文主要针对的是不带头节点的非循环单链表。 单链表的介绍 typedef struct SListNode { DataType data;//数据域 struct SListNode *next;//结构体指针，指向下一个节点 }SListNode;//类型别名 如图 链表的每一个节点由数据域和指针域构成，数据域存放数据，指针域中的指针指向下一个节点。plist表示链表的指针，指向链表
单链表的基础操作
eminemi的博客
07-19 2865
在学习数据结构的过程中，首先接触到的就是线性表，线性表中的单链表，博主在一开始的时候真的是一头雾水，首先是对于指针的了解甚浅，其次是觉得这玩意太抽象了。但是后来重新看了之后发现，这玩意儿，也就这样吧！下面，以单链表为例，展开单链表的一些基础操作。...
单链表基本操作.rar
04-01
这个压缩包文件“单链表基本操作.rar”包含了一个名为“单链表基本操作.docx”的文档，我们可以从中学习到关于单链表的各种核心概念和操作。 单链表是由一系列节点构成的线性数据结构，每个节点包含两部分：数据域...
基于Java实现的单链表基本操作之链表排.zip
最新发布
04-26
在这个基于Java实现的单链表基本操作项目中，我们主要关注的是链表的排序。下面将详细讲解单链表的基本概念、Java中如何实现单链表以及如何进行链表排序。 **一、单链表的基本概念** 单链表是由一系列节点组成的...
基于Java实现的单链表基本操作之链表合并.zip
04-26
本项目聚焦于Java实现的单链表基本操作，特别是链表的合并这一关键操作。下面将详细介绍单链表的概念、基本操作以及如何在Java中实现链表合并。 单链表是一种线性数据结构，每个节点包含两部分：数据域，用于存储...
基于Java实现的单链表基本操作之链表反转.zip
04-26
在这个基于Java实现的单链表基本操作中，我们将重点关注链表反转这一特定操作。 链表反转是编程面试中常见的问题，它要求我们改变链表中节点的顺序，使得原链表的最后一个节点成为新链表的第一个节点，原链表的第一...
单链表的基本操作---插入，删除，交，并，相邻元素的交换等
weixin_30797027的博客
12-23 170
这个链表是带有表头的单链表。实现链表的一些规范操作，初始化，插入，删除等。包括两个头文件list.h，fatal.h，库函数list.c，测试函数testlist.c。头文件放的都是函数声明，库函数list.c放的的函数的定义。 头文件list.h 1 typedef int ElementType; 2 #ifndef _List_H//如果没有编译过 3 st...
【单链表的基本操作】
w_9420的博客
12-10 1006
链表的基本操作
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值