【单链表的基本操作】

最新推荐文章于 2023-10-12 16:11:40 发布
最新推荐文章于 2023-10-12 16:11:40 发布
阅读量596 收藏
点赞数
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w_9420/article/details/128260544
版权

人生如棋，我愿为卒，行走虽慢，可有谁见我后退一步？

目录

单链表

链表是线性表的链式存储方式。逻辑上相邻的数据在计算机内的存储位置中不一定相邻。链式存储：通过指针串起来。

单链表的存储方式

链式结构中，除了要存储数据元素外，还要存储它的后继元素（下一个结点）的地址。我们把存储数据元素的信息的域称数据域，存储它的后继元素（下一个结点）位置的域称为指针域。这两部分信息组成数据元素的a[i]的存储映像，称为结点（Node）。因此指针都指向下一个结点，都朝一个方向的，这样的链表称为单链表。单链表的存储方式如下图所示：
在这里插入图片描述
对于线性表来说，有头有尾，链表也不意外，为了操作方便，还会给链表增加一个不存放数据的头节点（也可以存放表长等信息，整个链表的存取就必须从头指针开始，我们只要牵住头指针就相当于牵住了整个单链表。注头节点不算真节点，辅助用 那么最后一个结点的位置指向哪里呢？最后一个结点的后继不存在所以我们规定链表的最后一个结点指针为NULL（空）。NULL在链表中往往作为链表结束的判断标志如下图。
在这里插入图片描述

单链表的节点结构体定义

#ifndef LIST_H
#define LIST_H
 typedef int data_t; //为int取个名字叫data_t
 typedef struct node
 {
   data_t data; //数据域
   struct node *next;//指针域，保存下一个结点的地址>    。
}NODE;//用typwdef将结构体等价于类型名NODE

假设p是指向链表第i个元素的指针，则该结点a[i]的数据域我们可以表示为a->data。a[i]的指针域可以表示为p->next，p->next 指向a[i+1]的地址（指针）那么a[i+1]的数据域可以表示为p->next->data.
在这里插入图片描述

单链表的基本操作

//1.创建头结点 NODE *create_list(void);

//2.判空, 1为空 int empty_list(NODE *head);

//3.求链表长度 int length_list(NODE *head);

//4.按位置插入结点，需要传三个即头结点、要插入的位置> ，要插入的值 int insrert_listpos(NODE *head, int pos,data_t data);

//5.按位置删除链表，需要传递头结点和删除的位置 int delete_linklistpos(NODE *head,int pos);

//6.安置查找，返回地址.所以我们要遍历整个结点 NODE *find_listdata(NODE *head,data_t data);

//7.安置删除链表结点 int delete_listpos(NODE *head, data_t data);

//8.按位置查找，返回地址 NODE *findlistpos(NODE *head, int pos);

//9.按值修改链表 int update_listdata(NODE *head,data_t old_data,data_t, new_data);

//1o.清空链表,即链表只剩头结点 void clear_list(NODE *head);

//11.销毁链表 void destory_list(NODE **head);

//12.链表的输出 void printf_list(NODE *head);

1.创建头结点

//1.创建头结点
NODE *create_list(void)
{
    NODE *head = (NODE*)malloc(sizeof(NODE));//利用malloc函数为头结点申请空间，一个结点包含数据域和指针域。
    if(NULL == head)//判断头结点的空间是否申请成功。
    {
        return NULL;
    }
    head->data = -1;//头结点的数据初始化，无意义。
    head->next = NULL;//头结点的数据初始化，无意义.
    return head;
}

2.判空

//2.判空, 1为空
int empty_list(NODE *head)
{
    if(NULL != head)//判断头结点是否申请成功
    {
        return ((head->next==NULL) ? 1 : 0);//如果头结点的指针域是空则返回1，反之返回0；
    }
    else
        return -1;//异常
}

3.求链表长度

//3.求链表长度
int length_list(NODE *head)
{
    if(NULL == head)
    {
        return -1;
    }
    int len = 0;//定义变量len,累加求长度。
    NODE *p = head->next;//定义一个结构体指针p,指向头结点下一个结点（有效结点）
    while(p != NULL)//遍历整个链表，直到p==NULL时退出循环
    {
        len++;      
        p=p->next;//len自加后，指针p移动到下一个结点。
    }
    return len;
}

4.按位置插入结点

在这里插入图片描述
在这里插入图片描述

//4.按位置插入结点，需要传三个即头结点、要插入的位置，要插入的值

