单链表操作集合

已于 2023-08-24 13:43:47 修改
阅读量117 收藏
点赞数
分类专栏： 数据结构 文章标签： c语言 数据结构 链表
于 2023-08-19 13:45:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunres/article/details/132376247
版权

文章目录

前言

记录一下单链表的各种操作思路，方便后面复习回顾。

一、单链表介绍

链表是链式存储结构，用于存储逻辑关系为线性，也就是“一对一”关系的数据。

  • 有头链表：存在一个头节点，头节点的指针域有效，数据域看个人。
  • 无头链表：每一个数据域和指针域都有效。

无头链表

  • 特点：内存中不连续，通过指针链接。
  • 解决问题：长度固定的问题和插入删除麻烦的问题。
  • 逻辑结构：线性结构
  • 存储结构：链式存储结构
  • 操作：增删改查

二、单链表创键

为什么要用指针来操作链表呢？

在我看来是每一个节点都有指针来指向，所以自然想到用指针来操作了，而且我们开辟堆空间放节点时，也是用指针接收的。在对结构体进行操作时，我们通过移动头节点的指针来到达想要的位置，然后进行相应操作。

1.初始化

  • 开辟空间，创建节点
  • 头节点数据域置0 (可选)
  • 头节点指针域指向NULL
// 初始化链表
Node* initList()
{
    // 开辟空间,创建节点
    Node* list = (Node*)malloc(sizeof(Node));
    list -> data = 0;   //头节点数据域一般存放节点个数
    list -> next = NULL;
    return list;
}

Node* list = initList();//头节点指针

2.头插法

在这里插入图片描述
从头节点的后面插入，头节点用来保存链表的信息。

  • 开辟空间，创建节点
  • 数据域保存传进来的数据
  • 调整新建节点的指向 (上图1)
  • 调整头节点的指向 (上图2)
  • 头节点数据+1,表示新增了一个节点 (上图3， 可选)
// 头插法：从头节点的后面插入。头节点用来保存链表的信息
void headInsert(Node* list, int data)
{
    // 开辟空间
    Node* node = (Node*)malloc(sizeof(Node));
    node -> data = data;    //节点数据域保存传进来的数据
    node -> next = list -> next;    //将头节点next指向的节点地址赋值给新建节点next
    list -> next = node;    //头节点指向新建节点
    list -> data++;     //头节点数据+1,表示新增了一个节点
}

3.尾插法

在这里插入图片描述

// 尾插法：遍历到最后一个节点，在该节点后面插入新节点
void tailInsert(Node* list, int data)
{
    Node* head = list;
    // 开辟空间
    Node* node = (Node*)malloc(sizeof(Node));
    node -> data = data;
    node -> next = NULL;    //最后一个，没有可指向的节点
    //移动到最后一个节点
    while (list -> next)
    {
        list = list -> next; 
    }
    //最后节点指向新节点
    list -> next = node;
    head -> data++;//节点数量++    
}

4.打印

// 从第一个节点开始遍历输出每一个节点
void printList(Node* list)
{
    list = list -> next; //从第一个节点开始遍历  
    while (list)
    {
        printf("%d->", list -> data);
        list = list -> next;    
    }
    printf("\n");
}

5.删除

在这里插入图片描述

遍历所有节点, 将要删除的节点内容和每一个节点的内容进行比对，找到目标节点后,把它指向的节点传给前一个节点的next(如图1)

需要两个指针，初始时，一个(pre)指向头节点，一个(current)指向头节点后面，每次循环时，它们都向后移动一次
操作完要释放该空间(如图2)
头节点的data要-1(如图3)

void delete(Node* list, int data)
{
    Node* pre = list;
    Node* current = list->next;

    while (current)//遍历节点
    {
        if (current->data == data)//根据data找到指定位置
        {
            pre->next = current->next;//调整前一节点指向
            free(current);//释放空间
            current = NULL;
            printf("已删除!\n");
            list->data--;//节点数量-1
            break;
        }
        //移动到下一个节点
        pre = current;
        current = current->next;
    }
}

