单向链表，链表的定义以及增删改查的实现

已于 2023-07-23 10:46:19 修改
阅读量246 收藏 1
点赞数
分类专栏： 数据结构 # 数据结构练习（7月18） 文章标签： 数据结构 链表
于 2023-07-18 20:01:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53478812/article/details/131794617
版权
本文详细介绍了单链表的定义，包括结点结构、首元结点、头结点和头指针。接着，提供了单链表的一系列操作实现，如创建、插入（头插、尾插）、删除（头删、尾删）、遍历、长度计算、任意位置插入、查找、修改、删除等。此外，还涵盖了单链表的逆置、冒泡排序和简单选择排序的算法实现。
摘要由CSDN通过智能技术生成

一、单链表的定义和表示

        线性表链式存储结构的特点是：用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。因此，为了表示每个元素a_i与其直接后继数据元素a_ i + _1之间的逻辑关系，对数据元素a_i来说，除了存储其本身的信息之外，还需要存储一个指示其直接后继的信息。这两部分信息组成数据元素a_i的存储映像，称为结点。它包括两个域：

数据域：存储数据元素信息的域

指针域：存储直接后继存储位置的域

        n个结点链结成一个链表，即为线性表的链式存储结构，而每个结点只包含一个指针域称为线性链表或单链表。

        根据链表结点所含指针个数、指针指向和指针连接方式，可将链表分为单链表、循环链表、双向链表、二叉链表、十字链表、临近链表、临接多重表等。

首元结点：链表中存储第一个数据元素的结点

头结点：在首元结点之前附设的一个结点，其指针域指向首元结点。头节点的数据域一般存放链表的长度

头指针：指向链表中第一个结点的指针 

注意：链表的最后一个结点的指针域为NULL

二、单链表的存储结构

typedef int ElemType;  //重定义数据域的数据类型
typedef struct LNode   //定义单链表存储结构
{
	ElemType data;     //结点的数据域
	struct LNode *next;//结点的指针域
}*LinkList;            //LinkList为指向结构体LNode的指针类型

三、单链表的操作

3.1 单链表创建

LinkList Request_space()  //在堆区申请一个结点空间
{
	LinkList node=(LinkList)malloc(sizeof(struct LNode));  //在使用malloc函数时，记得引用头文件#include <stdlib.h>
	if(NULL==node)
		return NULL;
	node->data=0;
	node->next=NULL;
	return node;
}

3.2 单链表头插

LinkList insert_head(LinkList L_list,ElemType value)  //实现头插
{
	LinkList node=Request_space();
	if(NULL==node)
		return NULL;
	node->data=value;
	node->next=L_list;
	L_list=node;
	return L_list;
}

3.3 单链表尾插

LinkList insert_rear(LinkList L_list,ElemType value)  //实现尾插
{
	LinkList node=Request_space();
	node->data=value;
	if(NULL==L_list)
		L_list=node;
	else
	{
		LinkList rear=L_list;
		while(rear->next!=NULL)
			rear=rear->next;
		rear->next=node;
	}
	return L_list;
}

3.4 单链表头删

LinkList delete_head(LinkList L_list)  //实现头删
{
	if(NULL==L_list)
		return NULL;
	if(L_list->next==NULL)
	{
		free(L_list);
		L_list=NULL;
	}
	else
	{
		LinkList p=L_list->next;
		L_list->data=p->data;
		L_list->next=p->next;
		free(p);
		p=NULL;
	}
	return L_list;
}

3.5 单链表尾删

LinkList delete_rear(LinkList L_list)  //实现尾删
{
	if(NULL==L_list)
		return NULL;
	if(L_list->next==NULL)
	{
		free(L_list);
		L_list=NULL;
	}
	else
	{
		LinkList rear=L_list;
		while(rear->next->next!=NULL)
			rear=rear->next;
		free(rear->next);
		rear->next=NULL;
	}
	return L_list;
}

3.6 单链表遍历

