数据结构day6单链表的（复杂）操作实现

最新推荐文章于 2024-10-31 13:56:46 发布
最新推荐文章于 2024-10-31 13:56:46 发布
阅读量141 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AuroraSmith/article/details/130541333
版权

数据结构day6单链表的（复杂）操作实现

链表的反转

代码：

int list_reverse(linklist H)
{
	linklist p;
	linklist q;
	if(H == NULL)
	{
		printf("H is NULL\n");
		return -1;
	}

	if(H->next == NULL || H->next->next == NULL)
	{
		return 0;
	}

	p = H->next->next;
	H->next->next = NULL;//链表一分为二 

	while(p != NULL)
	{
	q = p;
	p = p->next;

	q->next = H->next;
	H->next = q;

	}
	return 0;
}

请添加图片描述

请添加图片描述

链表求相邻两个节点最大值的第一个指针，和其相邻两个节点的最大值

代码：

linklist list_adjmax(linklist H, data_t *value)
{

	linklist p, q, r;
	data_t sum;

	if(H == NULL)
	{
		printf("H is NULL\n");
		return NULL;
	}
	if(H->next == NULL || H->next->next == NULL || H->next->next->next == NULL)//H中的data没有值
	{
		return H;
	}

	q = H->next;
	p = H->next->next;
	r = q;

	sum = q->data + p->data;

	while(p->next != NULL)
	{
		p = p->next;
		q = q->next;
		if(sum < q->data + p->data)
		{
			sum = q->data + p->data;
			r = q;

		}
	}
	*value = sum;

	return r;

}

请添加图片描述

请添加图片描述

两个有序链表的合并

代码：

int list_merge(linklist H1, linklist H2)
{	
	linklist p, q, r;


	if(H1 == NULL || H2 == NULL)
	{
		printf("H1 || H2 is NULL\n");
		return -1;
	}
	
	p = H1->next;
	q = H2->next;

	r = H1;

	H1->next = NULL;
	H2->next = NULL;


	while(p && q)
	{
		if(p->data <= q->data)
		{
			r->next = p;
			p = p->next;
			r = r->next;
			r->next = NULL;
		}
		else
		{
			r->next = q;
			q = q->next;
			r = r->next;
			r->next = NULL;
		}

	}

	if(p == NULL)
	{
		r->next = q;

	}
	else
	{
		r->next = p;
	}	

	
	return 0;
}

请添加图片描述

请添加图片描述

请添加图片描述

所有代码（day4-day6）

linklist.h


typedef int data_t;

typedef struct node{
	data_t data;
	struct node * next;


}listnode, * linklist;


linklist list_create();
int list_tail_insert(linklist H, data_t value);//Head
int list_show(linklist H);
int list_insert(linklist H, data_t value, int pos);//链表在新的位置插入一个节点
linklist list_get(linklist H, int pos);//得到特定位置节点的值
int list_delete(linklist H, int pos);//删除某一位置上的节点
linklist list_free(linklist H);//链表的释放
int list_reverse(linklist H);//链表的反转
linklist list_adjmax(linklist H, data_t *value);//求相邻两个节点data值之和为最大
int list_merge(linklist H1, linklist H2);//两个有序链表的合并,合并到H1中

linklist.c

#include <stdio.h>
#include "linklist.h"
#include <stdlib.h>


linklist list_create()
{
	linklist H;

	H = (linklist)malloc(sizeof(listnode));
	if(H == NULL)
	{
		printf("malloc failed\n");
		return H;
	}

	H->data = 0;
	H->next = NULL;

	return H;
}
int list_tail_insert(linklist H, data_t value)//Head
{
	linklist p;
	linklist q;

	if(H == NULL)
	{
		printf("H is empty\n");
		return -1;
	}

	//1 new node p
	if((p = (linklist)malloc(sizeof(listnode))) == NULL)
	{
		printf("malloc failed\n");
		return -1;
	}
	p->data = value;
	p->next = NULL;
	
	//2 locate tail node
	q = H;
	while(q->next != NULL)
	{
		q = q->next;
	}
	
	//3 insert
	
	q->next = p;
	

	return 0;
}
int list_show(linklist H)
{
	linklist p;
	if(H == NULL)
	{
		printf("H is NULL\n");
		return -1;
	}
	p = H;
	while(p->next != NULL)
	{
		printf("%d ", p->next->data);
		p = p->next;
	}
	puts(" ");
	return 0;
}

