数据结构之单向有头链表的操作(纯代码及代码解释)

最新推荐文章于 2023-08-05 15:57:39 发布
最新推荐文章于 2023-08-05 15:57:39 发布
阅读量476 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68210771/article/details/125971165
版权

一，头文件

    在了解了链表的定义等基础知识之后，我们需要将定义转化为程序；

    首先我们需要将概念的思想转化为程序的思路：

        ①单向有头链表，存在一个空的头节点；

        ②链表中节点逻辑上按顺序排列，存储时节点之间通过指针连接，存储空间上不一定连续；

        ③节点需要存放数据，还需要存放下一个节点的地址，由此我们可知链表结构体中的成员变量包括一个数据域"datatype data;"，和一个指针域"结构体类型 *p;"

        ④头节点的数据域为空，没有数据，指针域指向链表中的第一个有数据的节点；当链表为空时，头节点的指针域指向空；

    了解了上述内容后，就容易理解程序；

    程序主要掌握空链表的创建，数据的插入和删除，以及链表的转置。

    头文件程序代码如下：

#ifndef _LINKLIST_H_
#define _LINKLIST_H_
#include <stdio.h>
#include <stdlib.h>

typedef int datatype;
typedef struct link_node
{
    datatype data;//数据域
    struct link_node *next;//指针域
}link_t;

//1.创建一个有头单向链表
link_t *CreateEpLinklist(void);
//2.向指定位置插入数据
int InsertIntoLinklist(link_t *p,int post,datatype data);
//3.计算链表长度
int LengthLinklist(link_t *p);
//4.在指定位置删除数据
int DeleteLinklist(link_t *p,int post);
//5.遍历链表
void ShowLinklist(link_t *p);
//6.判断链表是否为空
int isEpLinklist(link_t *p);
//7.查询链表指定位置的数据
int SearchPostLinklist(link_t *p,int post);
//8.查询指定数据在链表的位置
int SearchDataLinklist(link_t *p,datatype data);
//9.修改链表中指定的数据
int ChangeDataLinklist(link_t *p,datatype old,datatype new);
//10.修改链表中指定位置的数据
int ChangePostLinklist(link_t *p,int post,datatype new);
//11.删除链表中指定的数据
void DeleteDataLinklist(link_t *p,datatype data);
//12.链表的转置
void ReserveLinklist(link_t *p);
//13.清空链表
void ClearLinklist(link_t *p);
//14.销毁链表
void DestoryLinklist(link_t **p);
#endif

二，函数代码

1.创建一个空的单向有头链表

     先使用malloc开辟一个结构体空间，然后将指针域指向空，数据域不赋值，即无数据，就创建好了一个单向链表的空的头结点。

//创建一个有头单向链表
link_t *CreateEpLinklist(void)
{
    link_t *p = (link_t *)malloc(sizeof(link_t));
    if(NULL == p)
    {
        printf("CreateEpLinklist fail\n");
        return NULL;
    }
    p->next = NULL;//数据域无效，指针域有效
    return p;
}

2.向链表中指定位置插入数据

插入数据时，需要判断插入的位置是否合理；

将指向空的头节点的指针指向要插入位置的前一个节点；

开辟一个新的结构体空间；

给结构体中的数据域赋值，指针域指向该位置的后一位的节点，也就是头节点指向的当前节点的下一个节点(因为新节点还没插入，新节点要插入到两个节点之间)；

将头节点当前指向的节点，其指针域指向新节点，新节点才算插入成功；

//向指定位置插入数据
int InsertIntoLinklist(link_t *p,int post,datatype data)
{
    int i;
    link_t *pnew = NULL;
    //容错判断
    if(post < 0 || post > LengthLinklist(p))//插入数据时，可能会插入最后一位的后一位
    {
        printf("InsertIntoLinklist fail\n");
        return -1;
    }
    //将头指针指向post-1位置的节点
    for(i = 0;i < post;i++)
    {
        p = p->next;
    }
    //创建新节点
    pnew = (link_t *)malloc(sizeof(link_t));
    if(NULL == pnew)
    {
        printf("pnew create fail\n");
        return -1;
    }
    pnew->data = data;
    pnew->next = NULL;
    //新节点先指向post-1指向的节点，post-1再指向新节点
    pnew->next = p->next;
    p->next = pnew;
    return 0;
}

