【数据结构】Day4 作业 链表

已于 2023-06-14 13:29:13 修改
阅读量81 收藏
点赞数
文章标签： 数据结构 c#
于 2023-06-13 21:22:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangxiasun/article/details/131196606
版权

 main.c

#include "head.h"

int main(int argc, const char *argv[])
{
	//1表示头节点，0表示普通节点
	Linklist L=creat_node(1);  //创建头节点

	int n;
	datatype e;
	Linklist rear=L;  //定义尾部节点地址,注意初始化
	printf("请输入要插入的个数n:");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		printf("请输入要插入的值:");
		scanf("%d",&e);
	//	insert_head(L,e);        //链表头插
		rear=insert_rear(L,e,rear);  //链表尾插
	}
	output(L);  //链表输出
	
	int pos;
	datatype key;

	printf("请输入要查找的元素：");
	scanf("%d",&key);
	pos=search_data(L,key);
	if(pos==-1) printf("查找失败");
	else printf("要查找的元素%d的位置是:%d\n",key,pos);

//单链表按照元素修改
	printf("请输入要修改的元素：");
	scanf("%d",&key);	
	printf("请输入要修改的元素值：");
	scanf("%d",&e);
	update_data(L,key,e);
	output(L);

//单链表按照元素插入
	printf("请输入要插入的元素：");
	scanf("%d",&key);	
	printf("请输入要插入的元素值：");
	scanf("%d",&e);
	insert_data(L,key,e);
	output(L);

//单链表按照元素插入
	printf("请输入要删除的元素：");
	scanf("%d",&key);	
	delete_data(L,key);
	output(L)
		
		;
//单链表逆置
	printf("逆置后:");
	rev(L);
	output(L);

	return 0;
}

test.c

#include "head.h"

/*
 * function:    创建节点
 * @param [ in] 
 * @param [out] 1:表示头节点；0：表示普通节点
 * @return      成功返回首地址,失败返回NULL
 */
Linklist creat_node(int flag)
{
	Linklist L=(Linklist)malloc(sizeof(struct Node));
	if(NULL==L)
	{
		return NULL;
	}
	//对L初始化
	if(flag==1)      L->len=0;  //对L节点数据域清空
	else if(flag==0) L->data=0; 
	L->next=NULL;  //对L的指针域初始化指向null
	return L;
}

/*
 * function:    链表头插
 * @param [ in] 头结点，插入的值
 * @param [out] 
 * @return      成功返回0，失败返回-1
 */

int insert_head(Linklist L,datatype e)
{
	//判断头结点是否创建成功
	if(NULL==L)
	{
		return -1;
	}

	//2.插入新节点s
	Linklist s=creat_node(0);
	if(NULL==s)  //判断s是否为空
	{
		return -1;
	}
	//s的数据域赋值,指针域赋值
	s->data=e;
	s->next=L->next;
	L->next=s;

	L->len++;
	
	return 0;
}

/*
 * function:    链表的输出
 * @param [ in] 链表
 * @param [out] 
 * @return      无
 */
void output(Linklist L)
{
	//1.判断链表是否创建成功
	//2.判断链表是否为空，L->len==0 || L->next==NULL
	if ((NULL==L) || (L->next)==NULL)  return;

	//3.循环遍历
	Linklist p=L;
	while(p->next!=NULL)
	{
		p=p->next;
		printf("%d\t",p->data);
	}

/*	for(int i=0;i<L->len;i++)  /依赖于len
	{
		p=p->next;
		printf("%d\t",p->data);
	}
*/
	putchar(10);
}


/*
 * function:    尾插
 * @param [ in] 头节点，插入的元素
 * @param [out] 尾部节点地址
 * @return      成功返回尾部节点地址
 */
Linklist insert_rear(Linklist L,datatype e,Linklist rear)
{
	//1.判断头节点是否创建成功
	if(NULL==L) return NULL;

	//2.在尾部插入新节点s
	Linklist s=creat_node(0);
	if(s==NULL) return NULL;

	s->data=e;
	rear->next=s;
	rear=s;

	L->len++;
	
	return rear;
}