int insrert_listpos(NODE *head, int pos,data_t data)
{
    //1.判断pos插入位置的合法性0~lend
    int len=length_list(head);
    if(pos < 0 || pos >len)
    {
        return -1;
    }
    //2.准备新的结点
    NODE *new = (NODE *)malloc(sizeof(NODE));//为新结点开空间
    if(NULL == new)//判断新结点空间是否申请成功，NULL == new 表示申请失败
    {
        return -1;
    }
    new->data = data;//把要插入的数值，给new的数据域
    new ->next = NULL;//初始化new的指针域
    //3.找到pos的前一个位置,pos--完成刚好得到pos的前一个位置。
    NODE *p=head;//定义结构体指针p，指向头结点。
    while(pos--)
    {
        p=p->next;
    }
    //4.将new结点插入到p指针指向的结点之后
    new->next = p->next;//new的指针域存放p的下一个结点地址。
    p->next = new;//p的指针域存放new的地址
    return 0;
}

4.1malloc函数

  • malloc需要我们自己计算字节数，并且返回的时候要强转成指定类型的指针
  • int *p; p = (int *)malloc(sizeof(int));
  • （1）malloc的返回是void*,如果我们写成了：p=malloc(sizeof(int));间接的说明了（将void转化给了int*，这不合理）
  • （2）malloc的实参是sizeof(int)，用于指明一个整型数据需要的大小，如果我们写成p=(int*)malloc(1),那么可以看出：只是申请了一个一个字节大小的空间。
  • （3）malloc只管分配内存，并不能对其进行初始化，所以得到的一片新内存中，其值将是随机的。一般意义上：我们习惯性的将其初始化为NULL，当然也可以使用memset函数。
  • malloc函数其实就是在内存中找一片指定大小的空间，然后将这个空间的首地址给一个指针变量，这里的指针变量可以是一个单独的指针，也可以是一个数组的首地址，这要看malloc函数中参数size的具体内容。我们这里malloc分配的内存空间在逻辑上是连续的，而在物理上可以不连续。我们作为程序员，关注的是逻辑上的连续，其他的操作系统会帮着我们处理。
  • 用malloc函数申请空间后要记得用free();函数释放掉。如果一直不释放可能会造成内存溢出，内存满了，申请空间会失败。

5.按位置删除链表

在这里插入图片描述
在这里插入图片描述

//5.按位置删除链表，需要传递头结点和删除的位置
int delete_linklistpos(NODE *head,int pos)
{
    //1判空        
if(empty_list(head))
{
return -1;
}
    //2.判断位置的合法性
    //2.判断pos插入位置的合法性0~lend
    int len=length_list(head);
    if(pos < 0 || pos >len)
    {
        return -1;
    }
//3.找到pos的前一个位置
NODE *p = head;
while (pos--)
{
    p=p->next;
}
//4.删除pos位子的结点先创建一个*q保存一下pos位置的结点
NODE *q = p->next;
p->next = q->next;//p的指针域存放q的下一个结点地址。
free(q);        //释放掉q
q = NULL;    //free掉之后要记得让q=NULL
return 0;
}

6.安置查找，返回地址

//6.安置查找，返回地址.所以我们要遍历整个结点
NODE *find_listdata(NODE *head,data_t data)
{
    if(NULL == head)
    {
        return NULL;
    }
    NODE *p = head;
    while(p->next != NULL)//遍历整个链表，从有效结点开始遍历
    {
        if(p->next->data == data)//如果在链表中找到想查找的数值，则返回该地址。
        {
            return p->next;
        }
        else
        {
            p=p->next;
        }  
    }
    return NULL;
}

7.安置删除链表结点

//7.安置删除链表结点
int delete_listpos(NODE *head, data_t data)
{   
    //1判空        
if(empty_list(head))
{
return -1;
}
//2.遍历结点找到里面和data一样的数值
    
    NODE *p = head;
    NODE *q=NULL;//用来存放要删除的结点
    while(p->next != NULL)
    {
        if(p->next->data == data)
        {
            q=p->next;
            p->next = q->next;
            free(q);
            q=NULL;
        }
        else
        {
            p=p->next;
        }
    }
return -1;

}

8.按位置查找，返回地址

//8.按位置查找，返回地址
NODE *findlistpos(NODE *head, int pos)
{
    
    //1.判断pos插入位置的合法性0~lend
    int len=length_list(head);
    if(pos < 0 || pos >len)
    {
        return NULL;
    }

    找到pos的前一个位置
    NODE *p = head;
    while(pos--)
    {
        p=p->next;
    }
    return p->next;
    
}

9.按值修改链表

//9.按值修改链表
int update_listdata(NODE *head,data_t old_data,data_t new_data)
{
    NODE *p = find_listdata(head,old_data);//找到这个数值，返回这个数值的是地址,所以定义结构体指针p。

    p->data = new_data;//将p地址的数值修改成new_data.
}

