单链表的基本操作

最新推荐文章于 2024-07-09 22:37:42 发布
最新推荐文章于 2024-07-09 22:37:42 发布
阅读量533 收藏 4
点赞数 8
文章标签： c++ c语言 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Star__01/article/details/137085439
版权
本文详细介绍了链表的创建（单链表和循环链表）、删除节点的方法、逆置链表以及链表的排序算法，包括冒泡排序、插入排序和头节点置空的排序方式。还涉及了约瑟夫环问题和链表查询中的跳表概念。
摘要由CSDN通过智能技术生成

链表

文章目录

struct List
{
	int data;
	struct List* next;
}

创建链表

单链表

实现一：
struct List* listCreate()
{
	int data;
    struct List* head = NULL;
    struct List* pre = NULL;
    struct List* current = NULL;
    
    while(scanf("%d",&data) && data != -1)
    {
        current = (struct List*)malloc(sizeof(struct List));
        if(head == NULL)
            head = current;
        else
            pre->next = current;
        current->next = NULL;
        current->data = data;
        pre = current;
    }
    return head;
}
实现二：
struct List* listCreate()
{
    struct List* head;
    struct List* current;
    head = (struct List*)malloc(sizeof(struct List));
    current = head;
    while (scanf("%d", &data) && data != -1)
    {
        current->next = (struct List*)malloc(sizeof(struct List));
        current = current->next;
        current->data =  current;
        current->next = NULL;
    }
    return head;
}
错例
struct List* listCreate()
{
	int data;;
	struct List* current = NULL;
	struct List* head = current;
	while (scanf("%d", &data) && data != -1)
	{
		current = (struct List*)malloc(sizeof(struct List));
		if (head == NULL)
			head = current;
		current->data = data;
		current = current->next;
	}
	return head;
}

在使用malloc函数开辟的空间中，不要进行指针的移动，因为一旦移动之后可能出现申请的空间和释放空间大小的不匹配

循环链表

https://pic2.zhimg.com/v2-6d8f7d01b3b74ce646e73b76ee414c40_r.jpg

单独创建

struct List* circle_listCreate()
{
	int data;
    struct List* head = NULL;
    struct List* pre = NULL;
    struct List* current = NULL;
    
    while(scanf("%d",&data) && data != -1)
    {
        current = (struct List*)malloc(sizeof(struct List));
        if(head == NULL)
            head = current;
        else
            pre->next = current;
        current->next = head;
        current->data = data;
        pre = current;
    }
    return head;
}

逐节点创建

void Append(struct List** L,int data)
{
    struct List* head = *L;
    struct List* newNode = NULL;
    if((*L) == NULL)
    {
        (*L) = (struct List*)malloc(sizeof(struct List));
        (*L)->data = data;
        head = (*L);
        (*L)->next = head;
    }
    else
    {
        while ((*L)->next != head){
            (*L) = (*L)->next;
        }
        newNode = (struct List*)malloc(sizeof(struct List));
        newNode->data = data;
        (*L)->next = newNode;
        newNode->next = head;
        *L = head;
    }
}

约瑟夫环问题

void Append(struct List** L,int data)
{
    struct List* head = *L;
    struct List* newNode = NULL;
    if((*L) == NULL)
    {
        (*L) = (struct List*)malloc(sizeof(struct List));
        (*L)->data = data;
        head = (*L);
        (*L)->next = head;
    }
    else
    {
        while ((*L)->next != head){
            (*L) = (*L)->next;
        }
        newNode = (struct List*)malloc(sizeof(struct List));
        newNode->data = data;
        (*L)->next = newNode;
        newNode->next = head;
        *L = head;
    }
}
void Display(struct List* L,int num)
{
    struct List* head = L;
    struct List* pre = NULL;
    struct List* kill = NULL;
    int nodeNum = 0;
    while (L->next != head)
    {
        nodeNum++;
        L = L->next;
    }
    pre = L;
    L = L->next;
    nodeNum++;
    while (nodeNUm)
    {
        if (nodeNum == 1)
        {
            printf("%d",L->data);
            free(L);
            return;
        }
        for (int i=1; i < m; i++)
        {
            pre = L;
            L = L->next;
        }
        printf("%d ", L->data);
        kill = L;
        L = L->next;
        free(kill);
        nodeNum--;
    }
}

删除节点

实现方式一：

struct list* listDelete(struct list* L,int data)
{
    struct list* pre = L;
    struct list* head = L;
    struct list* kill;
    
    while(head != NULL && head->data == m)
    {
        kill = head;
        head = head->next;
        free(kill);
    }
    if(head == NULL)
        return head;
    
    pre = head;
    kill = head->next;
    while(kill!=NULL)
    {
        if(kill->data == m)
        {
            pre->next = kill->next;
            free(kill);
            kill = pre->next;
        }
        else
        {
            pre = kill;
            kill = kill->next;
        }
    }
    return head;
}

实现方式二：

