链表的插入，删除和遍历

最新推荐文章于 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
    评论
【数据结构与算法】之双向链表的创建/遍历/插入/删除/查找的算法实现
╰つ栺尖篴夢ゞ
08-06 983
双向链表是数据结构中重要的结构，也是线性结构中常用的数据结构，双向指针，方便用户从首结点开始沿指针链向后依次遍历每一个结点，结点的前驱和后继查找方便。 其实双向链表和单向链表也是有很多相似的地方的，每个节点都包含两个指针，一个指针指向上一个节点，一个指针指向下一个节点。 两个特殊的地方，第一就是头节点的一个指针指向NULL空指针（没有前驱节点），第二就是尾节点的一个指针指向NULL指针（没有后继节点）。
【数据结构与算法】之单向循环链表的创建/遍历/插⼊/查找/删除算法实现
╰つ栺尖篴夢ゞ
08-06 1253
循环链表是一个收尾相接的链表，将单链表的最后一个指针域改由NULL改为指向表头结点这就是单链式的循环链表，并称为循环单链表。 带头结点的循环单链表的各种操作的算法实现与带头结点单链表的算法实现类似，差别仅在于算法判别当前结点p是否为尾结点的条件不同。单链表中的判别条件为p!=NULL或p->next!=NULL，而单循环链表判别条件是p!=L或p->next!=L。 在循环单链表中附设尾指针有时候比附设头指针更简单。
链表的删除
2401_83430041的博客
04-14 164
删除节点
链表 删除
最新发布
JINbigXIA的博客
04-19 141
先说说情况吧：今天刷题时间不太够，写博客的时候已经11点了，而且刷题也没用深度思考。（因为不确定是头节点是否会被删除，所以要返回头节点就返回虚拟头节点的next）在做链表的题目时，我们需要定义一个遍历的指针cur，类型是和链表一个类型的。步骤：首先创建一个虚拟头节点，将head的位置赋值给虚拟头节点的 next。这是第一种方法，主要的蛮烦就是需要把头节点和非头节点分开判断。但是注意头节点删除要用while，不能用if。最后把虚拟头节点的next赋值给head。首先把 头节点的位置赋值给cur。
删除整个链表的方法
qq_62846665的博客
08-31 2079
删除整个链表的方法
链表之移除链表元素的三种方法
2301_79646104的博客
02-26 889
再往回“归”，递的时候，当发现节点为空时停止，开始往回归，判断是否节点满足条件，开始移除节点操作。第三种方法就是递归，这种方法较难理解，建议新手使用第二种方法，递归就是，先往下“递”引入力扣的203移除链表元素。，请你删除链表中所有满足。给你一个链表的头节点。
链表 - 203. 移除链表元素(C#和C实现)
Ammmmmmmmn的博客
12-09 656
若是则删除该节点。需要注意的是，删除节点时需要更新前一个节点的。使用迭代或递归的方式遍历链表，检查每个节点的值是否等于目标值。删除链表中等于给定值。
链表的创建、遍历、查找、插入、删除
qq_44829047的博客
02-20 3608
一、链表的创建（头插法、尾插法） 1、准备工作： #include<stdio.h> #include<stdlib.h> //提供 malloc 和 free 函数 typedef struct node{ //typedef 是重新定义数据类型 struct node int data; struct node *next; }NODE,*PNODE; 2、头插法： //头插法创建链表 PNODE HeadInsert(int n) { int i,temp; PNO
单向链表的添加及遍历
furthermore1的博客
12-07 673
单向链表的添加及遍历 一、在链表尾添加新节点 1.创建：头节点head（不存放任何数据） 2.遍历：利用临时变量temp遍历整个单链表 在这里插入代码片
猴子也能看懂的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继续比较。
数据结构之链表的删除
StevenBian的博客
05-06 7544
思路分析 1：因为题目中只给定了要删除的节点,并没有给出链表的头结点，所以无法通过遍历查询到待删除节点的上一个节点，然后执行删除操作 2：对此，我们利用给定的待删除节点的信息，将待删除节点的下一个节点的值付给待删除的节点，这样就可以将待删除节点的next指针域指向下一个节点的下一个，从而实现删除操作 class Solution { public void deleteNode(ListNode node) {
删除整个链表
MatrixDK的博客
01-11 786
当有些空间不再需要时，你可以用free命令通知系统来回收他。free(p)的结果是：p正在指向的地址没变，但再该地址处的数据此时已无定义了。对于要放弃的单元，应该需要一个临时的变量，因为在撤除指针的工作结束后，你将不能再引用它。以上代码不是删除整个表的正确方法。——摘自《数据结构预算法分析》P38.
C语言实现单链表删除
热门推荐
weixin_43484734的博客
10-23 3万+
C语言实现单链表删除所有与条件相符的结点 删除链表的结点指若某结点数据域的值满足给定的条件，则将该节点删除。 删除链表结点有两个原则： （1）删除操作不应该破坏原链接关系。 （2）删除结点前，应该有一个删除位置的查找子过程。 在删除一个结点时可能遇到以下三种情况： （1）链表为空。此时不用做任何操作，直接返回。 （2）链表头就是要删除的结点。这时先用一个指针q暂存此结点，再将链表头指向下一结点，最...
链表删除
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个...
链表的删除操作
和产品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    然...
链表的插入，遍历，查找和删除
05-24
以下是链表的插入、遍历、查找和删除操作的具体实现： 插入操作： 在链表中插入一个新的节点通常需要以下步骤： 1. 创建一个新的节点，赋值为要插入的数据。 2. 找到要插入的位置，即在哪两个节点之间插入新节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值