10.清空链表,即链表只剩头结点

//1o.清空链表,即链表只剩头结点
 void clear_list(NODE *head)
{
    if(NULL == head)
    {
    return ;
    }
    
    NODE *p=head->next;//清空第一个有效结点
    NODE *q=NULL;
    head->next = NULL;//让头结点的指针域为NULL
    while(p != NULL)
    {
        q=p->next;//q保存下一个地址
        free(p);//释放p结点
        p=q;
        
    }
return ;      
}

11.销毁链表


//11.销毁链表
 
void destory_list(NODE **head)
{
    
 clear_list(*head);
 free(*head);//释放头
 *head=NULL;//防止野指针
}

12.链表的输出

//12.链表的输出

void printf_list(NODE *head)
{
    if(NULL == head)
    {
        return;
    }
    NODE *p=head->next;//让p指向第一个有效结点
    while(p != NULL)//遍历整个链表
    {
        printf("%-3d",p->data);//打印结点的数据
        p=p->next;//让p指向下一个结点，当p = NULL时退出循环。
    }
    printf("\n");
    return ;
}

13.man.c 代码

#include <stdio.h>
#include<stdlib.h>
#include "list.h"
int main(int argc, char *argv[])
{ 
        NODE *head = create_list();
        if(NULL == head)
        {
            printf("malloc failed\n");
            return -1;
        }

        int len = length_list(head);
        printf("len:%d\n",len);
        int i;
        printf("请输入整数i，插入1——i的数\n");
        scanf("%d",&i);
        while(i--)
        {
            insrert_listpos(head,0,i+1);//调用插入函数，每次从0位置开始插入，直到循环结束，刚好是1到i。
        }
        printf("插入的数为：\n");
        printf_list(head);//调用输出函数
        len = length_list(head);
        printf("len:%d\n",len);
       
        
        printf("按值删除表结点，删除 5 \n");
        delete_listpos(head, 5);
        printf_list(head);//调用输出函数

        //5.按位置删除链表，需要传递头结点和删除的位置
        printf("按位值删除表结点，删除 6号位置\n");
        delete_linklistpos(head,6);
        printf_list(head);//调用输出函数

        printf("把数值3修改成11\n");
        update_listdata(head,3,11);
        printf_list(head);//调用输出函数


        printf("清空链表，只剩头结点\n");
        clear_list(head);//清空链表
        len = length_list(head);
        printf("len:%d\n",len); 
    
        printf("销毁链表\n");
        destory_list(&head); //销毁链表
       printf("head:%p\n",head);

    return 0;
}

结果

在这里插入图片描述

  • 注：主要用于自己记录学习和方便自己复习，如有错误或不足之处望大家多多指出。