int list_insert(linklist H, data_t value, int pos)
{
	linklist p;
	linklist q;
	

	if(H == NULL)
	{
		printf("H is NULL\n");
	}

	//1 locate node p (pos-1)
	p = list_get(H, pos-1);
	
	if(p == NULL)
	{
		return -1;
	}

	//2 new node q
	if((q = (linklist)malloc(sizeof(listnode))) == NULL)
	{
		printf("malloc failed\n");
		return -1;
	}
	q->data = value;
	q->next = NULL;



	//3 insert
	q->next = p->next;
	p->next = q;

	return 0;
}
linklist list_get(linklist H, int pos)
{
	linklist p;
	int i;
	if(H == NULL)
	{
		printf("H is NULL\n");
		return NULL;
	}
	if(pos == -1)
	{
		return H;
	}
	if(pos < -1)
	{
		printf("pos is invalid\n");
		return NULL;
	}

	p = H;

	i = -1;
	while(i < pos)
	{
		p = p->next;
		if(p == NULL)
		{
			printf("pos is invalid\n");
			return NULL;
		}
		i++;
	}


	return p;

}
int list_delete(linklist H, int pos)
{
	linklist p;
	linklist q;

	//1
	if(H == NULL)
	{
		printf("H is NULL\n");
		return -1;
	}

	//2 locate prior找到上一个节点
	p = list_get(H, pos-1);
	if(p == NULL)
		return -1;

	if(p->next == NULL)
	{
		printf("delete pos is invalid\n");
		return -1;
	}
	
	//3 update list
	q = p->next;
	p->next = q->next;

	//4 free
	printf("free:%d\n",q->data);
	free(q);
	q = NULL;	
	
	

	return 0;
}
linklist list_free(linklist H)
{
	linklist p;
	if(H == NULL)
	{
		printf("H is NULL\n");
		return NULL;
	}
	p = H;

	printf("free:");
	while(H != NULL)
	{
		p = H;
		printf("%d ",p->data);
		H = H->next;
		
		free(p);
	}
	puts("");
	return NULL;
}
int list_reverse(linklist H)
{
	linklist p;
	linklist q;
	if(H == NULL)
	{
		printf("H is NULL\n");
		return -1;
	}

	if(H->next == NULL || H->next->next == NULL)
	{
		return 0;
	}

	p = H->next->next;
	H->next->next = NULL;//链表一分为二 

	while(p != NULL)
	{
	q = p;
	p = p->next;

	q->next = H->next;
	H->next = q;

	}
	return 0;
}
linklist list_adjmax(linklist H, data_t *value)
{

	linklist p, q, r;
	data_t sum;

	if(H == NULL)
	{
		printf("H is NULL\n");
		return NULL;
	}
	if(H->next == NULL || H->next->next == NULL || H->next->next->next == NULL)//H中的data没有值
	{
		return H;
	}

	q = H->next;
	p = H->next->next;
	r = q;

	sum = q->data + p->data;

	while(p->next != NULL)
	{
		p = p->next;
		q = q->next;
		if(sum < q->data + p->data)
		{
			sum = q->data + p->data;
			r = q;

		}
	}
	*value = sum;

	return r;

}
int list_merge(linklist H1, linklist H2)
{	
	linklist p, q, r;


	if(H1 == NULL || H2 == NULL)
	{
		printf("H1 || H2 is NULL\n");
		return -1;
	}
	
	p = H1->next;
	q = H2->next;

	r = H1;

	H1->next = NULL;
	H2->next = NULL;


	while(p && q)
	{
		if(p->data <= q->data)
		{
			r->next = p;
			p = p->next;
			r = r->next;
			r->next = NULL;
		}
		else
		{
			r->next = q;
			q = q->next;
			r = r->next;
			r->next = NULL;
		}

	}

	if(p == NULL)
	{
		r->next = q;

	}
	else
	{
		r->next = p;
	}	

	
	return 0;
}

test.c

#include "linklist.h"
#include <stdio.h>


