链表的插入，删除和遍历

最新推荐文章于 2024-04-19 23:47:37 发布
最新推荐文章于 2024-04-19 23:47:37 发布
阅读量257 收藏
点赞数 2
文章标签： 链表 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/n14401/article/details/136219523
版权

双向链表

主文件

#include <stdio.h>
#include "./03_shuang_head.h"

int main(int argc, const char *argv[])
{
	linkList* head = create_shuang_link();
	//头插
	shuang_head_cha(head,50);
	shuang_head_cha(head,40);
	shuang_head_cha(head,30);
	shuang_head_cha(head,20);
	shuang_head_cha(head,10);
	
	//尾插
	shuang_wei_cha(head,80);
	shuang_wei_cha(head,90);
	
	//按位置插入
/*	shuang_weiz_cha(head,11,1);
	shuang_weiz_cha(head,66,6);
	shuang_weiz_cha(head,999,9);   */
	
	//头删
/*	shuang_head_delete(head,10);   */

	//尾删
/*	shuang_wei_delete(head,90);	   */
	
	//按位置删除
	shuang_weiz_delete(head,4);

	//遍历
	shuang_bianli(head);

	return 0;
}

调用的函数文件

#include <stdio.h>
#include <stdlib.h>
#include "./03_shuang_head.h"

//创建一个空的双向链表
linkList* create_shuang_link(void)
{
	linkList* head = (linkList*)malloc(sizeof(linkList));
	if(head == NULL)
	{
		printf("创建失败!\n");
		return NULL;
	}
	head->text.len = 0;
	head->next = NULL;
	head->prev = NULL;

	return head;
}

//头插
void shuang_head_cha(linkList* head, dataType num)
{
	linkList* temp = (linkList*)malloc(sizeof(linkList));
	if(temp == NULL)
	{
		printf("头插失败\n");
		return;
	}
	temp->text.data = num;
	temp->next = NULL;
	temp->prev = NULL;

	if(head->next == NULL)
	{
		temp->next = head->next;
		head->next = temp;
		
		temp->prev = head;
	}
	else
	{
		temp->next = head->next;
		head->next = temp;
		
		temp->next->prev = temp;
		temp->prev = head;
	}
	
	printf("头插成功!\n");
	head->text.len++;

	return;

}

//尾插
void shuang_wei_cha(linkList* head, dataType num)
{
	linkList* temp = (linkList*)malloc(sizeof(linkList));
	if(temp == NULL)
	{
		printf("头插失败\n");
		return;
	}
	temp->text.data = num;
	temp->next = NULL;
	temp->prev = NULL;
	
	linkList* p =head;
	while(p->next != NULL)
		p = p->next;
	temp->next = p->next;
	p->next = temp;

	temp->prev = p;

	printf("尾插成功!\n");
	head->text.len++;
}

//按位置插入
void shuang_weiz_cha(linkList* head, dataType num, int pos)
{
	linkList* temp = (linkList*)malloc(sizeof(linkList));
	if(temp == NULL)
	{
		printf("头插失败\n");
		return;
	}
	temp->text.data = num;
	temp->next = NULL;
	temp->prev = NULL;

	if(pos < 1 || pos > temp->text.len+1)
	{
		printf("插入位置非法，插入失败!\n");
		return;
	}
	linkList* p = head;
	for(int i = 0; i < pos-1; i++)
		p = p->next;
	if(p->next != NULL)
	{
		temp->next = p->next;
		p->next = temp;

		temp->next->prev = temp;
		temp->prev = p;
	}
	else
	{
		temp->next = p->next;
		p->next = temp;

		temp->prev = p;
	}
	printf("按位置插入成功!\n");
	head->text.len++;
}