6.任意位置插入

// 任意位置插入:用户输入位置和数据
void insertNode(Node* list)
{
    int post;//插入位置
    int temp_data;//存用户的插入数
    printf("请输入要插入的位置:\n");
    scanf("%d", &post);
    getchar();
    // 进行容错判断
    if (post < 0 || post > list->data+1)//
    {
        printf("位置不在有效范围!\n");
        return;
    }

    printf("请输入要插入的数:\n");
    scanf("%d", &temp_data);
    getchar();

    // 开辟空间,创建节点
    Node* node = (Node*)malloc(sizeof(Node));
    node->data = temp_data;
    Node* current = list;//要移动的指针
    // 移动到要插入的前一个节点上
    for (int i = 1; i < post; i++)//插入到位1,不移动指针,插入到位2,移动1次,插入到位3,移动2次
    {
        current = current->next;
    }
    // 插入操作
    node->next = current->next;//调整插入节点的next
    current->next = node; //调整前一节点的next
    list->data++;
}

7.判断空表

// 判断是否空链表：看头节点的next是否为null
void isNullList(Node* list)
{
    if (list->next == NULL)
    {
        printf("NULL\n");
        return;
    }
    printf("节点数:%d\n", list->data);
}

8.清空节点

// 清空节点：从第一个节点开始遍历，将每一个节点进行删除，最后让头节点指向NULL
void noneNode(Node* list)
{
    Node* current = list->next;
    while (current != NULL)
    {
    	Node* current_next = current->next;//提前保存要删除节点的下一个节点位置
    	//删除操作
        free(current);
        current = NULL;
        list->data--;
        //当头节点data为0时，停止删除
        if (list->data == 0)
        {
            list->next = NULL;
            printf("已清空!\n");
            return;
        }
        current = current_next;//删除完，指针向后移动
    }
}

9.查找数据

// 查找:用户输入数据,将数据去和每一个节点进行匹配，如果成功,返回位置
void searchNode(Node* list)
{
    int temp_data;//要查找数据
    int num = 0;//记录数据所在位置
    printf("请输入要查找的数据:");
    scanf("%d", &temp_data);

    Node* current = list->next;//移动到第一个节点
    while (current != NULL)//遍历
    {
        if (current->data == temp_data)//匹配
        {
            printf("%d在位置%d!\n", temp_data, num+1);
        }
        num++;//不匹配位置++
        current = current->next;
    }
}

10.修改数据

//修改：让头节点指针移动到指点位置，修改节点的数据
void modifyNode(Node* list)
{
    int num;//位置
    int temp_data;//要修改的数据
    printf("请输入要修改的位置:");
    scanf("%d", &num);

    // 容错判断
    if (num < 0 || num > list->data)
    {
        printf("位置超范围!\n");
    }

    printf("请输入要修改的值:");
    scanf("%d", &temp_data);

    for (int i = 0; i < num; i++)//让头节点指针移动到修改位置
    {
        list = list->next;
    }

    list->data = temp_data;//修改
    printf("修改成功!\n");
}

11.数据转置

// 链表转置:将原表从头节点处拆开,遍历头节点后每一个节点,每次将要遍历的节点'头插入'头节点中
void linkListReverse(Node* list)
{
    
    Node* current = list->next;//原表用来移动的指针,从第一个节点开始
    list->next = NULL;
    
    while (current)//遍历原表
    {
        //将原表每一个节点头插入空的头节点
        Node* next_node = current->next;//在插入之前保存current下一个结点,不然current指向改变后,其后续节点找不到了
        current->next = list->next;//调整当前遍历节点的next
        list->next = current;//头节点指向新插入节点
        current = next_node;//移动到下一个节点
    }
    printf("转置完成!\n");
}