3.在指定位置删除数据

 删除数据时也需要判断删除位置的合理性；

头节点也需要指向要删除节点的前一个节点；

然后用一个临时指针指向要删除的节点；

让头节点当前指向的节点，其指针域指向要删除结点的下一个节点；

将要删除的节点释放，并指向NULL。

//在指定位置删除数据
int DeleteLinklist(link_t *p,int post)
{
    link_t *pdel = NULL;
    //容错判断
    //后面的所有相关指定位置post的容错判断，因为都表示的是下标，指定的post不能超出下标，所以需要减1
    if(post < 0 || post > LengthLinklist(p) - 1 || isEpLinklist(p))
    {
        printf("DeleteLinklist fail\n");
        return -1;
    }
    //将节点指向要删除的节点的前一个节点post-1
    for(int i = 0;i < post;i++)
    {
        p = p->next;
    }
    //新建一个临时指针指向要删除的post节点
    pdel = p->next;
    //要删除的节点的前一个节点post-1指向要删除的节点的后一个节点post+1
    p->next = pdel->next;
    //释放要删除的节点
    free(pdel);
    pdel = NULL;
    return 0;
}

4.链表的转置

转置，对于链表来说，可以理解为除去空的头节点，将其他的原来的节点倒过来排序；

先将空的头节点和第一个有数据的节点断开，生成一个空的头节点和一个没有无头链表；

然后将无头链表中的所有节点循环插入到空的头节点的后面，而且每次插入节点都要插入到空的头节点的后一位；

void ReserveLinklist(link_t *p)
{
    link_t *temp = NULL;//接收无头节点的插入节点的下一个节点
    link_t *q = NULL;//接收无头节点的第一个节点
    q = p->next; //让q接收断开的无头节点的第一个节点
    p->next = NULL;//让原本的头节点后面指向空，也就是断开链表
    while(q != NULL)//所有的节点都要插入，所以应该是对q判断，不应该是对q->next判断;q所在的节点为空了，才停止插入
    {
        temp = q->next;//先保存下来无头节点中要插入节点的下一个节点
        q->next = p->next;//插入的节点后面要链接之前插入的节点;一开始后面链接的是空，下一次插入后面链接的就是无头节点的第一个节点
        p->next = q;//循环插入空的头节点后面
        q = temp;//让q移动到无头节点的下一个节点
    }
}

//或
void ReserveLinklist(link_t *p)
{
    link_t *temp = NULL;
    link_t *pa = p->next;
    p->next = NULL;

    while(pa != NULL)
    {
        temp = pa;  //保存下来要插入的节点
        pa = pa->next; //无头链表向后移动
        temp->next = NULL; //要插入的节点后面指向空，也就是把它和无头链表断开

        temp->next = p->next; //插入的节点后面接上已经插入的节点;
        p->next = temp;  //节点插入;
    }
}

三，详细代码

#include "linklist.h"