/*
 * function:    头删除
 * @param [ in] 链表
 * @param [out] 
 * @return      成功返回0；失败返回-1
 */

int delete_head(Linklist L)
{
	//判断头节点是否创建成功、
	//判断链表是否为空
	if((NULL==L) || (NULL==L->next))
	{
		return -1;
	}

	//删除L->next
	Linklist q=L->next;
	L->next=q->next;
	free(q);
	q=NULL;
	L->len--;

	return 0;
}

/*
 * function:    尾删：尾部删除一个节点
 * @param [ in] 链表
 * @param [out] 
 * @return      成功返回0，失败返回-1
 */

int delete_rear(Linklist L)
{
	//判断头节点是否创建成功、
	//判断链表是否为空
	if((NULL==L) || (NULL==L->next))
	{
		return -1;
	}

	//尾部删除,先循环到倒数第二个节点L->next-next
	Linklist p=L;
	while(p->next->next!=NULL) //循环到倒数第二个节点
	{
		p=p->next;
	}
	free(p->next);   //释放最后一个节点
	p->next=NULL;
	L->len--;

	return 0;
}

/*
 * function:    按任意位置插入
 * @param [ in]
 * @param [out] 链表 位置 插入的值
 * @return      成功返回0.失败返回-1；
 */

int insert_pos(Linklist L,int pos,datatype e)
{
	//1.判断头节点是否创建成功
	//2.判断插入的位置是否合法
	if(NULL==L || pos<1 || pos>L->len+1)
	{
		return -1;
	}

	//3.在pos位置插入e
	Linklist p=L;
	Linklist s=creat_node(0);  //创建一个要插入的新节点s
	for(int i=0;i<pos-1;i++)
	{
		p=p->next;   //p循环到指向pos-1的位置
	}
	if(s==NULL)  return -1;
	s->data=e;
	s->next=p->next;
	p->next=s;
	L->len++;
	return 0 ;
}

/*
 * function:    按照任意位置删除
 * @param [ in] 
 * @param [out] 链表 位置
 * @return      成功返回0，失败返回-1
 */
int delete_pos(Linklist L,int pos)
{
	//1.判断头节点是否创建成功
	//2.判读删除的位置是否合法
	if(NULL==L || pos<1 || pos>L->len)
	{
		printf("删除失败");
		return -1;
	}

	//3.删除pos位置的节点
	Linklist p=L;
	for(int i=0;i<pos-1;i++) //循环到pos-1的位置
	{
		p=p->next;  
	}
	//删除p->next的节点
	Linklist q=p->next;    //定义新的q  ?
	p->next=q->next;        //?
	free(q);
	q=NULL;

	L->len--;	

	return 0;
}


/*
 * function:    按照任意位置查找
 * @param [ in] 
 * @param [out] 链表，位置
 * @return      返回值
 */
datatype search_pos(Linklist L,int pos)
{
	//判断头节点是否创建成功
	//判断位置是否合法
	if(NULL==L || pos<1 || pos>L->len)
	{
		return -1;
	}
	
	//找到pos位置
	Linklist p=L;
	for(int i=0;i<pos;i++)
	{
		p=p->next;
	}
	return p->data;
}

/*
 * function:    链表按位置修改
 * @param [ in] 链表，位置，值
 * @param [out] 
 * @return      成功返回0；失败返回-1
 */
int update_pos(Linklist L,int pos,datatype e)
{
	//判断头节点是否创建成功
	//判断位置是否合法
	if(NULL==L || pos<1 || pos>L->len)
	{
		return -1;
	}
	
	//找到pos位置
	Linklist p=L;
	for(int i=0;i<pos;i++)
	{
		p=p->next;
	}

	p->data=e;
	return 0;;
}


/*
 * function:    链表通过元素查找
 * @param [ in] 链表 查找的值
 * @param [out] 
 * @return      返回位置
 */