//头删
dataType shuang_head_delete(linkList* head, dataType num)
{
	if(head->next == NULL)
	{
		printf("链表为空，无法删除\n");
		return -1;
	}
	linkList* p = head->next;
	if(p->next != NULL)
	{
		head->next = p->next;
		p->next->prev = head;
		dataType num = p->text.data;
		printf("头删除的节点num = %d\n", num);
		free(p);
	}
	else
	{
		head->next = p->next;
		dataType num = p->text.data;
		printf("头删除的节点num = %d\n", num);
		free(p);
	}

	head->text.data = num;
	head->text.len--;
	return num;
}

//尾删
dataType shuang_wei_delete(linkList* head, dataType num)
{
	if(head->next == NULL)
	{
		printf("链表为空，无法删除\n");
		return -1;
	}
	linkList* p = head;
	while(p->next != NULL)
		p = p->next;
	p->prev->next = NULL;
	num = p->text.data;
	printf("头删除的节点num = %d\n", num);
	free(p);

	head->text.data = num;
	head->text.len--;
	return num;

}

//按位置删除
dataType shuang_weiz_delete(linkList* head, int pos)
{
	linkList* p = head;
	for(int i = 0; i < pos; i++)
		p = p->next;
	if(p->next != NULL)
	{
		p->prev->next = p->next;
		p->next->prev = p->prev;
		dataType num = p->text.data;
		printf("按位置删除的节点num = %d\n", num);
		free(p);
	}
	else
	{
		p->prev->next = p->next;
		dataType num = p->text.data;
		printf("按位置删除的节点num = %d\n", num);
		free(p);
	}
	dataType num = head->text.data;
	head->text.len--;
	return num;
}

//遍历
void shuang_bianli(linkList* head)
{
	linkList* p = head;
	while(p->next != NULL)
	{
		p = p->next;
		printf("%d ",p->text.data);
	}
	printf("\n");

	return;
}

头文件

#ifndef __shuang_h__
#define __shuang_h__
typedef int dataType; //由于应用中不一定为int类型，所以重名为dataTppe

//使用联合体存储数据域信息
union msg{
    dataType data;  //有效数据节点
    int len;        //头结点的表长
};

//由于节点中的指针域要指向下一个节点，所以必须使用有名结构体
typedef struct node{
    //数据域: 若是头结点，则使用text里的len,
    //        若是有效数据节点，则使用text里的data
    union msg text;                                                  
    struct node* next; //指针域，存储下一个节点的地址
	struct node* prev; //指针域，存储上一个节点的地址
}linkList;

//创建一个空的双向链表
linkList* create_shuang_link(void);
//头插
void shuang_head_cha(linkList* head, dataType num);
//遍历
void shuang_bianli(linkList* head);
//尾插
void shuang_wei_cha(linkList* head,dataType num);
//按位置插入
void shuang_weiz_cha(linkList* head, dataType num, int pos);
//头删
dataType shuang_head_delete(linkList* head, dataType num);
//尾删
dataType shuang_wei_delete(linkList* head, dataType num);
//按位置删除
dataType shuang_weiz_delete(linkList* head, int pos);

#endif

单向循环链表

主文件

#include <stdio.h>
#include "./33_xunhuan_head.h"
int main(int argc, const char *argv[])
{
	linkList* head = create_xunh_link();
	//头插
	xunh_link_head_charu(head,55);
	xunh_link_head_charu(head,44);
	xunh_link_head_charu(head,33);
	xunh_link_head_charu(head,22);
	xunh_link_head_charu(head,11);
	
	//尾插
	xunh_link_wei_cha(head,66);
	xunh_link_wei_cha(head,77);
	xunh_link_wei_cha(head,88);
	
	//头删
	xunh_head_delete(head);

	//尾删
	xunh_wei_delete(head);

	//遍历
	xunh_link_bianli(head);

	return 0;
}

调用的函数文件

#include <stdio.h>
#include <stdlib.h>
#include "./33_xunhuan_head.h"

//创建空的单向循环链表
linkList* create_xunh_link(void)
{
    //头结点
    linkList* head = (linkList*)malloc(sizeof(linkList));
    if(head == NULL)
    {
        printf("头结点为空，创建链表失败!\n");
        return NULL;
    }

    head->text.len = 0;  //初始化头结点的表长为0
    head->next = head;   //初始化指针域为空

    return head;
}                                                        