struct list* listDelete(struct list** L,int data)
{
    struct list* head = (*L), * pre = (*L);
    struct list* newL = *L;
    struct list* kill = NULL;
    while (*L != NULL)
    {
        if((*L)->data == data)
        {
            if((*L) == newL)
                newL == newL->next;
            else
                pre->next = (*L)->next;
            kill = (*L);
            (*L) = (*L)->next;
            free(kill);
        }
        else
        {
            pre = (*L);
            (*L) = (*L)->next;
        }
    }
    *L = newL;
    return head;
}

删除节点并建立新链表

struct list* list_Delete_Create(struct list** L) //数据为奇数存为新链表
{
    struct list* newhead = NULL, * newcurrent = NULL, * newpre = NULL;
    struct list* newL = *L;
    struct list* kill = NULL;
    struct list* pre = *L;
    while (*L)
    {
        if((*L)->data%2 == 1)
        {
            newcurrent = (struct list*)malloc(sizeof(struct list));
            if(newhead == NULL)
                newhead = newcurrent;
            else
                newpre->next = newcurrent;
            newcurrent->data = (*L)->data;
            newcurrent->next = NULL;
            newpre = newcurrent;
            
            if((*L) == newL)
                newL = newL->next;
            else
                pre-next = (*L)->next;
            kill = (*L);
            (*L)=(*L)->next;
            free(kill);
        }
        else
        {
            pre = (*L);
            (*L) = (*L)->next;
        }
    }
    *L = newL;
    return newhead;
}

逆置链表

实现：

struct list* reverse(struct list* L)
{
    struct list* newhead = NULL, * current;
    while (L != NULL)
    {
        current = (struct list*)malloc(sizeof(struct list));
        current->data = L->data;
        L = L->next;
        current->next = newhead;
        newhead = current;
    }
    free(L);
    return newhead;
}

链表排序

实现一：

struct List* listSort(struct List** head, int n, int(*compare)(float a, float b)) {
	int i, j;
	struct List *temp;
    struct List *current;
    struct List *init = *head;
	for (i = 0; i < n; i++) {
		current = *head;
		temp = *head;
		for (j = 0; j < n - i - 1; j++) {
			if ((*compare)(current->data, current->next->data)) {
				if (current == *head) {
					*head = current->next;
					temp = current->next;
					current->next = temp->next;
					temp->next = current;
                    init = *head;
				}
				else {
					temp->next = current->next;
					current->next = current->next->next;
					temp->next->next = current;
					temp = temp->next;
				}
			}
			else {
				temp = current;
				current = current->next;
			}
		}
	}
	return init;
}
int Descending(float a, float b) {
	return a > b;
}

int Ascending(float a, float b) {
	return a < b;
}

实现二：

void listSort(struct List* head, int n, int(*compare)(float a, float b)) {
	int i, j;
	struct List *temp;
    struct List *current;
	for (i = 0; i < n; i++) {
		current = head;
		temp = head;
		for (j = 0; j < n - i - 1; j++) {
			if ((*compare)(current->data, current->next->data)) {
				if (current == head) {
					head = current->next;
					temp = current->next;
					current->next = temp->next;
					temp->next = current;
				}
				else {
					temp->next = current->next;
					current->next = current->next->next;
					temp->next->next = current;
					temp = temp->next;
				}
			}
			else {
				temp = current;
				current = current->next;
			}
		}
	}
}

实现三：

//头节点置为空

void sortlist(struct List* head, int n, int(*compare)(float a, float b))
{
    int i, j;
	struct List *temp;
    struct List *current;
	for (i = 0; i < n; i++) {
		temp = head;
		current = head->next;
		for (j = 0; j < n - i - 1; j++) {
			if ((*compare)(current->data, current->next->data)) {
				temp->next = current->next;
				current->next = current->next->next;
				temp->next->next = current;
				temp = temp->next;
			}
			else {
				temp = current;
				current = current->next;
			}
		}
	}
}

链表查询(跳表)