int search_data(Linklist L,datatype key)
{
	//1.判断头结点是否创建成功、
	//2.判断链表是否为空
	if(NULL==L || NULL==L->next)
	{
		return -1;
	}
	
	Linklist p=L;
	int pos=0;
	while(p->next!=NULL)
	{
		p=p->next;
		pos++;
		if(p->data==key)
		{
			return pos;
		}
	}
	return -1;
}


/*
 * function:    单链表按照元素修改
 * @param [ in] 链表 元素位置 元素值
 * @param [out] 
 * @return      成功返回0，失败返回-1
 */

int update_data(Linklist L,datatype key,datatype e)
{
	int pos=search_data(L,key);
	if(pos==-1) return -1;

	update_pos(L,pos,e);
	return 0;
}



/*
 * function:    单链表按照元素插入
 * @param [ in] 链表 元素位置 元素值
 * @param [out] 
 * @return      成功返回0，失败返回-1
 */

int insert_data(Linklist L,datatype key,datatype e)
{
	int pos=search_data(L,key);
	if(pos==-1) return -1;

	insert_pos(L,pos,e);
	return 0;
}


/*
 * function:    单链表按照元素删除
 * @param [ in] 链表 元素值
 * @param [out] 
 * @return      成功返回0，失败返回-1
 */


int delete_data(Linklist L,datatype key)
{
	int pos=search_data(L,key);
	if(pos==-1) return -1;

	int i=0;
	Linklist p=L;
	while(p->next!=NULL)
	{
		i++;
		p=p->next;
		if(p->data == key)
		{
			delete_pos(L,i);
			i--;
		}
	}
	return 0;
}


/*
 * function:    逆置
 * @param [ in] 链表
 * @param [out] 
 * @return      无
 */
void rev(Linklist L)
{	
	//1.判断头结点是否创建成功、
	//2.判断链表是否为空
	if(NULL==L || NULL==L->next)
	{
		return;
	}

	//逆置
	Linklist p=L->next;  //头插需要保存L，否则后续节点丢失
	L->next=NULL;
	while(p!=NULL)
	{
		Linklist t=p;  //头插需要保存p,否则后续节点丢失
		p=p->next;
		t->next=L->next; //头插
		L->next=t;	
	}
}

head.h

#ifndef __HEAD_H__
#define __HEAD_H__

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

typedef int datatype;
//带头节点结构定义
typedef struct Node
{
	//数据域
	union{
		int len;       //头节点的数据域；链表
		datatype data; //其他节点的数据域
	};
	//指针域：指向下一个节点的地址
	struct Node *next;
}*Linklist;


Linklist creat_node(int flag);            //创建节点
int insert_head(Linklist L,datatype e);   //链表头插
Linklist insert_rear(Linklist L,datatype e,Linklist rear);
void output(Linklist L);   //链表输出
int delete_head(Linklist L);
int delete_rear(Linklist L);
int delete_pos(Linklist L,int pos);
int insert_pos(Linklist L,int pos,datatype e);
datatype search_pos(Linklist L,int pos);
int search_data(Linklist L,datatype key);

int update_pos(Linklist L,int pos,datatype e);
int update_data(Linklist L,datatype key,datatype e);
int insert_data(Linklist L,datatype key,datatype e);
int delete_data(Linklist L,datatype key);

void rev(Linklist L);  //逆置

#endif

运行结果

ubuntu@ubuntu:day4$ gcc *.c
ubuntu@ubuntu:day4$ ./a.out 
请输入要插入的个数n:5
请输入要插入的值:22
请输入要插入的值:33
请输入要插入的值:55
请输入要插入的值:11
请输入要插入的值:22
22	33	55	11	22	
请输入要查找的元素：22
要查找的元素22的位置是:1
请输入要修改的元素：33
请输入要修改的元素值：99
22	99	55	11	22	
请输入要插入的元素：99
请输入要插入的元素值：88
22	88	99	55	11	22	
请输入要删除的元素：88
22	99	55	11	22	
逆置后:22	11	55	99	22