//单项循环链表头插
void xunh_link_head_charu(linkList* head,dataType num)
{
	linkList* temp = (linkList*)malloc(sizeof(linkList));
	if(temp == NULL)
	{
		printf("创建节点失败\n");
		return;
	}
	//初始化
	temp->text.data = num;
	temp->next = NULL;
	//头插
	temp->next = head->next;
	head->next = temp;

	head->text.len++;
	printf("单向循环链表头插成功\n");

	return;
}

//单项循环链表尾插
void xunh_link_wei_cha(linkList* head,dataType num)
{
	linkList* temp = (linkList*)malloc(sizeof(linkList));
	if(temp == NULL)
	{
		printf("创建节点失败\n");
		return;
	}	
	temp->text.data = num;
	temp->next = NULL;
	//尾插
	linkList* p = head;
	while(p->next != head)
	{
		p = p->next;
	}
	temp->next = head;
	p->next =temp;

	head->text.len++;
	printf("单向循环链表尾插成功!\n");

	return;
}

//循环链表遍历
void xunh_link_bianli(linkList* head)
{
	linkList* p = head;
	while(p->next != head)
	{
		p = p->next;
		printf("%d ",p->text.data);
	}
	printf("\n");

	return;
}

//头删
dataType xunh_head_delete(linkList* head)
{
	if(head->next == head)
	{
		printf("链表为空，无法删除\n");
		return -1;
	}
	linkList* temp = head->next;
	head->next = temp->next;

	dataType num = temp->text.data;
	printf("头删除的节点num = %d\n", num);
	free(temp);
	temp = NULL;
	
	head->text.len--;
	return num;
}

//尾删
dataType xunh_wei_delete(linkList* head)
{
	if(head->next == head)
	{
		printf("链表为空，无法删除\n");
		return -1;
	}
	linkList* p = head;
	while(p->next->next != head)
	{
		p = p->next;
	}
	dataType num = p->next->text.data;
	printf("尾删除的节点num = %d\n",num);
	free(p->next);
	p->next = head;

	head->text.len--;

	return num;
}

头文件

#ifndef __xunhuanlink_h__
#define __xuanhuanlink_h__

typedef int dataType; //由于应用中不一定为int类型，所以重名为dataTppe

//使用联合体存储数据域信息
union msg{
    dataType data;  //有效数据节点
    int len;        //头结点的表长
};

//由于节点中的指针域要指向下一个节点，所以必须使用有名结构体
typedef struct node{
    //数据域: 若是头结点，则使用text里的len,
    //        若是有效数据节点，则使用text里的data
    union msg text;                                                  
    struct node* next; //指针域，存储下一个节点的地址
}linkList;

//创建空的单向循环链表
linkList* create_xunh_link(void);
//单向循环链表头插
void xunh_link_head_charu(linkList* head,dataType num);
//单向循环链表头删
void xunh_link_wei_cha(linkList* head,dataType num);
//循环链表遍历
void xunh_link_bianli(linkList* head);
//头删
dataType xunh_head_delete(linkList* head);
//尾删
dataType xunh_wei_delete(linkList* head);


#endif