int Output(LinkList L_list)  //实现输出
{
	if(NULL==L_list)
		return -1;
	while(L_list!=NULL)
	{
		printf("%d ",L_list->data);
		L_list=L_list->next;
	}
	puts("");
	return 0;
}

3.7 计算单链表长度

int len_Llist(LinkList L_list)  //计算单链表长度
{
	int count=0;
	if(NULL==L_list)
		return -1;
	while(L_list!=NULL)
	{
		count++;
		L_list=L_list->next;
	}
	return count;
}

3.8 单链表任意位置插入

LinkList insert_by_seat(LinkList L_list,int seat,ElemType value)  //实现任意位置插入
{
	int len=len_Llist(L_list);
	if(NULL==L_list||seat<1||seat>len+1)
		return L_list;
	if(seat==len+1)
		L_list=insert_rear(L_list,value);

	LinkList rear=L_list;
	LinkList node=Request_space();
	for(int i=1;i<seat;i++)
		rear=rear->next;
	node->data=rear->data;
	rear->data=value;
	node->next=rear->next;
	rear->next=node;
	return L_list;
}

3.9 单链表任意位置查找

int search_by_seat(LinkList L_list,int seat)  //实现任意位置查找
{
	int len=len_Llist(L_list);
	if(NULL==L_list||seat<1||seat>len+1)
		return -1;
	LinkList rear=L_list;
	for(int i=1;i<seat;i++)
		rear=rear->next;
	printf("%d\n",rear->data);
	return 0;
}

3.10 单链表任意位置修改

int modify_by_seat(LinkList L_list,int seat,ElemType value)  //任意位置修改
{
	int len=len_Llist(L_list);
	if(NULL==L_list||seat<1||seat>len+1)
		return -1;
	LinkList rear=L_list;
	for(int i=1;i<seat;i++)
		rear=rear->next;
	rear->data=value;
	return 0;
}

3.11 单链表任意位置删除 

LinkList delete_by_seat(LinkList L_list,int seat)  //任意位置删除
{
	int len=len_Llist(L_list);
	if(NULL==L_list||seat<1||seat>len)
		return L_list;
	if(seat==1)
		L_list=delete_head(L_list);
	else
	{
	LinkList rear=L_list;
	for(int i=1;i<seat-1;i++)
		rear=rear->next;
	LinkList p=rear->next;
	rear->next=p->next;
	free(p);
	p=NULL;
	}
	return L_list;
}

3.12 单链表任意元素查找

int search_by_element(LinkList L_list,ElemType value)  //任意元素查找
{
	if(NULL==L_list)
		return -1;
	int seat=0;
	while(L_list)
	{
		seat++;
		if(L_list->data==value)
			return seat;
		L_list=L_list->next;
	}
	return -1;
}

3.13 单链表任意元素删除

LinkList delete_by_element(LinkList L_list,ElemType value)  //任意元素删除
{
	int seat=search_by_element(L_list,value);
	if(seat==-1)
		return L_list;
	L_list=delete_by_seat(L_list,seat);
	return L_list;
}

3.14 单链表任意元素插入

LinkList insert_by_element(LinkList L_list,ElemType value,ElemType element)  //任意元素插入
{
	int seat=search_by_element(L_list,value);
	if(seat==-1)
		return L_list;
	L_list=insert_by_seat(L_list,seat,element);
}

3.15 任意元素修改

int modify_by_element(LinkList L_list,ElemType value,ElemType element)  //任意元素修改
{
	int seat=search_by_element(L_list,value);
	if(seat==-1)
		return -1;
	while(--seat)
		L_list=L_list->next;
	L_list->data=element;
	return 0;
}

3.16 单链表逆置

LinkList rev_list(LinkList L_list)  //单链表逆置
{
	if(NULL==L_list||L_list->next==NULL)
		return L_list;
	LinkList p=L_list->next;
	int len=len_Llist(L_list)-1;
	L_list->next=NULL;
	for(int i=0;i<len;i++)
	{
		LinkList q=p;
		p=p->next;
		q->next=L_list;
		L_list=q;
	}
		return L_list;
}