//1.创建一个有头单向链表
link_t *CreateEpLinklist(void)
{
    link_t *p = (link_t *)malloc(sizeof(link_t));
    if(NULL == p)
    {
        printf("CreateEpLinklist fail\n");
        return NULL;
    }
    p->next = NULL;//数据域无效，指针域有效
    return p;
}
//2.向指定位置插入数据
int InsertIntoLinklist(link_t *p,int post,datatype data)
{
    int i;
    link_t *pnew = NULL;
    //容错判断
    if(post < 0 || post > LengthLinklist(p))//插入数据时，可能会插入最后一位的后一位
    {
        printf("InsertIntoLinklist fail\n");
        return -1;
    }
    //将头指针指向post-1位置的节点
    for(i = 0;i < post;i++)
    {
        p = p->next;
    }
    //创建新节点
    pnew = (link_t *)malloc(sizeof(link_t));
    if(NULL == pnew)
    {
        printf("pnew create fail\n");
        return -1;
    }
    pnew->data = data;
    pnew->next = NULL;
    //新节点先指向post-1指向的节点，post-1再指向新节点
    pnew->next = p->next;
    p->next = pnew;
    return 0;
}
//3.计算链表长度,len是长度，从1开始;post是下标，从0开始;
int LengthLinklist(link_t *p)
{
    int len = 0;
    while(p->next != NULL)
    {
        p = p->next;
        len++;
    }
    return len;
}
//4.在指定位置删除数据
int DeleteLinklist(link_t *p,int post)
{
    link_t *pdel = NULL;
    //容错判断
    //后面的所有相关指定位置post的容错判断，因为都表示的是下标，指定的post不能超出下标，所以需要减1
    if(post < 0 || post > LengthLinklist(p) - 1 || isEpLinklist(p))
    {
        printf("DeleteLinklist fail\n");
        return -1;
    }
    //将节点指向要删除的节点的前一个节点post-1
    for(int i = 0;i < post;i++)
    {
        p = p->next;
    }
    //新建一个临时指针指向要删除的post节点
    pdel = p->next;
    //要删除的节点的前一个节点post-1指向要删除的节点的后一个节点post+1
    p->next = pdel->next;
    //释放要删除的节点
    free(pdel);
    pdel = NULL;
    return 0;
}
//5.遍历链表
void ShowLinklist(link_t *p)
{
    while(p->next != NULL)
    {
        p = p->next;
        printf("%d ",p->data);
    }
    putchar(10);
    printf("---------------------\n");
}
//6.判断链表是否为空
int isEpLinklist(link_t *p)
{
    return p->next == NULL;
}
//7.查询链表指定位置的数据
datatype SearchPostLinklist(link_t *p,int post)
{
    //容错判断
    if(post < 0 || post > LengthLinklist(p) - 1 || isEpLinklist(p))
    {
        printf("SearchPostLinklist fail\n");
        return -1;
    }
    int i;
    for(i = 0;i <= post;i++)
    {
        p = p->next;
    }
    return p->data;
}
//8.查询指定数据在链表的位置
int SearchDataLinklist(link_t *p,datatype data)
{
    if(isEpLinklist(p))
    {
        printf("isEmptyLinklist\n");
        return -1;
    }
    int post = 0;
    while(p->next != NULL)
    {
        p = p->next;
        if(p->data == data)
        {
            return post; //return之后函数结束
        }
        post++;
    }
    return -1;
}
//9.修改链表中指定的数据
int ChangeDataLinklist(link_t *p,datatype old,datatype new)
{
    while(p->next != NULL)
    {
        p = p->next;
        if(p->data == old)
        {
            p->data = new;
        }
    }
    return 0;
}
//10.修改链表中指定位置的数据
int ChangePostLinklist(link_t *p,int post,datatype new)
{
    //容错判断
    if(post < 0 || post > LengthLinklist(p) - 1 || isEpLinklist(p))
    {
        printf("ChangePostLinklist fail\n");
        return -1;
    }
    int i;
    for(i = 0;i <= post;i++)
    {
        p = p->next;
    }
    p->data = new;
    return 0;
}
//11.删除链表中指定的数据
void DeleteDataLinklist(link_t *p,datatype data)
{
    
    while(p->next != NULL)
    {
        if(p->next->data == data)
        {
            link_t *pdel = p->next; //必须放这，每次free后，pdel就被释放了
            p->next = pdel->next;
            free(pdel);
            pdel = NULL;
        }
        else
        {
            p = p->next;
        }
        
    }
}
#if 0
//12.链表的转置
void ReserveLinklist(link_t *p)
{
    link_t *temp = NULL;//接收无头节点的插入节点的下一个节点
    link_t *q = NULL;//接收无头节点的第一个节点
    q = p->next; //让q接收断开的无头节点的第一个节点
    p->next = NULL;//让原本的头节点后面指向空，也就是断开链表
    while(q != NULL)//所有的节点都要插入，所以应该是对q判断，不应该是对q->next判断;q所在的节点为空了，才停止插入
    {
        temp = q->next;//先保存下来无头节点中要插入节点的下一个节点
        q->next = p->next;//插入的节点后面要链接之前插入的节点;一开始后面链接的是空，下一次插入后面链接的就是无头节点的第一个节点
        p->next = q;//循环插入空的头节点后面
        q = temp;//让q移动到无头节点的下一个节点
    }
}
#endif
#if 1
//12.链表的转置
void ReserveLinklist(link_t *p)
{
    link_t *temp = NULL;
    link_t *pa = p->next;
    p->next = NULL;

    while(pa != NULL)
    {
        temp = pa;  //保存下来要插入的节点
        pa = pa->next; //无头链表向后移动
        temp->next = NULL; //要插入的节点后面指向空，也就是把它和无头链表断开

        temp->next = p->next; //插入的节点后面接上已经插入的节点;
        p->next = temp;  //节点插入;
    }
}
#endif
//13.清空链表
void ClearLinklist(link_t *p)
{
    link_t *pdel = NULL;
    while(p->next != NULL)
    {
        pdel = p->next;
        p->next = pdel->next;
        free(pdel);
        pdel = NULL;
    }
}
//14.销毁链表
void DestoryLinklist(link_t **p) //要把main函数中创建的指针也销毁，也就是更改它的值，所以需要地址传递
{
    if(!isEpLinklist(*p))
    {
        ClearLinklist(*p);
    }
    free(*p);
    *p = NULL;
}