nmq3929
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
yuandaima.zip_插入排序_链表插入排序
09-20
链表插入排序的时间复杂度与数组插入排序相同，但在链表操作上，插入和删除通常比数组更高效。 在实际应用中，快速排序通常是首选的排序算法，因为它具有较高的平均性能，时间复杂度为O(n log n)。然而，对于小型...
猴子也能看懂的Java数据结构与算法——单链表元素删除解析及高频面试题
wyx1473343124的博客
07-21 497
这里我们使用双指针法，先让快慢指针步差为K+1，然后快慢指针同步移动，这样当快指针指向链表末尾的null时（你也可以理解成链表最后一个元素是倒数第1节点，最后一个元素的null指针域是倒数第0节点），即快指针指向倒数第0个节点时，因为步差K+1,所以这时慢指针指向倒数第K+1个节点，也就是前驱节点。那回到之前所说的，把cur.next.next赋值给cur.next，这也就是说，让cur.next也指向后继结点。//如果值相同，则删除cur.next, cur不移动，和下一个cur.next继续比较。
链表 - 203. 移除链表元素(C#和C实现)
Ammmmmmmmn的博客
12-09 658
若是则删除该节点。需要注意的是，删除节点时需要更新前一个节点的。使用迭代或递归的方式遍历链表，检查每个节点的值是否等于目标值。删除链表中等于给定值。
删除整个链表的方法
qq_62846665的博客
08-31 2079
删除整个链表的方法
链表的删除
2401_83430041的博客
04-14 166
删除节点
链表之移除链表元素的三种方法
2301_79646104的博客
02-26 889
再往回“归”，递的时候，当发现节点为空时停止，开始往回归，判断是否节点满足条件，开始移除节点操作。第三种方法就是递归，这种方法较难理解，建议新手使用第二种方法，递归就是，先往下“递”引入力扣的203移除链表元素。，请你删除链表中所有满足。给你一个链表的头节点。
单链表的插入删除 遍历等操作
12-05
单链表操作的一个重要特点是它们通常不是常数时间复杂度，如插入和删除需要O(n)的时间，因为可能需要遍历整个链表找到特定位置。但单链表的优点在于插入和删除操作相对简单，只需要改变少数几个指针，而不需要像数组...
数据结构算双链表的初始化 插入 删除 遍历 代码
06-02
数据结构算双链表的初始化 插入 删除 遍历 代码
sss.rar_sss_双向链表_链表_链表 插入
09-14
双向链表插入结点 插入节点操作分为头插、尾插以及在任意位置插入。在双向链表中，插入节点时需要同时更新前后两个节点的指针。例如，在某个节点后插入新节点，需要将新节点的前一个指针设为原节点，后一个指针设...
链表 删除
最新发布
JINbigXIA的博客
04-19 141
先说说情况吧：今天刷题时间不太够，写博客的时候已经11点了，而且刷题也没用深度思考。（因为不确定是头节点是否会被删除，所以要返回头节点就返回虚拟头节点的next）在做链表的题目时，我们需要定义一个遍历的指针cur，类型是和链表一个类型的。步骤：首先创建一个虚拟头节点，将head的位置赋值给虚拟头节点的 next。这是第一种方法，主要的蛮烦就是需要把头节点和非头节点分开判断。但是注意头节点删除要用while，不能用if。最后把虚拟头节点的next赋值给head。首先把 头节点的位置赋值给cur。
数据结构之链表的删除
StevenBian的博客
05-06 7544
思路分析 1：因为题目中只给定了要删除的节点,并没有给出链表的头结点，所以无法通过遍历查询到待删除节点的上一个节点，然后执行删除操作 2：对此，我们利用给定的待删除节点的信息，将待删除节点的下一个节点的值付给待删除的节点，这样就可以将待删除节点的next指针域指向下一个节点的下一个，从而实现删除操作 class Solution { public void deleteNode(ListNode node) {
删除整个链表
MatrixDK的博客
01-11 787
当有些空间不再需要时，你可以用free命令通知系统来回收他。free(p)的结果是：p正在指向的地址没变，但再该地址处的数据此时已无定义了。对于要放弃的单元，应该需要一个临时的变量，因为在撤除指针的工作结束后，你将不能再引用它。以上代码不是删除整个表的正确方法。——摘自《数据结构预算法分析》P38.
链表的删除操作
和产品battle的秃头程序
06-10 1万+
趁着今天还有点时间，再分享一题，这里有两个题目，题目一：给定单项链表的头指针和一个节点指针，定义一个函数在O（1）时间内删除该节点。思路：把非头节点和尾节点的后一位节点的值覆盖到要删除的节点，然后把删除的节点的next指向它下一个节点的下一个节点就OJBK了如：1-&gt;2-&gt;3-&gt;4    需要删除3，那么把3覆盖到2那里得到    1-&gt;3-&gt;3-&gt;4    然...
链表删除
yisish的博客
03-02 314
题目描述 请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。 现有一个链表 – head = [4,5,1,9]，它可以表示为: 示例 输入: head = [4,5,1,9], node = 1 输出: [4,5,9] 解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -&amp;amp;amp;gt; 5 -&amp;amp;amp;gt; 9. 思路介绍 因为...
单链表的删除
w.here的CSDN
03-18 370
Time Limit: 3000ms, Memory Limit: 10000KB, Accepted: 299, Total Submissions: 494Description已知A,B和C为三个非递减有序的线性表，均以单链表作为存储结构。现要求对A表作如下操作：删去那些既在B表中出现又在C表中出现的元素。试对单链表编写实现上述操作的算法，并释放A表中的无用结点空间。Input第一行输入3个...
C语言实现单链表删除
热门推荐
weixin_43484734的博客
10-23 3万+
C语言实现单链表删除所有与条件相符的结点 删除链表的结点指若某结点数据域的值满足给定的条件，则将该节点删除。 删除链表结点有两个原则： （1）删除操作不应该破坏原链接关系。 （2）删除结点前，应该有一个删除位置的查找子过程。 在删除一个结点时可能遇到以下三种情况： （1）链表为空。此时不用做任何操作，直接返回。 （2）链表头就是要删除的结点。这时先用一个指针q暂存此结点，再将链表头指向下一结点，最...
链表的插入，遍历，查找和删除
05-24
链表是一种常见的数据结构，它由若干个节点组成，每个节点中包含了一个数据元素和一个指向下一个节点的指针。链表可以用来实现栈、队列等数据结构。 以下是链表的插入、遍历、查找和删除操作的具体实现： 插入操作： 在链表中插入一个新的节点通常需要以下步骤： 1. 创建一个新的节点，赋值为要插入的数据。 2. 找到要插入的位置，即在哪两个节点之间插入新节点。 3. 将新节点的指针指向下一个节点，并将前一个节点的指针指向新节点。 代码实现： ```python class Node: def __init__(self, data=None): self.data = data self.next = None class LinkedList: def __init__(self): self.head = None def insert(self, data): new_node = Node(data) if self.head is None: self.head = new_node return current_node = self.head while current_node.next is not None: current_node = current_node.next current_node.next = new_node ``` 遍历操作： 遍历链表通常需要以下步骤： 1. 从头节点开始，依次遍历每个节点。 2. 对于每个节点，执行相应的操作，例如打印节点中的数据。 代码实现： ```python class LinkedList: def __init__(self): self.head = None ... def traverse(self): if self.head is None: print("Linked list is empty") return current_node = self.head while current_node is not None: print(current_node.data) current_node = current_node.next ``` 查找操作： 在链表中查找一个节点通常需要以下步骤： 1. 从头节点开始，依次遍历每个节点。 2. 对于每个节点，判断其包含的数据是否与要查找的数据相等。 3. 如果找到了相等的节点，返回该节点；否则，返回 None。 代码实现： ```python class LinkedList: def __init__(self): self.head = None ... def search(self, data): if self.head is None: return None current_node = self.head while current_node is not None: if current_node.data == data: return current_node current_node = current_node.next return None ``` 删除操作： 在链表中删除一个节点通常需要以下步骤： 1. 找到要删除的节点，即在哪两个节点之间删除节点。 2. 将前一个节点的指针指向后一个节点。 代码实现： ```python class LinkedList: def __init__(self): self.head = None ... def delete(self, data): if self.head is None: return if self.head.data == data: self.head = self.head.next return current_node = self.head while current_node.next is not None: if current_node.next.data == data: current_node.next = current_node.next.next return current_node = current_node.next ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值