wangxiasun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构课程设计报告航空客运订票系统.doc
10-20
在这个系统中，核心是构建和管理两种关键的数据结构：航线信息的链表（airline）和客户信息的链表（customer）。 首先，航线信息由结构体`airline`表示，包含了以下字段： 1. `line_num`：航班号，用于唯一标识一个...
数据结构课程实习
08-23
要求：利用单向循环链表存储结构模拟此过程，并从键盘输入人数n 以及m的初值，并输入每个人的密码和姓名，建立单循环链表。 输出形式：正确的输出序列或最后一个赢家。 测试数据：m的初值为12，n=6，6个人的密码依次...
就业班JavaSE-day08每日作业卷1
08-08
链表（Linked List）也是线性数据结构，但它的元素在内存中不是连续存储的，每个元素（节点）包含数据和指向下一个节点的引用。链表的优点在于插入和删除操作通常只需要O(1)的时间，因为只需更改相邻节点的引用即可...
就业班JavaSE-day08每日作业卷答案1
08-08
在第08天的作业中，主要关注了数据结构中的栈、队列以及LinkedList的使用，这些都是编程中非常基础且重要的知识点。 1. 栈（Stack）： 栈是一种后进先出（LIFO, Last In First Out）的数据结构。它的特点是只允许在...
day03_List、Set 每日作业卷1
08-08
4. **队列**：先进先出（FIFO）的数据结构，允许在两端进行插入和删除。 5. **哈希表**：通过哈希函数快速定位元素，插入和查找速度通常很快，但删除操作可能涉及重新哈希。 6. **树**（如二叉树）：支持中等速度的...
插入和选择排序
c23856的博客
07-20 538
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
【数据结构】搜索二叉树
dab112的博客
07-24 638
介绍了二叉搜索树的实现与模拟
数据结构（二叉树-1）
2401_83968713的博客
07-20 1086
树是⼀种⾮线性的数据结构，它是由nn>=0） 个有限结点组成⼀个具有层次关系的集合。把它叫做 树是因为它看起来像⼀棵倒挂的树，也就是说它是根朝上，⽽叶朝下的。有⼀个特殊的结点，称为根结点，根结点没有前驱结点。除根结点外，其余结点被分成M(M>0)个互不相交的集合T1T2……Tm，其中每⼀个集合⼜是⼀棵结构与树类似的⼦树。每棵⼦树的根结点有且只有⼀个前驱，可以有0个或多个后继。因此，树是递归定义的。树形结构中，⼦树之间不能有交集，否则就不是树形结构。
【手撕数据结构】把玩顺序表
apple_61439616的博客
07-19 964
顺序表是⽤⼀段物理地址连续的存储单元依次存储数据元素的线性结构，⼀般情况下采⽤数组线性结构又是什么意思，这就不得不提到线性表了线性表（linear list）是n个具有相同特性的数据元素的有限序列线性表是⼀种在实际中⼴泛使 ⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串注意的是，他在逻辑结构上一定是连续的，但在物理结构上不一定是连续的.线性表在物理上存储时，通常以数组和链式结构的形式存储那么我们知道，数组在内存中存储也是连续的，并且也是类型一致，那么他与顺序表的区别是什么呢.
《数据结构：栈和队列》
2401_83305953的博客
07-19 679
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行插入和删除操作的一端称为栈顶，另一端称为栈底。概念：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)队列也可以由数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。：栈的插入操作叫做进栈/压栈/入栈/，入数据在栈顶。
数据结构——二叉树定义
鲸落博客
07-23 379
二叉树是一种树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。每个子节点本身又可以是一个二叉树。二叉树在计算机科学中有着广泛的应用，例如在搜索算法、排序算法等领域二叉树(Binary Tree)是n(n≥0)个结点的有限集合，该集合 或者为空集(称为空二叉树),或者由一个根结点和两棵互不相交 的、分别称为根结点的左子树和右子树的二叉树组成。
数据结构：栈
sparrowfart的博客
07-19 1182
满足栈的特性，只有先进后出的特性，不能遍历，也就不能遍历打印，也不能随机访问。
2024.7.24 作业
qq_64434282的博客
07-24 456
【代码】2024.7.24 作业。
数据结构的概念和术语
最新发布
2303_78660417的博客
07-24 396
数据结构是一门研究非数值计算的程序设计中计算机的操作对象以及它们之间的关系和操作的学科。数据结构的基本数据结构包括两部分，线性结构跟非线性结构。
数据结构：二叉搜索树（简单C++代码实现）
2301_79171011的博客
07-22 833
本文将深入探讨二叉搜索树这一重要的数据结构。二叉搜索树不仅是一个功能强大的数据结构，而且在实际应用中展现出了极高的实用性。它以其独特的组织方式，使得查找、插入和删除操作都能在平均对数到线性时间内完成，从而大大提高了数据处理的效率。为了更好地理解二叉搜索树的工作原理，我们使用C++语言实现了一个简单的二叉搜索树。通过本文的阐述，相信你应该对二叉搜索树的基本概念、特性以及操作方法已经有了一定的了解。不过想要掌握这个数据结构，还需要亲自上手编写一个二叉搜索树的代码。通过编码实践，才能更深刻体会到内部的工作机制。
数据结构（1）
m0_63067779的博客
07-22 258
集合举例：候车室线性举例：排队问题，随着时间推移，后面不断地有人来，我慢慢往前挪树：图：网络节点，地图路线顺序存储：数组存链式：malloc申请空间，用链表存左边最好，右边最差。
初识数据结构中的“栈”
D1557329860的博客
07-21 233
除了入栈和出栈操作外，还可以对栈进行其他操作，如查看栈顶元素（peek）和判断栈是否为空等。此外，由于栈的后进先出特性，它也常被用于实现一些需要这种特性的算法，如深度优先搜索等。此外，在算法设计中，栈也常被用于实现一些复杂的逻辑，如表达式求值、括号匹配等。在栈中，数据的添加和移除都仅在栈顶进行，这种操作方式使得栈具有一种“后进先出”的特性。也就是说，最后一个被放入栈中的元素将会是第一个被取出的元素。总的来说，栈是一种非常有用的数据结构，它的后进先出特性和基本操作方式使得它在处理特定问题时具有独特的优势。
【手撕数据结构】把玩栈
apple_61439616的博客
07-21 200
栈(stack)，栈遵守先进后出的原则，即先入栈的数据后出栈，插入数据是在栈顶插入，被称为压栈。出栈也是与顺序表的尾删一样的，这里直接将top减减，不影响后面再次在那个位置插入数据，会直接覆盖.但需检测栈是否为空，若为空，则不能进行出栈操作。进行入栈操作前，我们需要检测栈的当前状态，若已满，则需要先对其进行增容，然后才能进行入栈操作。栈的内存空间是动态开辟出来的，当我们使用完后必须释放其内存空间，避免内存泄漏。因为栈也是一种线性表，并且在物理结构上也是连续的，所以我们底层采用数组(顺序表)实现。
（10）深入理解pandas的核心数据结构：DataFrame高效数据清洗技巧
架构筑梦的Cherry Yang的博客
07-20 1116
# 1. DataFrame数据清洗 在Python中，使用pandas库处理DataFrame时，高效的数据清洗是数据预处理的关键步骤之一。以下是一些高效的数据清洗技巧： ## 1.1 处理缺失值（NaNs） 在现实世界中，数据大多是杂乱无章的;它有多种形式和形状，并且有许多缺失值。有趣的是，根据 IBM Data Analytics 的数据，数据科学家花费高达 80% 的时间来查找、清理和组织数据。幸运的是，pandas 提供了许多强大、快速和高效的方法来检测、删除和替换 pandas DataFra
数据结构解析：线索链表遍历算法
"线索链表的遍历算法是数据结构中的一个重要概念，特别是在二叉树的遍历中。本资源是南京理工考研数据结构课件的一部分，讲解了如何使用线索链表实现中序遍历。给出的代码展示了具体的遍历过程，通过标志位ltag和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值