int test_get(void);
int test_insert(void);
int test_delete(void);
int test_free(void);
int test_reverse(void);
int test_adjmax(void);
int test_merge(void);
int main(int argc, char *argv[])
{
	test_merge();
	return 0;
}

int test_get(void)
{
	linklist H;
	linklist p;
	int value;
	H = list_create();
	
	if(H == NULL)
		return -1;

	printf("input:\n");
	while(1)
	{
		scanf("%d",&value);
		if(value == -1)
			break;
		list_tail_insert(H, value);
		printf("input:\n");
	}
	list_show(H);

	p = list_get(H, 0);
	if(p != NULL)
	{
	printf("value:%d\n", p->data);
	}

}
int test_insert(void)
{

	linklist H;
	linklist p;
	int value;
	H = list_create();
	
	if(H == NULL)
		return -1;

	printf("input:\n");
	while(1)
	{
		scanf("%d",&value);
		if(value == -1)
			break;
		list_tail_insert(H, value);
		printf("input:\n");
	}
	list_show(H);

	list_insert(H, 100, 4);
	printf("*******************************\n");
	list_show(H);
	if(p != NULL)
	{
	printf("value:%d\n", p->data);
	}
}
int test_delete(void)
{
	linklist H;
	linklist p;
	int value;
	H = list_create();
	
	if(H == NULL)
		return -1;

	printf("input:\n");
	while(1)
	{
		scanf("%d",&value);
		if(value == -1)
			break;
		list_tail_insert(H, value);
		printf("input:\n");
	}
	list_show(H);

	list_delete(H, 2);
	printf("*******************************\n");
	list_show(H);

}
int test_free(void)
{
	linklist H;
	linklist p;
	int value;
	H = list_create();
	
	if(H == NULL)
		return -1;

	printf("input:\n");
	while(1)
	{
		scanf("%d",&value);
		if(value == -1)
			break;
		list_tail_insert(H, value);
		printf("input:\n");
	}
	list_show(H);

	list_delete(H, 2);
	printf("*******************************\n");
	list_show(H);
	printf("free before:H's position:%p\n",H);
	H = list_free(H);
	printf("free after:H's position:%p\n",H);


}
int test_reverse(void)
{
	linklist H;
	linklist p;
	int value;
	H = list_create();
	
	if(H == NULL)
		return -1;

	printf("input:\n");
	while(1)
	{
		scanf("%d",&value);
		if(value == -1)
			break;
		list_tail_insert(H, value);
		printf("input:\n");
	}
	list_show(H);
	
	list_reverse(H);
	printf("*******************************\n");
	list_show(H);
	H = list_free(H);
}