3.17 释放单链表

LinkList free_space(LinkList L_list)  //释放单链表
{
	if(NULL==L_list)
		return L_list;
	int len=len_Llist(L_list);
	for(int i=0;i<len;i++)
		L_list=delete_head(L_list);
	return L_list;
}

3.18 冒泡排序单链表

int Bubble_list(LinkList L_list)  //冒泡排序单链表
{
	if(NULL==L_list||L_list->next==NULL)
		return -1;
	int len=len_Llist(L_list);
	int count,i,j;
	LinkList p=L_list;
	for(i=1;i<len;i++)
	{
		count=0;
		for(j=0,p=L_list;j<len-i;j++,p=p->next)
		{
			if(p->data>p->next->data)
			{
				ElemType temp=p->data;
				p->data=p->next->data;
				p->next->data=temp;
				count++;
			}
		}
		if(count==0)break;
	}
	return 0;
}

3.19  简单选择排序单链表

int simple_list(LinkList L_list)  //简单选择排序单链表
{
	if(NULL==L_list||L_list->next==NULL)
		return -1;
	int len=len_Llist(L_list);
	int i,j,seat;
	LinkList p=L_list;
	LinkList q=L_list;
	for(i=0;i<len-1;i++,q=q->next)
	{
		seat=i;
		for(j=i+1,p=q->next;j<len;j++,p=p->next)
		{
			if(q->data>p->data)
			{
				seat=j;
			}
		}
		if(seat!=i)
		{
			p=L_list->next;
			while(--seat)
				p=p->next;
			ElemType temp=q->data;
			q->data=p->data;
			p->data=temp;
		}
	}
	return 0;
}

3.20 简单选择排序单链表2 

int simple_list(Linklist L_list)
{
	if(NULL==L_list||L_list->next==NULL)
		return -1;
	int len=Len_linklist(L_list);
	Linklist p,q;
	int i,j;
	for(i=0,p=L_list;i<len-1;i++,p=p->next)
	{
		Linklist min=p;
		for(j=i+1,q=p->next;j<len;j++,q=q->next)
		{
			if(min->data<q->data)
			{
				min=q;
			}
		}
		if(min!=p)
		{
			int t=min->data;min->data=p->data;
			p->data=t;
		}
	}
	return 0;
}

四、多文件编辑实现单链表操作

头文件 head.h

#ifndef __HEAD_H__
#define __HEAD_H__

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

typedef int ElemType;  //重定义数据域的数据类型
typedef struct LNode  //定义单链表存储结构
{
	ElemType data;
	struct LNode *next;
}*LinkList;

LinkList Request_space();  //在堆区申请一个结点空间
int Output(LinkList L_list);  //实现输出
LinkList insert_head(LinkList L_list,ElemType value);  //实现头插
LinkList insert_rear(LinkList L_list,ElemType value);  //实现尾插
LinkList delete_head(LinkList L_list);  //实现头删
LinkList delete_rear(LinkList L_list);  //实现尾删
LinkList insert_by_seat(LinkList L_list,int seat,ElemType value);  //实现任意位置插入
int search_by_seat(LinkList L_list,int seat);  //实现任意位置查找
int modify_by_seat(LinkList L_list,int seat,ElemType value);  //任意位置修改
LinkList delete_by_seat(LinkList L_list,int seat);  //任意位置删除
int search_by_element(LinkList L_list,ElemType value);  //任意元素查找
LinkList delete_by_element(LinkList L_list,ElemType value);  //任意元素删除
LinkList insert_by_element(LinkList L_list,ElemType value,ElemType element);  //任意元素插入
int modify_by_element(LinkList L_list,ElemType value,ElemType element);  //任意元素修改
LinkList rev_list(LinkList L_list);  //单链表逆置
LinkList free_space(LinkList L_list);  //释放单链表
int Bubble_list(LinkList L_list);  //冒泡排序单链表
int simple_list(LinkList L_list);  //简单选择排序单链表