樱桃的崩崩
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言之单向链表详解及实例代码
12-31
1，单向链简洁。 单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指列表中的下一个结点；列表是由结点构成，由head指针指向第一个成为表头的结点而终止于最后一个指向nuLL的指针； 2，例子要求： 根据示例代码中的例子，完成单向链表(single linked list)中的以字符串为数据的链表的插入、删除以及查找，并支持单向链表的反转； 3，代码实现。 #include <stdio> #include <math.h>
C++实现简单单向链表
12-17
本文实例为大家分享了C++实现简单单向链表的具体代码，供大家参考，具体内容如下 为了练习一下对链表的理解，尝试手动造轮子，实现单向链表的右添加，左添加和删除的功能。 头文件 #pragma once #include<iostream> using namespace std; struct Node//节点 { int value; Node* next; Node(int a = 0, Node* n = NULL) :value(a), next(n) {} }; class List { private: Node* head = NULL;//头指针 Node* tail
详细介绍如何写一个单向链表
A_lid的博客
07-31 511
有头单向链表，创建，插入，删除，查询，转置，清空，销毁。
数据结构--带头结点的单向链表
最新发布
散步的呆头鹅的博客
08-05 2029
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。
有头单向链表
SUN_QL_的博客
04-12 161
有头单向链表
四、数据结构——单向链表的基本操作详解：创建、插入（头插法、尾插法、任意点插法）、删除（头删法、尾删法、任意位置删法）、查询（按值查下标、按下标查值）、遍历链表和清空链表
qq_57737603的博客
06-14 1950
单向链表是一种线性数据结构，由一系列节点组成。每个节点包含两个部分：数据和指向下一个节点的引用（也称为指针）。节点之间通过这个引用连接在一起，形成链表结构。最后一个节点的引用指向空值，表示链表的结束。
数据结构（二）——单向有头链表的原理以及简单应用
weixin_44463519的博客
11-07 646
这一章主要叙述了有头单链表的原理和增删改查的应用。
建立一个单向链表的步骤(C语言)
热门推荐
qq_49175846的博客
05-17 2万+
建立一个单向链表的步骤要点总结
简单单向链表（头插法、尾插法、插入排序创建单向链表）
新手小白
09-15 277
简单链表基本操作~ 创建链表（头插法、尾插法），进阶版（有序插入）
C语言：有序单链表的创建
qq_43432875的博客
12-16 1万+
如何创建一个带头结点的有序的单链表？ 链表在创建的时候就把它创建成有序的会显得专业许多（雾）， 而不是先创建无序链表再排序； 拿一道典型例题举个栗子，相信你们都见过这道题； Problem Description 输入N个无序的整数，建立一个有序链表，链表中的结点按照数值非降序排列，输出该有序链表。 Input 第一行输入整数个数N； 第二行输入N个无序的整数。 Output 依次输出有序链表的...
带头结点的单向链表的基本操作的实验代码和实验报告
04-14
使用给定数据结构，实现带头结点的单向链表的创建、删除链表、插入结点等操作，每个学生的学号互不相同，学号不同而姓名相同则为不同的学生，每个学生的学号在合并后的链表中不重复，如果出现重复，则删除年龄较小...
C语言实现单向链表及操作
03-24
数据结构，c语言实现的单向链表。代码分享 struct LinkNode { int data; struct LinkNode *next; }; typedef struct LinkNode *Lnode;
Python实现的数据结构与算法之链表详解
12-24
本文实例讲述了Python实现的数据结构与算法之链表。分享给大家供大家参考。具体分析如下： 一、概述 链表（linked list）是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的...
数据结构与算法 python–第三节 链表之单向链表
01-20
文章目录3 链表3.1 单向链表单链表的操作单链表是否为空、长度、遍历操作头部添加元素 add()尾部添加元素append()指定位置添加元素insert(pos,item)删除节点remove(item)查找节点是否存在search（item）完整代码链表...
数据结构-链表的实现代码（C语言版）.rar
10-27
数据结构 -- C语言版 -- 链表的部分实现代码（单向链表、双向链表、循环链表、约瑟夫环等），详细介绍参考数据结构--链表的系列博文。链接为：https://blog.csdn.net/songshuai0223/category_9742561.html。
单向链表的创建与遍历
2021dragon的博客
03-24 5435
文章目录前言创建单项链表遍历单项链表测试代码正确性 前言 链表这个词想必大家都听说过，链表是一种常见而重要的基础数据结构，也是实现复杂数据结构的重要手段。它不按照线性的顺序存储数据，而是由若干个同一结构类型的“结点”依次串联而成的，即每一个结点里保存着下一个结点的地址。链表有很多种不同的类型：单向链表、双向链表以及循环链表。 接下来我们来看看如何创建以及如何遍历单项链表。 创建单项链表 我们知道链表是由多个结点组成，所以要想创建一个链表，首先要创建一个结点。一个结点存储的内容可以分为两部分：数据域，指针域。
链表-----单向链表详解
weixin_51134816的博客
05-04 1116
玩单链表的时候一定要注意区分头指针和头结点，在链表的初阶学习时，老师可能会对第一个结点直接取地址传过去，在无头单链表中，头指针和第一个结点重名，这就导致了当时学链表的时候很疑惑为啥一会儿传第一个结点的地址，一会儿传第一个结点的地址的地址。菜就多练！
单向链表的创建和操作
m0_67186846的博客
08-14 580
单向链表的创建和基本操作
四种创建单链表的方法
兔子王
09-23 1万+
学习了这么久的数据结构，终于把链表吃透啦，下面是我整理的四种创建单链表的的方法，以及一些非常容易犯的错误，让我们一起来看看吧~
数据结构单向链表插入代码
03-26
以下是单向链表插入代码的示例： ``` #include <stdio.h> #include <stdlib.h> // 定义链表结构体 typedef struct Node { int data; struct Node* next; } Node; // 链表插入函数 void insert(Node** head, int data) { Node* new_node = (Node*)malloc(sizeof(Node)); // 创建新节点 new_node->data = data; new_node->next = NULL; if (*head == NULL) { // 链表为空，将新节点作为头节点 *head = new_node; } else { // 链表不为空，将新节点插入链表尾部 Node* temp = *head; while (temp->next != NULL) { temp = temp->next; } temp->next = new_node; } } // 测试函数 int main() { Node* head = NULL; // 定义头节点 insert(&head, 1); // 插入第一个节点 insert(&head, 2); // 插入第二个节点 insert(&head, 3); // 插入第三个节点 // 遍历链表 Node* temp = head; // 从头节点开始 while (temp != NULL) { printf("%d ", temp->data); temp = temp->next; } printf("\n"); return 0; } ``` 示例代码中使用了头指针（即双重指针），这样可以在插入新节点时对链表头节点进行修改。如果不使用头指针，则需要单独处理头节点的插入和删除情况。 在该代码中，插入操作采用了尾插法，即新节点始终插入到链表的尾部。具体实现方式是从头节点开始遍历链表，直到找到链表的最后一个节点，然后将新节点插入到其 next 指针处。如果链表为空，则将新节点作为头节点。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值