12.数据排序

// 排序
// 思路:
// 根据平均分降序排序
// 思路:将头节点和后续节点分开,对后续无头节点进行遍历,
// 将遍历节点重新插入头节点后面,每次插入时要考虑顺序
// 这样要插入的链表就是一个已经排序好的链表
void sortLinkList(Node* list)
{
    // 将头节点和后续节点分开前,要保存后续第一个节点位置,否找找不到后面
    Node* current = list->next;
    //将头节点和后续节点进行分开
    list->next = NULL;
//对后续无头节点进行遍历,将每个节点重新插入头节点后面,插入时考虑顺序
    while (current)
    {
        //每个节点插入前,都要提前保存下一个节点,因为后面current的next发生变化
        Node* current_next = current->next;
        //头节点指针复制品,用来移动的,指向头节点
        Node* sorted_ptr = list;
        //节点插入时,要考虑插入位置,当第一个位置不合适就去下一个位置,所以要对已排序链表进行遍历
        while (sorted_ptr)
        {
            // 什么时候进行插入?  
            //1.当已排序链表为空时直接插入(条件1) 
            //2.当遍历已排序链表最后位置时,直接插入(条件1) 
            //3.移到合适位置插入(条件2)
            if (sorted_ptr->next == NULL || current->data < sorted_ptr->data)
            {
                //头插操作
                current->next = sorted_ptr->next;
                sorted_ptr->next = current;
                break;
            }
            else
            {
                //不符合插入条件时指针后移
                sorted_ptr = sorted_ptr->next;
            }    
        }
        //发生插入后,current指针后移,移到下一个待插入节点
        current = current_next;
    }
    printf("排序完成!\n");
}

三 、全部代码

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

typedef struct Node
{
    int data;
    struct Node* next;
}Node;

// 初始化
Node* initList()
{
    Node* list = (Node*)malloc(sizeof(Node));
    if (list == NULL)
    {
        perror("malloc error");
    }
    list->data = 0;
    list->next = NULL;
    return list;
}


// 头插法：从头节点的后面插入。头节点用来保存链表的信息
// void headInsert(Node* list, int data)
// {
//     // 开辟空间
//     Node* node = (Node*)malloc(sizeof(Node));
//     node -> data = data;    //节点数据域保存传进来的数据
//     node -> next = list -> next;    //将头节点next指向的节点地址赋值给新建节点next
//     list -> next = node;    //头节点指向新建节点
//     list -> data++;     //头节点数据+1,表示新增了一个节点
// }

// 尾插法
// void tailInsert(Node* list, int data)
// {
//     Node* head = list;
//     // 开辟空间
//     Node* node = (Node*)malloc(sizeof(Node));
//     node -> data = data;
//     node -> next = NULL;    //最后一个，没有可指向的节点
   
//     while (list -> next)
//     {
//         list = list -> next; 
//               //list已经是尾巴了，怎么让list->data加1呢？ 
//     }
//     list -> next = node;
//     head -> data++;
// }

// 任意位置插入:用户输入位置和数据
void insertNode(Node* list)
{
    int post;//插入位置
    int temp_data;//存用户的插入数
    printf("请输入要插入的位置:\n");
    scanf("%d", &post);
    getchar();
    // 进行容错判断
    if (post < 0 || post > list->data+1)//
    {
        printf("位置不在有效范围!\n");
        return;
    }

    printf("请输入要插入的数:\n");
    scanf("%d", &temp_data);
    getchar();

    // 开辟空间,创建节点
    Node* node = (Node*)malloc(sizeof(Node));
    node->data = temp_data;
    Node* current = list;//要移动的指针
    // 移动到要插入的前一个节点上
    for (int i = 1; i < post; i++)//插入到1不移动指针,插入到2,移动1次,插入到3,移动2次
    {
        current = current->next;
    }
    // 插入操作
    node->next = current->next;//调整插入节点的next
    current->next = node; //调整前一节点的next
    list->data++;
}