#endif

自定义函数 fun.c

#include "head.h"
LinkList Request_space()  //在堆区申请一个结点空间
{
	LinkList node=(LinkList)malloc(sizeof(struct LNode));
	if(NULL==node)
		return NULL;
	node->data=0;
	node->next=NULL;
	return node;
}
int Output(LinkList L_list)  //实现输出
{
	if(NULL==L_list)
		return -1;
	while(L_list!=NULL)
	{
		printf("%d ",L_list->data);
		L_list=L_list->next;
	}
	puts("");
	return 0;
}
LinkList insert_head(LinkList L_list,ElemType value)  //实现头插
{
	LinkList node=Request_space();
	if(NULL==node)
		return NULL;
	node->data=value;
	node->next=L_list;
	L_list=node;
	return L_list;
}
LinkList insert_rear(LinkList L_list,ElemType value)  //实现尾插
{
	LinkList node=Request_space();
	node->data=value;
	if(NULL==L_list)
		L_list=node;
	else
	{
		LinkList rear=L_list;
		while(rear->next!=NULL)
			rear=rear->next;
		rear->next=node;
	}
	return L_list;
}
LinkList delete_head(LinkList L_list)  //实现头删
{
	if(NULL==L_list)
		return NULL;
	if(L_list->next==NULL)
	{
		free(L_list);
		L_list=NULL;
	}
	else
	{
		LinkList p=L_list->next;
		L_list->data=p->data;
		L_list->next=p->next;
		free(p);
		p=NULL;
	}
	return L_list;
}
LinkList delete_rear(LinkList L_list)  //实现尾删
{
	if(NULL==L_list)
		return NULL;
	if(L_list->next==NULL)
	{
		free(L_list);
		L_list=NULL;
	}
	else
	{
		LinkList rear=L_list;
		while(rear->next->next!=NULL)
			rear=rear->next;
		free(rear->next);
		rear->next=NULL;
	}
	return L_list;
}
int len_Llist(LinkList L_list)  //计算单链表长度
{
	int count=0;
	if(NULL==L_list)
		return -1;
	while(L_list!=NULL)
	{
		count++;
		L_list=L_list->next;
	}
	return count;
}
LinkList insert_by_seat(LinkList L_list,int seat,ElemType value)  //实现任意位置插入
{
	int len=len_Llist(L_list);
	if(NULL==L_list||seat<1||seat>len+1)
		return L_list;
	if(seat==len+1)
		L_list=insert_rear(L_list,value);
	else
	{
		LinkList rear=L_list;
		LinkList node=Request_space();
		for(int i=1;i<seat;i++)
			rear=rear->next;
		node->data=rear->data;
		rear->data=value;
		node->next=rear->next;
		rear->next=node;
	}
	return L_list;
}
LinkList delete_by_seat(LinkList L_list,int seat)  //任意位置删除
{
	int len=len_Llist(L_list);
	if(NULL==L_list||seat<1||seat>len)
		return L_list;
	if(seat==1)
		L_list=delete_head(L_list);
	else
	{
		LinkList rear=L_list;
		for(int i=1;i<seat-1;i++)
			rear=rear->next;
		LinkList p=rear->next;
		rear->next=p->next;
		free(p);
		p=NULL;
	}
	return L_list;
}
int search_by_seat(LinkList L_list,int seat)  //实现任意位置查找
{
	int len=len_Llist(L_list);
	if(NULL==L_list||seat<1||seat>len+1)
		return -1;
	LinkList rear=L_list;
	for(int i=1;i<seat;i++)
		rear=rear->next;
	printf("%d\n",rear->data);
	return 0;
}
int modify_by_seat(LinkList L_list,int seat,ElemType value)  //任意位置修改
{
	int len=len_Llist(L_list);
	if(NULL==L_list||seat<1||seat>len+1)
		return -1;
	LinkList rear=L_list;
	for(int i=1;i<seat;i++)
		rear=rear->next;
	rear->data=value;
	return 0;
}
int search_by_element(LinkList L_list,ElemType value)  //任意元素查找
{
	if(NULL==L_list)
		return -1;
	int seat=0;
	while(L_list)
	{
		seat++;
		if(L_list->data==value)
			return seat;
		L_list=L_list->next;
	}
	return -1;
}
LinkList delete_by_element(LinkList L_list,ElemType value)  //任意元素删除
{
	int seat=search_by_element(L_list,value);
	if(seat==-1)
		return L_list;
	L_list=delete_by_seat(L_list,seat);
	return L_list;
}
LinkList insert_by_element(LinkList L_list,ElemType value,ElemType element)  //任意元素插入
{
	int seat=search_by_element(L_list,value);
	if(seat==-1)
		return L_list;
	L_list=insert_by_seat(L_list,seat,element);
}
int modify_by_element(LinkList L_list,ElemType value,ElemType element)  //任意元素修改
{
	int seat=search_by_element(L_list,value);
	if(seat==-1)
		return -1;
	while(--seat)
		L_list=L_list->next;
	L_list->data=element;
	return 0;
}
LinkList rev_list(LinkList L_list)  //单链表逆置
{
	if(NULL==L_list||L_list->next==NULL)
		return L_list;
	LinkList p=L_list->next;
	int len=len_Llist(L_list)-1;
	L_list->next=NULL;
	for(int i=0;i<len;i++)
	{
		LinkList q=p;
		p=p->next;
		q->next=L_list;
		L_list=q;
	}
		return L_list;
}
LinkList free_space(LinkList L_list)  //释放单链表
{
	if(NULL==L_list)
		return L_list;
	int len=len_Llist(L_list);
	for(int i=0;i<len;i++)
		L_list=delete_head(L_list);
	return L_list;
}
int Bubble_list(LinkList L_list)  //冒泡排序单链表
{
	if(NULL==L_list||L_list->next==NULL)
		return -1;
	int len=len_Llist(L_list);
	int count,i,j;
	LinkList p=L_list;
	for(i=1;i<len;i++)
	{
		count=0;
		for(j=0,p=L_list;j<len-i;j++,p=p->next)
		{
			if(p->data>p->next->data)
			{
				ElemType temp=p->data;
				p->data=p->next->data;
				p->next->data=temp;
				count++;
			}
		}
		if(count==0)break;
	}
	return 0;
}
int simple_list(LinkList L_list)  //简单选择排序单链表
{
	if(NULL==L_list||L_list->next==NULL)
		return -1;
	int len=len_Llist(L_list);
	int i,j,seat;
	LinkList p=L_list;
	LinkList q=L_list;
	for(i=0;i<len-1;i++,q=q->next)
	{
		seat=i;
		for(j=i+1,p=q->next;j<len;j++,p=p->next)
		{
			if(q->data>p->data)
			{
				seat=j;
			}
		}
		if(seat!=i)
		{
			p=L_list->next;
			while(--seat)
				p=p->next;
			ElemType temp=q->data;
			q->data=p->data;
			p->data=temp;
		}
	}
	return 0;
}