w_9420
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
单链表的相关操作
xwt321的博客
01-25 582
1.单链表的读取       在线性表的顺序存储结构中，我们计算任意一个元素的存储位置很容易。单在单链表中，由于第i个元素到底在哪？没办法一开始就知道，必须得从头开始找。获得链表第i个数据的算法思路如下： 1）声明一个结点p指向链表第一个结点，初始化j从1开始； 2）当j 3）若到链表末尾p为空，则说明第i个元素不存在； 4）否则查找成功，返回结点p的数据。 代码算法实现如下： /*
单链表的查找(按值查找、按位查找)(数据结构与算法)
AII_IIA的博客
11-03 3588
什么是单链表？单链表是一种常见的链式数据结构，用于存储和操作数据元素的集合。它由一系列的节点组成，每个节点包含两个部分：数据域和指针域。单链表的每个节点包含了存储数据的数据域，以及指向下一个节点的指针域。通过这些指针域，节点之间可以按顺序连接起来，形成一个链式结构。链表的最后一个节点通常指向一个特殊的空节点（NULL或nullptr），表示链表的结束。相比于数组，链表的一大优势是它的动态性。在链表中，节点的添加、删除可以通过修改指针的指向来完成，不需要像数组那样进行元素的移动。
数据结构——单链表的查找
晓风岚月
04-24 4033
一、按位查找（带头结点） //按位查找，返回第i个元素 LNode * GetElem(LinkList L,int i){ int j = 1; //当前p指向的是第几个结点 LNode *p = L->next; //p指向L结点的指针 if(i == 0) return L; if(i < 1) ...
单链表的基本操作
weixin_46086149的博客
09-13 1710
单链表的基本操作
删除链表的倒数第N个节点，并返回链表的头节点
天行健，君子以自强不息；地势坤，君子以厚德载物。
01-28 1751
面试的时候遇到了一个笔试题，是leetcode的原题，原题的连接：https://leetcode-cn.com/problems/remove-nth-node-from-end-of-...
单链表基本操作
08-25
单链表 基本操作
单链表基本操作.rar
最新发布
04-01
单链表基本操作
单链表基本操作.pdf
04-01
单链表是线性数据结构的一种，由一系列的节点组成，每个节点至少包含两部分信息：元素的数据域和指向下一个节点的指针域。单链表的操作主要包括创建链表、插入节点、...下面我们将对单链表的基本操作进行详细的介绍。
2.2.4 单链表的查找(按位查找、按值查找)建立（王道考研）
weixin_45005025的博客
08-19 1881
单链表的查找–带头结点 按位查找 按值查找 按位查找 /** * 按位查找，返回第i个节点 * 带头结点 * @param L * @param i * @return */ LNode * GetElem(LinkList L, int i){ if (i<0){ return NULL; } LNode *p; int j = 0; p=L; while (p!= NULL && j<i){
单链表的按序号查找结点和按位查找结点
m0_51769031的博客
05-20 3529
1、按序号查找结点，从单链表的第一个结点出发，直到找到第i个结点，否则返回最后一个结点指针域NULL； LinkList GetElem(LinkList L,int i) { int j=1; if(i==0) //如果i==0，则返回头结点 return L; if(i<1) //i给的值无效 { return NULL; } LinkList p=L->next; //第一个结点指针赋给p while(p&&j<i) {
【1】4. 单链表的两种查找方式
JJL的博客
07-27 3456
只探讨：带头结点的情况 查找分为 按位查找 =>GetElem(L,i) 获取表中第i个位置元素的值。 按值查找 =>LocateElem(L,e) 在表中查找具有给定关键值的元素。 按位查找 思路： 明确函数返回值类型，代码实质在于定位到第i个结点，而定位操作在单链表按位序增加或者删除都已经实践过! 分析（边界情况）： 当 i=0 时，这里将头结点视为了第0个结点。此时执行会跳过while循环，直接执行return p，即返回头结点。 ...
【BM2 链表内指定区间反转】
Sugar_wolf的博客
05-26 711
描述 将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)，空间复杂度 O(1)。 例如： 给出的链表为 ：1→2→3→4→5→NULL, m = 2, n = 4 返回 1→4→3→2→5→NULL. 数据范围： 链表长度 0 < size ≤ 1000，0 < m ≤ n ≤ size，链表中每个节点的值满足 ∣val∣ ≤ 1000 要求：时间复杂度 O(n) ，空间复杂度 O(n) 进阶：时间复杂度 O(n)， 空间复杂度 O(1
【数据结构】单链表的按位查找（带头结点的和不带头结点的）和按值查找
bbt953的博客
10-12 412
单链表的按位查找（带头结点的和不带头结点的）和按值查找
考研数据结构:(二)单链表(不带头节点)的基本操作(只有干货)
潘小蓝的博客
10-10 838
/* Author: panxiaolan Time: 2021-10-09 单链表的基本操作(不带头节点): (1).单链表的定义 (2).单链表的初始化 (3).单链表建立 a.头插法建立单链表 b.尾插法建立单链表 (4).单链表查找 a.按位查找 b.按值查找 (5).单链表的长度 (6).单链表插入 a.后插 b.前插 c.在某个位置插入 (7).单链表删除 a.删除指定位序上的元素 b.删除某个节点 (8).单链表的输出 *
数据结构--单链表的查找
m0_60593173的博客
06-27 1640
均以带头结点链表为例:按位查找操作。获取表L中第i个位置的元素的值。:按值查找操作。在表L中查找具有给定关键字值的元素。
单链表的查找
周大胖的分享
04-09 187
单链表的查找 按位查找 //按位查找，返回第i个元素（带头结点，头结点可看做第0个） LNode * GetElem(LinkList L,int i){ if(i<0) return NULL; LNode *p;//指针p指向当前扫描到的结点 int j=0;//当前P指向的是第几个结点 p=L;//L指向头结点，头结点是第0个结点（不存数据） while(p!=NULL && j<i){ p=p-&gt
【基础算法】反转链表的三种方法
04-18 3515
【基础算法】反转链表的三种方法
单链表基本操作的实现
09-29
以下是单链表基本操作的实现代码： ```c /* 初始化链式线性表 */ Status IniList(LinkList *L) { *L = (LinkList)malloc(sizeof(Node)); /* 产生头结点，并使L指向此头结点 */ (*L)->next = NULL; /* 指针域为空 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

w_9420

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

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

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

打赏作者

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

抵扣说明：

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

余额充值