// 删除
void delete(Node* list)
{
    int temp_data;
    printf("请输入要删除的数据:");
    scanf("%d", &temp_data);

    Node* pre = list;
    Node* current = list->next;

    while(current != NULL)
    {
        if (current->data == temp_data)
        {
            pre->next = current->next;
            free(current);
            current = NULL;
            list->data--;
            printf("删除成功!\n");
            return;
        }
        pre = current;
        current = current->next;
    }
    printf("没找到!\n");
}

// 判断是否空链表
void isNullList(Node* list)
{
    if (list->next == NULL)
    {
        printf("NULL\n");
        return;
    }
    printf("节点数:%d\n", list->data);
}

// 清空节点
void noneNode(Node* list)
{
    Node* current = list->next;

    while (current != NULL)
    {
        Node* hou = current->next;//用来保存移动指针的下一个节点位置
        free(current);
        current = NULL;
        list->data--;
        if (list->data == 0)
        {
            list->next = NULL;
            printf("已清空!\n");
            return;
        }
    
        current = hou;//当前指针向后移动
    }
}

// 查找:用户输入数据,如果存在,返回位置
void searchNode(Node* list)
{
    int temp_data;
    int num = 0;
    printf("请输入要查找的数据:");
    scanf("%d", &temp_data);

    Node* current = list->next;
    while (current != NULL)
    {
        if (current->data == temp_data)
        {
            printf("%d在位置%d!\n", temp_data, num+1);
        }
        num++;
        current = current->next;
    }
}

//修改数据
void modifyNode(Node* list)
{
    int num;
    int temp_data;
    printf("请输入要修改的位置:");
    scanf("%d", &num);

    // 容错判断
    if (num < 0 || num > list->data)
    {
        printf("位置超范围!\n");
    }

    printf("请输入要修改的值:");
    scanf("%d", &temp_data);

    for (int i = 0; i < num; i++)
    {
        list = list->next;
    }

    list->data = temp_data;
    printf("修改成功!\n");
}


// 链表转置:将原表从头节点处拆开,遍历头节点后每一个节点,每次将要遍历的节点'头插入'头节点中
void linkListReverse(Node* list)
{
    
    Node* current = list->next;//在断开前,保存后面第一个节点
    list->next = NULL;
    
    while (current)//遍历原表
    {
        //将原表每一个节点头插入空的头节点
        Node* next_node = current->next;//在插入之前保存current下一个结点,不然current指向改变后,其后续节点找不到了
        current->next = list->next;//调整当前遍历节点的next
        list->next = current;//头节点指向新插入节点
        current = next_node;//移动到下一个节点
    }
    printf("转置完成!\n");
}

// 排序
// 思路:
// 根据平均分降序排序
// 思路:将头节点和后续节点分开,对后续无头节点进行遍历,
// 将遍历节点重新插入头节点后面,每次插入时要考虑顺序
// 这样要插入的链表就是一个已经排序好的链表
void sortLinkList(Node* list)
{
    // 将头节点和后续节点分开前,要保存后续第一个节点位置,否找找不到后面
    Node* current = list->next;
    //将头节点和后续节点进行分开
    list->next = NULL;
//对后续无头节点进行遍历,将每个节点重新插入头节点后面,插入时考虑顺序
    while (current)
    {
        //每个节点插入前,都要提前保存下一个节点,因为后面current的next发生变化
        Node* current_next = current->next;
        //头节点指针复制品,用来移动的,指向头节点
        Node* sorted_ptr = list;
        //节点插入时,要考虑插入位置,当第一个位置不合适就去下一个位置,所以要对已排序链表进行遍历
        while (sorted_ptr)
        {
            // 什么时候进行插入?  
            //1.当已排序链表为空时直接插入(条件1) 
            //2.当遍历已排序链表最后位置时,直接插入(条件1) 
            //3.移到合适位置插入(条件2)
            if (sorted_ptr->next == NULL || current->data < sorted_ptr->data)
            {
                //头插操作
                current->next = sorted_ptr->next;
                sorted_ptr->next = current;
                break;
            }
            else
            {
                //不符合插入条件时指针后移
                sorted_ptr = sorted_ptr->next;
            }    
        }
        //发生插入后,current指针后移,移到下一个待插入节点
        current = current_next;
    }
    printf("排序完成!\n");
}