主函数 main.c

#include "head.h"
int main(int argc, const char *argv[])
{
	LinkList L_list=NULL;  //定义结点变量,注意定义时一定要指向NULL
	int n;            //定义循环输入次数
	ElemType value;   //定义数据域元素
	int seat;  //定义元素位置

	printf("please enter n:");
	scanf("%d",&n);
	
 	for(int i=0;i<n;i++)  //头插
	{
		printf("please enter a value:");
		scanf("%d",&value);
		L_list=insert_head(L_list,value);
	}

	for(int i=0;i<n;i++)  //尾插
	{	
		printf("please enter a value:");
		scanf("%d",&value);
		L_list=insert_rear(L_list,value);
	}
	Output(L_list);


 	//任意位置插入
	printf("please enter a seat:");
	scanf("%d",&seat);
	printf("please enter a value:");
	scanf("%d",&value);
	L_list=insert_by_seat(L_list,seat,value);
	Output(L_list);

	//任意元素查找
	printf("please enter a seat:"); 
	scanf("%d",&seat);
	search_by_seat(L_list,seat);
	Output(L_list);

	//任意位置修改
	printf("please enter a seat:"); 
	scanf("%d",&seat);
	printf("please enter a value:");
	scanf("%d",&value);
	modify_by_seat(L_list,seat,value);
	Output(L_list);

	//任意位置删除
	printf("please enter a seat which you want to delete:"); 
	scanf("%d",&seat);
	L_list=delete_by_seat(L_list,seat);
	Output(L_list);

	//任意元素查找
	printf("please enter the element you are looking for:");
	scanf("%d",&value);
	seat=search_by_element(L_list,value);
	printf("the element you are looking for is in %d\n",seat);

	//任意元素删除
	printf("please enter the element you want to delete:");
	scanf("%d",&value);
	L_list=delete_by_element(L_list,value);
	Output(L_list);

	//任意元素插入
	ElemType element;
	printf("please enter the element you are looking for:");
	scanf("%d",&value);
	printf("please enter the element you want to insert:");
	scanf("%d",&element);
	L_list=insert_by_element(L_list,value,element);
	Output(L_list);
	
	//任意元素修改
	printf("please enter the element you are looking for:");
	scanf("%d",&value);
	printf("please enter the element you want to modify:");
	scanf("%d",&element);
	modify_by_element(L_list,value,element);
	Output(L_list);
	
    //单链表逆置
	L_list=rev_list(L_list);
	Output(L_list);

    //冒泡排序单链表
	Bubble_list(L_list);
	Output(L_list);

    //简单选择排序单链表
	simple_list(L_list);
	Output(L_list);

	return 0;
}