int test_adjmax(void)
{
	linklist H;
	linklist p;
	linklist r;
	int value;
	int sum;
	H = list_create();
	
	if(H == NULL)
		return -1;

	printf("input:\n");
	while(1)
	{
		scanf("%d",&value);
		if(value == -1)
			break;
		list_tail_insert(H, value);
		printf("input:\n");
	}
	list_show(H);
	
	r = list_adjmax(H, &sum);
	if( r != NULL && r != H)
	{
		printf("data is %d\n", r->data);
		printf("max is %d\n", sum);
	}
	list_show(H);
	H = list_free(H);
}
int test_merge(void)
{
	linklist H1;
	linklist H2;
	int i;

	int a[] = {1, 4, 6, 8, 10};
	int b[] = {2, 4, 8, 16, 20};

	H1 = list_create();
	H2 = list_create();
	if(H1 == NULL)
	{
		return -1;
	}
	if(H2 == NULL)
	{
		return -1;
	}
	for(i = 0; i < sizeof(a)/sizeof(int); i++)
	{
		list_tail_insert(H1, a[i]);
	}
	for(i = 0; i < sizeof(b)/sizeof(int); i++)
	{
		list_tail_insert(H2, b[i]);
	}

	list_show(H1);
	list_show(H2);

	list_merge(H1, H2);

	list_show(H1);
	list_show(H2);
	

	list_free(H1);
	list_free(H2);
}
Aurora Smith
关注
专栏目录
【数据结构与算法】程序员们常用的10个关键数据结构，包括它们的原理和C语言实现代码
AI天才研究院
05-02 8727
在计算机科学和编程中，我们每天使用各种数据结构来存储和操作数据。
实现链表的排序，从小到大
qq_45707522的博客
10-21 626
链表的排序
【数据结构】线性表之单链表（7）（函数功能实现：实现链表的排序）
m0_48572601的博客
03-10 773
实现链表的排序（使链表中元素的从无序到有序，要求从小到大）
数据结构-单链表的实现（删除和释放）day5（复杂操作的实现）day6
楚子航
04-08 3127
一、链表的删除 链表的删除：即实现DeleteLinklist(h, i)， 算法对应的链表结构如图所示。 算法思路：同插入法，先调用函数GetLinklist(h, i-1),找到结点ai的前驱，然后将结点ai删除之。 1.用q指向要被删除的节点，2.将被删除节点前方的箭头直接指向下一个节点。3.释放q指向节点的空间。 二、把整个链表释放 H指针往后走，p指针负责删除，H =NULL时结束。 三、代码 1.linklist.h: 2.linklist.c: 3....
数据结构（1）单链表基本操作——C语言代码实现
qq_56117689的博客
12-03 2281
作为一个数据结构学习的新手，这篇文章也算是笔记了，请根据目录食用 目录 一、用typedef声明新类型名 1、简单地使用一个新的类型名代替原有的类型名 2、命名一个简单的类型名代替复杂的类型表示方法 1、命名一个新的类型名代表结构体类型： 2、命名一个新的类型名代表数组类型 3、命名一个新的类型名代表指针类型 4、命名一个新的类型名代表指向函数的指针类型 二、malloc 三、头指针、头结点、首元结点 四、单链表的操作（C语言） 存储结构 初始化单链表 尾插法建立单链表-----
数据结构day4（单链表）
Hellomino_的博客
04-21 150
8> 链表的存储结构：链式存储【逻辑相邻，物理不一定相邻】3> 链表不存在满的情况，适用于与存储数据量较大的情况。1> 链表的插入和删除O(1),修改和查找O(n)2> 方便插入和删除，因为不需要移动大量元素。4> 链表适用于元素个数变化较大的情况。6> 链表不需要提前预估存储空间。7> 链表存储密度小于等于1。5> 链表属于动态申请空。
数据结构【没头单链表】
qq_67578580的博客
07-22 2278
图中指针变量plist保存的是第⼀个结点的地址，我们称plist此时“指向”第⼀个结点，如果我们希望 plist“指向”第⼆个结点时，只需要修改plist保存的内容为0x0012FFA0。链表中每个结点都是独⽴申请的（即需要插⼊数据时才去申请⼀块结点的空间），我们需要通过指针 变量来保存下⼀个结点位置才能从当前结点找到下⼀个结点。当我们想要保存⼀个整型数据时，实际是向操作系统申请了⼀块内存，这个内存不仅要保存整型数 据，也需要保存下⼀个节点的地址（当下⼀个节点为空时保存的地址为空）。
【数据结构】单链表的创建、逆置、遍历（C语言实现）
一个学生の乱记
02-27 451
实参向形参的数据传递是“值传递”，单向传递，只能由实参传给形参，而不能由形参传递给实参。所以本次实验我们传递给函数的是头结点的地址，使得函数通过地址找到头结点，并对头结点进行操作，而不能直接传递头结点，否则对头结点的操作将在函数结束时被释放。在本次实验中，我了解到结构体可以使用typedef函数，为算法代码的编写带来了极大的便利。struct LinkList 以及 struct LinkList* 均可用一个单词代替，使得主程序的编写更难出错，保持了较高的正确性，并且增加了程序的可读性。
数据结构day1
qq_52057773的博客
04-23 1027
静态数组在创建的时候就要确定数组的元素类型和元素数量。只有在 C++、Java、Golang 这类语言中才提供了创建静态数组的方式，类似 Python、JavaScript 这类语言并没有提供静态数组的定义方式。静态数组的用法比较原始，实际软件开发中很少用到，写算法题也没必要用，我们一般直接用动态数组。// 定义一个大小为 10 的静态数组// 用 memset 函数把数组的值初始化为 0// 使用索引赋值arr[0] = 1;arr[1] = 2;// 使用索引取值。
数据结构（Day15）
weixin_65095004的博客
09-18 1729
union EUM { 类型1 成员1；类型2 成员2；类型3 成员3；枚举常量： 定义格式： enum 枚举名 { 成员1，成员2，成员3，成员4 }；枚举成员直接使用，不需要结构体或者联合体那样引用。默认第一个成员是0，如果给第一个成员赋值，后面成员依次累加1定义函数实现输入，要求形参使用结构体指针接收函数实现5个学生年龄排序(注意对年龄排序时，交换的是所有信息)定义函数实现输出，要求形参使用结构体指针接收// 定义小车结构体，包含名称、价钱和颜色// 小车的名称// 小车的价格。
数据结构小练习-线性表（下）
06-25
理解线性表的基本操作对于学习更复杂的数据结构至关重要。 在"day02_code"文件中，可能包含了实现上述操作的示例代码。通过分析和运行这些代码，你可以更深入地理解线性表的内部工作原理，以及如何在实际编程中应用...
数据结构模拟题［二］
mufengzhiyu666的博客
10-30 473
4． 设一棵树 T 中边的集合为 {(A ，B) ，(A，C)，(A ，D)，(B，E)， (C，F)，(C，G)} ，要求用孩子兄弟表。7. 设一组初始记录关键字序列为 (55 ，63， 44， 38，75， 80，31， 56) ，则利用筛选法建立的初始堆为。3． 设一组有序的记录关键字序列为 (13 ，18，24，35， 47，50，62， 83，90) ，查找方法用二分查找，要。6． 设有一组初始记录关键字为 (45 ，80， 48，40，22， 78)，要求构造一棵二叉排序树并给出构造过程。
线性数据结构之链表
最新发布
m0_61840987的博客
10-31 442
单链表、双向链表、循环链表、哨兵链表在不同场景下的应用优势。每种链表类型在特定应用场景中能够发挥其独特的性能优势，通过选择合适的数据结构可以使程序更高效。
【高阶数据结构】红黑树的插入
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
10-29 878
超多精美配图讲解红黑树的插入方法；红黑树的插入C++完整代码的实现。
数据结构+算法分析与设计［19-21年真题版］
mufengzhiyu666的博客
10-29 324
八、设有一组关键字{19，01，23，14，55，20，84，27，68，11，10，77}，采用哈希函数： H(Key)=Key MOD 13， 采用开放地址法的线性探测再散列方法解决冲突，试在0～18的散列地址空间中对该关键字序列构造哈希表。八、依次输入表（30，15，28，20，24，10，12，68，35，50，46，55）中的元素，生成一棵二叉树排序树。七、给出一组关键字（29，18，25，47，58，12，51，10），分别写出按下列各种排序方法进行排序时的变化过程： （15分）
初阶数据结构之顺序表的实现
2402_84532723的博客
10-25 1375
/动态顺序表//顺序表的容量int size;//实际存储数据的个数}SL;typedef int SLDataType 对int进行类型重命名，如果需要存储char类型数据，只需要修改这里的int就可以了。十分的方便，代码也不容易出现错误。
20240818 字节跳动 笔试
lc_guo的博客
10-22 3703
BSP驱动开发工程师-OS、4 道编程题
线性数据结构之数组
m0_61840987的博客
10-31 192
数组是一种数据结构，用于存储多个相同类型的元素。在许多编程语言中，数组是最基本的数据结构之一，常用于管理和处理数据。数组的元素在内存中是连续存储的，可以通过索引直接访问。
10.28Python_数据结构_栈和链表
gs1we1的博客
10-28 1088
数据结构是计算机科学中的一个核心概念，它是指数据的组织、管理和存储方式，以及数据元素之间的关系。数据结构通常用于允许高效的数据插入、删除和搜索操作。：数组、链表、栈、队列等。：树、二叉树、堆、图等。：哈希表。：B树、B+树等。
商品货架管理的栈数据结构实现
"数据结构在商品货架管理中的应用，通过栈来实现商品的高效管理，栈顶商品生产日期最早，栈底商品生产日期最新。在上货时进行倒货架操作，确保新商品位于下方。提供的代码示例展示了如何用顺序栈（seqstack）存储...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Aurora Smith

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值