// 遍历
void printList(Node* list)
{
    list = list -> next;    //list++
    while (list)
    {
        printf("%d->", list -> data);
        list = list -> next;    //list++
    }
    printf("NULL\n");
}

int main(int argc, char const *argv[])
{
    Node* list = initList();

    isNullList(list);

    insertNode(list);
    insertNode(list);
    insertNode(list);
    insertNode(list);
    insertNode(list);
   
    // delete(list);
    printList(list);
    isNullList(list);

    

    // searchNode(list);
    modifyNode(list);
    printList(list);
    isNullList(list);
    // printf("节点数:%d\n", list->data);
    linkListReverse(list);
    printList(list);

    sortLinkList(list);
    printList(list);
    noneNode(list);
    isNullList(list);
    return 0;
}
数萼初含雪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表的集合操作实验报告.docx
10-18
在本实验报告中，主要探讨了单链表的集合操作，包括求集合交集、并集和差集。实验基于C++编程语言，利用模板类实现了链表结构，并提供了相关操作的方法。 首先，我们来看看链表节点的定义。在C++中，一个链表节点...
用单链表实现集合的操作.pdf
10-21
用单链表实现集合的操作.pdf用单链表实现集合的操作.pdf
单链表操作
11-12
单链表是一种基础的数据结构，它在计算机科学中扮演着重要的角色，特别是在处理动态数据集合时。单链表由一系列节点组成，每个节点包含两部分：数据元素和指向下一个节点的指针。在这个主题中，我们将深入探讨单链表...
用C语言实现单链表的各种操作(二)
01-20
用C语言实现单链表的各种操作(一)>主要是单链表的一些最基本的操作，下面，主要是一些其他的典型的算法和测试程序。 代码如下:/* 对单链表进行排序处理*/struct LNode *sort(struct LNode *head){ LinkList *p; ...
java单链表的基本操作.zip
01-09
Java单链表是一种常见的数据结构，它在编程中扮演着重要的角色，特别是在处理动态数据集合时。本资料主要涵盖了Java单链表的基本操作，包括链表的定义、创建、插入、删除、遍历等核心概念。 单链表由一系列节点组成...
C语言（7.4）
fhgfyrsg的博客
07-15 213
在cmd里面输入的东西必须和scanf括号里面引号里面的格式一模一样， 引号里是%d %d，在cmd里面输入的东西就必须是数字 数字，比如10 29 引号里是%d，%d，在cmd里面输入的东西就必须是数字，数字。printf("我的姓名为：%s\n年龄：%d\n身高：%f\n", name,age,high);今天做了一些关于键盘录入的基本训练。
c语言（函数7.18）
fhgfyrsg的博客
07-18 370
printf("小慧慧成绩高\n");printf("小丹丹成绩高\n");printf("两人成绩一样\n");今天学习了带有形参的函数，带有返回值的函数。
C语言 | Leetcode C语言题解之第237题删除链表中的节点
m0_59237910的博客
07-16 362
C语言 | Leetcode C语言题解之第237题删除链表中的节点
常见排序算法总结
mydaily_的博客
07-16 773
大概是因为插入排序没预处理，极端情况可能让一个很小很右的数一直比比比比比，比到最开头，浪费比较次数。某种情况比计数排序好，因为数字，如果按照普通十进制理解，则只需准备10个不同数字的桶就好了！整体的quickSort函数swap后，再进行partition，划分三部分后，所以这种不基于比较的算法应用范围很局限，大部分情况下，不如之前的所有比较算法！前提得知道空间范围，比如人的年龄，正数[0-200]，否则内存爆炸！间隔分组，且分组间隔依次减半，每次分组后，每个组内排序都是插入排序。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1879
栈超超超详解
数据结构——栈
weixin_45942515的博客
07-19 162
1、栈的英文为stack2、栈是先入后出（FILO-First In Last Out）的有序列表。3、栈stack是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶 (Top)，另一端固定的一端，称为栈底(Bottom)。4、根据栈的定义可知，最先放入栈中的元素在栈底，最后放入栈中的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
数据结构(5.1)——树的性质
m0_65240792的博客
07-16 230
1%29%5D。
《数据结构》预备
U2396573637的博客
07-19 452
位段的声明和结构体是类似的，有两个不同：1.位段的成员必须是int、unsigned int、 signed int，在C99中位段成员也可以选择其它类型。2.位段的成员后边有一个冒号和一个数字。int _b:5;int _c:10;int _d:30;A就是一个位段类型。那位段A所占内存的大小是多少呢？
数据结构(5.2_3)——二叉树的存储结构
最新发布
m0_65240792的博客
07-19 155
1%29%5D1。
数据结构（队列）
2401_83968713的博客
07-19 445
这么看好像两者的差别不大，但是我们在单链表结构中可以稍作改造，直接定义两个结点（头结点，尾结点）指向原链表的队头和队尾，那么在队尾入数据时就不用遍历链表，直接让尾结点->next 等于新结点，时间复杂度就变成 O(1)了。概念：只允许在⼀端进⾏插⼊数据操作，在另⼀端进⾏删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)⼊队列操作的时间复杂度为 O(1) ,进行出队列操作的时间复杂度为 O(n);⼊队列：进⾏插⼊操作的⼀端称为队尾。出队列：进⾏删除操作的⼀端称为队头。
数据结构(4.4)——求next数组
m0_65240792的博客
07-14 373
next[1]都无脑写0next[2]都无脑写1其他next:在不匹配的位置前边，划一条分界线，模式串一步一步往后退，直到分界线之前"能对上"，或模式串能完全跨过分界线为止，此时j指向哪儿，next数组值就是多少ababaa的next数组//求next[1]??????->??????/i=1->i=2ababaa-> ababaa //j=0,第一个字符匹配失败，只能匹配下一个子串，++i，++jnext[1]=0;//求next[2]a?????->a??????//i=2。
数据结构_排序
m0_73620971的博客
07-19 619
1、希尔排序是对直接插入排序的优化。2、直接选择排序效率不高，很少使用；堆排序效率高。3、快速排序综合性能和使用场景都是比较好的。4、归并排序更多是在解决磁盘中的外排序问题。
《数据结构：C语言实现双链表》
2401_83305953的博客
07-19 113
带头链表中的头结点，实际为“哨兵位”，哨兵位结点补存储任何有效元素，只是站在这里“放哨的”虽然有这么多的链表的结构，但我们实际中最常用的还是两种结构：单链表和双向带头循环链表.
《数据结构-用C语言描述第三版》课后答案 第三章
m0_62469100的博客
07-19 748
b[2] = 2;b[n+1] = 2;i>=2;i--){若调用 bin ( A ,5)，给出 A 数组中第1个到第6个数组元素的值。答：数组中的值为每次递归将后面一个元素赋值为2，然后前面的元素分别加等其前面的元素。
单链表集合运算实验报告：并交差操作实现
五 实验总结:通过本次实验，我们加深了对单链表和集合的理解，掌握了基于单链表的集合操作的实现方法。同时，通过编写程序实现了各种基本运算和集合运算，提高了我们的编程能力和数据结构应用能力。在以后的学习和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值