数据结构：单向链表的增删改查
qq_42128262的博客
04-29 911
单向链表 定义：单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指向列表中的下一个结点； 数据结构： public class LinkList{ public Integer date; public LinkList next; ...
用c语言实现链表增删改查
11-07
通过以上分析，我们可以看到这段代码实现了单向链表的基本操作：创建、打印、删除、添加、查询和修改。这些操作为理解和使用链表打下了坚实的基础。此外，该程序还展示了C语言中的指针操作，这对于深入学习C语言和...
数据结构与算法---单向链表
weixin_73602725的博客
03-01 1800
单向链表的详细讲解（附完整版）
单向链表的C++实现(增删改查)
zorchp
11-08 1242
-
数据结构单向循环链表，创建以及增删改查的实现
小钱努力学C的博客
07-19 1270
循环链表基本操作，循环链表约瑟夫环问题
写一个单向链表并实现增删改查
qq_62537505的博客
04-07 662
写一个单向链表并实现增删改查
链表——单向链表的增删改查
LeeBlog
09-03 322
【目的】 实现单向链表的修改、删除操作 【代码实现】 链表的定义 //定义链表 class SingleLinkedList2{ //初始化一个头结点 private HeroNode head = new HeroNode(0,"" , ""); //添加结点 public void add(HeroNode heroNode) { HeroNode temp...
链表的增删改查
l602248的博客
08-25 554
以下为链表的增删改查的代码，大家如果有疑问，欢迎在评论区说出你的疑问，我们一起探讨。增：添加(创建)节点。
实现单向链表的增删改查操作
qq_44287198的博客
05-08 311
单向链表使用JAVA实现单向链表增删改查操作链表的定义单链表结构分析链表的实现 使用JAVA实现单向链表增删改查操作 链表的定义 （1）链表是以节点的方式来存储的，是链式存储，在内存中不一定是连续存储 （2）每个节点包含data域,next域：指向下一个节点 （3）链表分带头结点的链表和没有头结点的链表，根据实际的需求来确定 单链表结构分析 （1）首先我们来看链表的结构 头结点为空不设置内容，使其（next域）指向下一节点，链表尾部的（next域）指向空，在链表尾部添加节点只需要将链表尾部的（next域）
C语言——单向链表与增删改查
PanicLin的博客
01-06 357
文章目录认识链表创建单向链表链表的增删改查 认识链表 ·链表是可以动态地按需进行存储分配的一种结构。 ·与数组相比较链表更加灵活，数组需要事先定义固定长度，而链表不需要。 ·链表由数据域和指针域组成。数据域用来存放所需要的数据，指针域用来存放下一个结点的位置（地址）。 例子：创建一个关于学生信息的结构体，把此结构体当作链表的结点。 struct student { char name[10];//姓名 int weight;//体重 int height;//身高 int sex;//性别 str
单向链表增删改查、反转等操作
qq_33930457的博客
06-28 192
代码： public static void main(String[] args) { //创建节点 HeroNode hero1 = new HeroNode(1, "宋江", "及时雨"); HeroNode hero2 = new HeroNode(3, "吴用", "智多星"); HeroNode hero3 = new HeroNode(2, "卢俊义", "玉麒麟"); HeroNode hero4 = new HeroNode(7, "林冲", "豹子
用C++类实现单向链表的增删查和反转操作方法
12-31
数据结构这东西，理解起来不算难，但是实现难度就不小了，虽然思路很清晰，但不知道从何下手还有语言的细节问题一直是阻碍初学者的主要障碍（比如我）。今天用了一下午时间终于独立完成了链表操作。 找网上的代码，...
C语言单双向链表的增删改查以及排序问题完整代码
09-04
本主题聚焦于C语言实现的单双向链表，包括链表的基本操作：增、删、改、查和排序。以下是这些核心知识点的详细说明。 首先，链表是一种动态数据结构，它不像数组那样在内存中连续存储元素，而是通过节点间的指针...
【数据结构】实验二 单链表的基本操作
drt_0506的博客
11-14 411
1）根据输入的一系列整数，以0标志结束，用头插法建立单链表，并输出单链表中各元素值，观察输入的内容与输出的内容是否一致。4）在单链表中查找第i个元素，如果查找成功，则显示该元素的值，否则显示该元素不存在。2）在单链表的第i个元素之前插入一个值为x的元素，并输出插入后的单链表中各元素值。3）删除单链表中第i个元素，并输出删除后的单链表中各元素值。掌握链表基本操作的算法实现，以及对相应算法的性能分析。掌握线性表的链式存储结构的表示和实现方法。
数据结构_图的遍历
2301_79837864的博客
11-17 100
【代码】数据结构_图的遍历。
【数据结构和算法】-布隆过滤器
前鼻音的博客
11-14 788
布隆过滤器的思想就是，1个哈希容易冲突，那就上多个哈希函数，即使1个位上冲突了，其他位冲突的概率也非常小。注意map是key、value形式，我们要检测value存在不存在，是要通过实际判定value的值，如果value本身是个基础类型，那好说。不过，哈希算法会出现哈希冲突，在某些场景下，这是一个比较头疼的问题，就需要算法本身越来越复杂，而且也伴随着存储空间的增加。有些小伙伴又说了，图片也不怕，我有MD5，是，没错，但是要知道MD5的开销是比较大的，这样数据量少还可以，如果是百万级别的数据量呢？
数据结构王道P234第二题
最新发布
qq_63108111的博客
11-17 190
【代码】数据结构王道P234第二题。
C语言实现数据结构之二叉树
0xFFFFFFFF
11-15 636
本篇文章我们介绍了树的相关概念，用C语言实现了一棵二叉树的相关方法，如：前序遍历，中序遍历，后序遍历，层序遍历，创建销毁等，并完成了相关的OJ题
代码随想录刷题学习日记
weixin_73939095的博客
11-17 339
90.子集II
用单向链表实现增删改查
05-17
下面是用单向链表实现增删改查的代码实现： ```python # 定义单向链表节点类 class ListNode: def __init__(self, val): self.val = val self.next = None # 定义单向链表类 class LinkedList: def __init__...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值