ctoLu
关注
  • 8
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
单链表基本操作.rar
04-01
这个压缩包文件“单链表基本操作.rar”包含了一个名为“单链表基本操作.docx”的文档，我们可以从中学习到关于单链表的各种核心概念和操作。 单链表是由一系列节点构成的线性数据结构，每个节点包含两部分：数据域...
单链表基本操作
08-25
单链表 基本操作
基于Java实现的单链表基本操作之链表排.zip
04-26
在这个基于Java实现的单链表基本操作项目中，我们主要关注的是链表的排序。下面将详细讲解单链表的基本概念、Java中如何实现单链表以及如何进行链表排序。 **一、单链表的基本概念** 单链表是由一系列节点组成的...
基于Java实现的单链表基本操作之链表合并.zip
04-26
本项目聚焦于Java实现的单链表基本操作，特别是链表的合并这一关键操作。下面将详细介绍单链表的概念、基本操作以及如何在Java中实现链表合并。 单链表是一种线性数据结构，每个节点包含两部分：数据域，用于存储...
c++习题08-计算星期几
码到成龚的博客
07-03 602
问题描述 假设今天是星期日，那么过a^b天之后是星期几？ 输入描述 两个正整数a，b，中间用单个空格隔开。0
C++初探究（2）
最新发布
Frenemy__的博客
07-09 753
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
Android 开发中 C++ 和Java 日志调试
小羊子的技术专栏
07-04 918
Android 开发中 C++ 和Java 日志调试方法小结
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 625
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现
C++：CV::Point函数简介
Ethan_Rich的博客
07-08 268
cv::Point是 OpenCV 库中用于表示二维坐标系下点的一个基本数据类型。它提供了在图像处理、计算机视觉等领域中定位和操作点的能力。以下是关于cv::Point。
C语言 do while 循环语句练习 中
2401_84378523的博客
07-05 327
注：使用Sleep首字母必须大写，引用头函数#include <windows.h>，Sleep是延时函数，用来做延时效果。使用system需应用头函数。
Python的异常处理（与C++对比学习）
2302_76941579的博客
07-09 417
通过C++的基础来学习Python的异常处理
LIUNX /SYS/CLASS/GPIO捕获IO输入状态 C语言
星羽空间
07-09 117
LIUNX /SYS/CLASS/GPIO捕获IO输入状态 C语言
C++数据的高效传递--左值引用和右值引用
CHNIM的博客
07-05 340
右值引用主要用于实现移动语义和完美转发。左值引用和右值引用是C++中的两个重要概念。左值引用引用持久存在的对象，而右值引用引用临时对象。通过右值引用，C++实现了移动语义和完美转发，从而提高了程序的效率和灵活性。理解和正确使用它们，对于编写现代、高效的C++代码非常重要。
【LinuxC语言】手撕Http协议之accept_request函数实现(一)
m0_62599305的博客
07-05 280
在计算机网络中，HTTP协议是一种常见的应用层协议，它定义了客户端和服务器之间如何进行数据交换。在这篇文章中，我们将深入探讨Linux C语言中实现HTTP协议的关键部分——accept_request函数。这个函数是服务器处理客户端请求的核心，它负责接收客户端的连接，读取HTTP请求，解析请求内容，并根据请求类型（GET或POST）调用相应的处理函数。我们将详细分析accept_request函数的实现，包括套接字的创建和绑定，监听客户端的连接，接收和解析HTTP请求，以及调用处理函数。
【C语言小知识】缓冲区
dab112的博客
07-06 681
主要讲解了缓冲区的概念
【C语言】操作符--百科全书
2302_81115588的博客
07-04 1080
C语言操作符
c++ learn first day
2301_80048347的博客
07-06 634
超市里有 n ( 1 ≤ n ≤ 1 0 5 ) n(1\le n\le10^5)n(1≤n≤10 5 ) 个寄包柜。每个寄包柜格子数量不一，第 i ii 个寄包柜有 a i ( 1 ≤ a i ≤ 1 0 5 ) a_i(1\le a_i\le10^5)a i (1≤a i ≤10 5) 个格子，不过我们并不知道各个 a i a_ia i的值。1 i j k：在第 i ii 个柜子的第 j jj 个格子存入物品 k ( 0 ≤ k ≤ 1 0 9 ) k(0\le k\le 10^9)k(0≤k≤10。
C++：对象begin()-＞second
Ethan_Rich的博客
07-04 148
函数是一个非常重要的成员函数（或对于非成员函数容器，如标准库中的容器，它是一个全局函数），它返回一个指向容器中第一个元素的迭代器（iterator）。迭代器是一种允许程序遍历容器（如数组、向量、列表等）的对象，类似于指针，但更加通用和灵活。这些容器中的元素通常是成对出现的，即键值对（key-value pairs）。的意思是：获取容器中第一个元素的迭代器，并访问这个元素的。：由于容器中的元素是键值对，每个元素都有一个。：这个对象是一个能够存储多个元素的容器，如。，我们获得了指向容器中第一个元素的迭代器。
替代AD780低温漂低噪声低功耗40V_3ppm/°C 高精度带隙基准电压源
szpc1621的博客
07-04 353
是一款精密基准电压源，该器件兼具稳健的工作特性和极低的漂移与低噪声。利用先进的曲率补偿，该带隙基准电压源可实现。的输出驱动（在低输出阻抗条件下）和精准的负载调节性能，并且内置了输出短路电流保护。等系列产品，还可以替代TI的REF5025/30/50/10)的漂移和可预知的温度特性，以及。的噪声和非常低的温度循环迟滞。可以用来检测器件温度。（典型值） ， 3ppm/低漂移 1.5ppm/（最大值）低噪声 10。用来微调输出电压值。
单链表基本操作的实现
09-29
以下是单链表基本操作的实现代码： ```c /* 初始化链式线性表 */ Status IniList(LinkList *L) { *L = (LinkList)malloc(sizeof(Node)); /* 产生头结点，并使L指向此头结点 */ (*L)->next = NULL; /* 指针域为空 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值