day15 单向链表

最新推荐文章于 2024-09-16 19:03:50 发布
最新推荐文章于 2024-09-16 19:03:50 发布
阅读量55 收藏
点赞数
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39692490/article/details/130735966
版权

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;




void menue();//菜单
linklist create();//创建节点
void output(linklist L);//输出
int insert_head(linklist L,datatype e);//头插
int insert_rear(linklist L,datatype e);//尾插
int delete_head(linklist L);//头删
int delete_rear(linklist L);//尾删
int insert_pos(linklist L,int pos,datatype e);//按位插入
int delete_pos(linklist L,int pos);//按位删除
int remake_pos(linklist L,int pos,datatype e);//按位修改
int find_pos(linklist L,int pos);//按位置查询



int find_data(linklist L,datatype key);//按元素查找位置
int insert_data(linklist L,datatype key,datatype e);//按照元素插入值
int delete_data(linklist L,datatype key);//按元素删除
int remake_data(linklist L,datatype key,datatype e);//按元素修改



void linklist_rev(linklist L);//单项列表逆置
linklist free_space(linklist L);//释放空间

#endif

main.c

#include "head.h"
int main(int argc, const char *argv[])
{
	//创建头节点L
	linklist L = create(1);

	menue();
	int number;
	while(1)
	{
		printf("\n请输入您的选择：");
		scanf("%d",&number);
		switch(number)
		{
		case 1:
			{
				int n;
				datatype e;
				printf("请输入元素个数");
				scanf("%d",&n);
				for (int i=0;i<n;i++)
				{
					printf("请输入第%d个插入的元素：",i+1);
					scanf("%d",&e);
					insert_head(L,e);
				}
			}break;
		case 2:
			{
				output(L);
			}break;
		case 3:
			{
				int n;
				datatype e;
				printf("请输入元素个数");
				scanf("%d",&n);
				for (int i=0;i<n;i++)
				{
					printf("请输入第%d个插入的元素：",i+1);
					scanf("%d",&e);
					insert_rear(L,e);
				}
				
			}break;
		case 4:
			{
				delete_head(L);
			}break;
		case 5:
			{
				delete_rear(L);
			}break;
		case 6:
			{
				int pos;
				datatype e;
				printf("请输入插入的位置与值");
				scanf("%d %d",&pos,&e);
				insert_pos(L,pos,e);
			}break;
		case 7:
			{
				int pos;
				printf("请输入要删除元素的位置");
				scanf("%d",&pos);
				delete_pos(L,pos);
			}break;
		case 8:
			{
				int pos;
				datatype e;
				printf("请输入修改的位置与值");
				scanf("%d %d",&pos,&e);
				remake_pos(L,pos,e);
			}break;
		case 9:
			{
				int pos;
				printf("请输入要查找的位置");
				scanf("%d",&pos);
				find_pos(L,pos);
			}break;
		case 10:
			   {
			   	datatype key;
				printf("请输入要查找的元素");
				scanf("%d",&key);
				find_data(L,key);
			   }break;
		case 11:
			   {
			   	datatype key;
				datatype e;
				printf("请输入元素以及插入这个元素的值");
				scanf("%d %d",&key,&e);
				insert_data(L,key,e);
			   }break;
		case 12:
			   {
			   	datatype key;
				printf("请输入要删除的元素：");
				scanf("%d",&key);
				delete_data(L,key);
			   }break;
		case 13:
			   {
			   	datatype key;
				datatype e;
				printf("请输入元素以及修改这个元素的值");
				scanf("%d %d",&key,&e);
				remake_data(L,key,e);
			   }
		case 14://排序
			   {
			   	
			   }break;
		case 15://逆置
			   {
			   	linklist_rev(L);
			   }break;
		case 16://释放
			   {
			   	free_space(L);
			   }

		default:printf("输入错误，请重新输入\n");break;
		case 0:printf("退出程序\n");exit(0);		
		}
	}
	
}

test.c

#include "head.h"

void menue()
{
	
	puts("****************");
	puts("\t1,单项链表头插");
	puts("\t2,单项链表遍历");
	puts("\t3,单项链表尾插");
	puts("\t4,单向链表头删");
	puts("\t5,单向链表尾删");
	puts("\t6,单向链表按下表插入");
	puts("\t7,单向链表按下表删除");
	puts("\t8,单向链表按下表修改");
	puts("\t9,单向链表按下表查找");
	puts("\t10,按照元素查找位置");
	puts("\t11,按照元素插入值");
	puts("\t12,按照元素删除");
	puts("\t13,按照元素修改");
	puts("\t14,单向链表排序");
	puts("\t15,单向链表逆置");
	puts("\t16,单向链表释放空间");
	puts("****************");
}
/*
 * function:    创建节点
 * @param [ in] 头结点1 新节点0
 * @param [out] 
 * @return      
 */
linklist create(int flag)
{
	//创建头节点
	linklist L=(linklist)malloc(sizeof(struct Node));
	if(L==NULL)
	{
		return NULL;
	}
	//成功
	//对头结点L的数据域初始化
	if(flag == 1)
	{
	L->len = 0;
	}
	//创建新节点
	else if(flag == 0)
	{
	L->data = 0;
	}
	//对头结点的指针初始化
	L->next = NULL;
	return L;
}

/*
 * function:    头插
 * @param [ in] 链表  插入的值
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int insert_head(linklist L,datatype e)
{
	//1、判断链表是否创建
	if(L ==NULL)
	{
		puts("头插失败");
		return -1;
	}
	//2、头插
	//创建一个新的节点s
	linklist s = create(0);
	if (s == NULL)
	{
		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.判断链表是否为空
	if(L ==NULL || L->len ==0)
	{
		puts("遍历失败");
	}
	//3.遍历
	//
	linklist p=L;
	while(p->next != NULL)
	{
		p =p->next;
		printf("%d\t",p->data);
	}
	puts("");
}
	
 
/*
 * function:    尾部插入
 * @param [ in] 
 * @param [out] 链表 插入的值
 * 
 * @return      
 */
int insert_rear(linklist L,datatype e)
{
	//判断链表是否创建
	if(L == NULL)
	{
		return -1;
	}
	//尾部插入
	//循环尾部节点
	linklist p = L;
	while(p->next != NULL)
	{
		p = p->next;
	}
	//在最后插入s
	linklist s = create(0);
	if(s == NULL)
	{
		return -1;
	}
	s->data = e;
	p->next = s;
	L->len++;
	return 0;
}

/*
 * function:    头部插入
 * @param [ in] 
 * @param [out] 链表
 * @return      
 */
int delete_head(linklist L)
{
	//判断链表是否创建
	//判断链表是否为空
	if(L == NULL || L->next == NULL)
	{
		puts("删除失败，链表未创建或链表为空");
		return -1;
	}
	linklist q = L->next;
	L->next = q->next;
	free(q);
	q = NULL;
	L->len--;
	puts("头删成功");
	return 0;
}

/*
 * function:    尾部删除
 * @param [ in] 
 * @param [out] 链表
 * @return      
 */
int delete_rear(linklist L)
{
	//判断链表是否创建
	//判断链表是否为空
	if(L == NULL || L->len ==0)
	{
		puts("删除失败，链表未创建或链表为空");
		return -1;
	}
	linklist p = L;
	while(p->next->next != NULL)
	{
		p = p->next;
	}
	free(p->next);
	p->next = NULL;
	L->len--;
	puts("尾删成功");
	return 0;
}

/*
 * function:    按位置插入值
 * @param [ in] 
 * @param [out] 链表 插入的位置 插入的值
 * @return      
 */
int insert_pos(linklist L,int pos,datatype e)
{
	//判断链表是否创建
	//判断位置是否合法
	if(L == NULL || pos<1 || pos>L->len+1)
	{
		printf("插入失败\n");
		return -1;
	}
	//循环到pos-1，起名为p
	linklist p =L;
	for (int i=0;i<pos-1;i++)
	{
		p = p->next;
	}
	linklist s= create(0);
	if (s == NULL)
	{
		return -1;
	}
	s->data =e;
	s->next = p->next;
	p->next =s;
	L->len++;
	printf("插入成功\n");
	return 0;
	
}

/*
 * function:    按位删除
 * @param [ in] 
 * @param [out] 链表 位置pos
 * @return      
 */
int delete_pos(linklist L,int pos)
{
	//判断链表是否创建
	//判断链表是否为空
	//判断位置是否合法
	if(L == NULL || L->next == NULL || pos<1 || pos>L->len)
	{
		puts("删除失败");
		return -1;
	}
	linklist p = L;
	for (int i=0;i<pos-1;i++)
	{
		p = p->next;
	}
	linklist q = p->next;
	p->next = q->next;
	free(q);
	q = NULL;
	L->len--;
}

/*
 * function:    按照位置修改
 * @param [ in] 
 * @param [out] 链表 位置pos 值e
 * @return      
 */
int remake_pos(linklist L,int pos,datatype e)
{
	//判断链表是否创建
	//判断位置是否合法
	if(L == NULL || pos<1 || pos>L->len+1)
	{
		printf("插入失败\n");
		return -1;
	}
	linklist p =L;
	for(int i=0;i<pos;i++)
	{
		p = p->next;
	}
	p->data = e;
	printf("修改成功\n");
	return 0;
}

/*
 * function:    按位置查询
 * @param [ in] 
 * @param [out] 链表 位置pos
 * @return      
 */
int find_pos(linklist L,int pos)
{
	if(L == NULL || pos<1 || pos >L->len)
	{
		printf("查询失败\n");
		return -1;
	}
	linklist p = L;
	for (int i =0;i<pos;i++)
	{
		p=p->next;
	}
	printf("第%d个元素为%d\n",pos,p->data);
	return 0;
}


/*
 * function:    按元素查找
 * @param [ in] 
 * @param [out] 链表 查找的值
 * @return      成功返回位置
 */
int find_data(linklist L,datatype key)
{
	//判断链表是否创建
	//判断链表是否为空
	if(L ==NULL || L->len == 0)
	{
		printf("查找失败\n");
		return -1;
	}
	linklist p=L;
	int count = 0;
	while(p->next != NULL)
	{
		p = p->next;
		count++;
		if(p->data == key)
		{
			return count;
		}
	}
	return 0;
}

/*
 * function:    按元素插入
 * @param [ in] 链表 已有元素key 插入元素e 
 * @param [out] 
 * @return      
 */
int insert_data(linklist L,datatype key,datatype e)
{
	int pos = find_data(L,key);
	if(pos == -1)
	{
		puts("按元素插入失败");
		return -1;
	}
	insert_pos(L,pos,e);
	printf("按元素插入成功\n");
	return 0;
}

/*
 * function:    按元素删除
 * @param [ in] 
 * @param [out] 链表 要删除的元素key
 * @return      
 */
int delete_data(linklist L,datatype key)
{
	int pos = find_pos(L,key);
	if (pos = -1)
	{
		puts("删除失败");
		return -1;
	}
	delete_pos(L,pos);
	puts("删除成功");
	return 0;
}

/*
 * function:    按元素修改
 * @param [ in] 
 * @param [out] 链表 原元素 修改元素
 * @return      
 */
int remake_data(linklist L,datatype key,datatype e)
{
	int pos = find_pos(L,key);
	if(pos = -1)
	{
		puts("修改失败");
		return -1;
	}
	remake_pos(L,pos,e);
	puts("修改成功");
}

/*
 * function:    逆置
 * @param [ in] 链表
 * @param [out]
 * @return      无
 */
void linklist_rev(linklist L)
{
    //1,判断链表是否创建
    //2，判断链表是否为空
    if(L==NULL || L->next==NULL)
    {
        return ;
    }
    //3逆置
    linklist p=L->next;
    L->next=NULL;
    while(p!=NULL)
    {
        linklist t=p;
        p=p->next;
        //把t节点头插到L节点的后面
        t->next=L->next;
        L->next=t;
    }
}

/*
 * function:    释放空间
 * @param [ in] 
 * @param [out] 链表
 * @return      
 */
linklist free_space(linklist L)
{
    if(L==NULL)
    {
        return NULL;
    }
    //释放
    int n=L->len;
    for(int i=0;i<n;i++)
    {
        delete_head(L);
    }
    free(L);
    L=NULL;
    return L;
}
ubun

 

野猪骑士丶
关注
day4单向链表
picians的博客
07-08 810
printf("########################按值查找返回地址\n");printf("表中%d修改后的值为：%d\n",data,data2);printf("########################链表的头插尾插\n");printf("第%d个的位置的数据为：%d\n",n,find_data(L,n));printf("########################按位置插入\n");printf("%d的地址为%p\n",m,find_link(L,m));
day3 单向链表
qq_41486882的博客
05-08 416
再次看了下链表的教程视频 根据视频内容写了个单向链表的例子和一些常见的 public class singleLinkedListTest { //单链表 public static void main(String[] args) { //创建几个节点 node node1 = new node(1,"剑圣","打野"); node node2 = new node(2,"亚索","中单"); node node3 = n
day5 单向链表+单向循环链表
Koren_fire的博客
07-19 102
day4:单向链表
jackwolfskin2的博客
12-22 403
思维导图按照元素查找按照元素修改按元素删除链表逆置链表倒数查找链表排序。
day5单向链表、单向循环链表、双向链表
weixin_53373681的博客
07-19 87
1.单向链表任意元素插入。2.单向链表任意元素修改。3.单向链表简单排序。
DAY13—单向链表
m0_51275808的博客
12-19 134
文章目录链表单向链表单链表的实现头部添加元素尾部添加元素尾部添加元素指定位置添加元素链表与顺序表的对比 链表 为什么需要链表 顺序表的构建需要预先知道数据大小来申请连续的存储空间，而在进行扩充时又需要进行数据的搬迁，所以使用起来并不是很灵活。 链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是在每一个节点（数据存储单元）里存放下一个节点的位置信息（即地址）。 单向链表 单向链表也叫单链表，是
【简单】反转部分单向链表－Java
了解➔熟悉➔掌握➔精通
01-12 524
package live.every.day.ProgrammingDesign.CodingInterviewGuide.List; /** * 反转部分单向链表 * * 【题目】 * 给定一个单向链表的头节点head，以及两个整数from和to，在单向链表中把第from个节点到第to个节点这一部分进行反转。 * * 【要求】 * １、如果链表长度为N，时间复杂度要求为O(N)，额外空间复杂度要求为O(1)。 * ２、如果不满足1
单向链表队列问题
IT小辉同学
05-01 212
愿我们的付出都值得
数据结构-单向链表
互联网知识分享
04-27 314
一个单链表的节点(Node)分为两个部分，第一个部分(data)保存或者显示关于节点的信息，另一个部分存储下一个节点的地址。4）链表的 Q节点有data和next两部分组成 ，data是节点的自身数据 而next是别的节点地址保存给Q里面，如果要删除Q节点就要把next该成自身地址，即自己指向自己。//判断节点内的数据是不是有包含删除的节点数据，以下进行定位删除节点，如果定位到有删除的节点就继续往下走，如果没有地位到停止程序执行。3）删除一个节点，我们将该节点的上一个节点的next指向该节点的下一个节点。
Day03 链表概念与单向不循环链表的实现
qq_59111928的博客
06-15 781
链式存储，则线性表中每一个数据元素除了存储自身数据之外，还需要额外存储直接后继的地址，所以链表中的每一个数据元素都是由两部分组成：存储自身数据的部分被称为数据域，存储直接后继地址的部分被称为指针域，数据域和指针域组成的数据元素被称为结点（Node）。顺序表的数据在进行增删的时候，需要移动成片的内存，另外，当数据元素的数量较多的时候，需要申请一块较大的连续的内存，同时当数据元素的数量的改变比较剧烈，顺序表不灵活。顺序表和链式表的区别：顺序表使用连续的内存，链式表使用离散的内存空间。
DAY3:链表（一）：链表基础知识+移除链表元素
CFY1226的博客
05-13 2530
/ 单链表的定义 struct ListNode {int val;//节点上储存的元素 ListNode * next;//指向下一个节点的指针 ListNode(int x) : val(x) , next(NULL) {//节点的构造函数 } }//定义指针，指向链表对象（虚拟头节点用法）所以如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！首先，你需要一个指针来找到要删除的节点。这个指针通常是通过遍历链表得到的。
蓝桥杯备赛Day6——链表
weixin_60535956的博客
01-09 569
详解链表
左神算法基础：两个单向链表的第一个交点
TeddyZhang的博客
07-03 491
最近听了左神的算法课，对一些常用数据结构以及算法改进的思路有了更深的理解，特此总结，不定期更新算法题目以及答案总结！笔者使用C++进行算法重现！虽然左神使用的是JAVA，但他自己也说了，算法与语言无关，但C++写出来的复杂度过不了，那么用其他的语言JAVA，Python也一定过不了！所以刷题还是尽量C++吧，算法基本用不了什么库函数，顶多几个数据结构，而C++的STL里面都包含。 单向链表 首先什...
1 【链表】输入一个链表，输出该链表中倒数第k个结点。
JayXu's Blog
05-06 214
Day1. 输入一个链表，输出该链表中倒数第k个结点。 代码 public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } } /** * 先搞一个stack，把所有的listNode都放进去，看看stack的大小的1/2是...
王道408考研数据结构-绪论
最新发布
qq_55882840的博客
09-16 309
1.1 数据结构的基本概念数据结构数据结构是相互之间存在一种或多种特定关系的数据元素的集合。在任何问题中，数据元素都不是孤立存在的，它们之间存在某种关系，这种数据元素相互之间的关系称为结构(Structure)。数据结构包括三方面的内容：逻辑结构、存储结构和数据的运算。数据的逻辑结构和存储结构是密不可分的两个方面，一个算法的设计取决于所选定的逻辑结构，而算法的实现依赖于所采用的存储结构。1.1.2 数据结构三要素1.数据的逻辑结构逻辑结构是指数据元素之间的逻辑关系，即从逻辑关系上描述数据。
【算法】冒泡排序
博客不会写，怎么办？抓紧练习咯！
09-12 399
冒泡排序是一种简单的排序算法，基本思想是通过重复遍历待排序的数列，比较相邻元素并交换它们的位置，以将较大（较小）的元素 “冒泡” 到数列的末端。最好的情况：O(n) ，此时说明我们的数据已经处于一个有序的状态。1、稳定性：即相等的元素在排序后仍保持原有的顺序性。2、简单：实先简单，易理解，不易使用在大型数据中。最坏和平均的情况：O(n的2次方)四、java代码示例。
数据结构-2.7.单链表的查找与长度计算
ADCvbV的博客
09-13 332
版本二：王道书版本 while循环进行到第5次时p指向NULL，不满足下一次循环条件，跳出while循环，此时返回的p为NULL：代表查找失败最终可知当i值不合法时即i为负数或者i值大于链表长度时最终都返回NULL，因此只需要判断返回结果是否为NULL即可得知是否查找成功。a.计算时间复杂度需要要查找的元素在合法范围内。b.平均时间复杂度是指此次输入的i值它取的合法范围内的任何一个数字的概率都等可能的情况，具体的算法和顺序表的按位查找的分析方法一样。案例二：后插操作的加入右下角的InsertNext
从零开始学数据结构系列之第六章《希尔排序》
铁匠匠匠的博客
09-14 920
​ 希尔排序是对插入排序的优化，基本思路是先选定一个整数作为增量，把待排序文件中的所有数据分组，以每个距离的等差数列为一组，对每一组进行排序，然后将增量缩小，继续分组排序，重复上述动作，直到增量缩小为1时，排序完正好有序。​ 我们发现，当被排序的对象越接近有序时，插入排序的效率越高，那我们是否有办法将数组变成接近有序后再用插入排序，此时希尔大佬就发现了这个排序算法，并命名为希尔排序。逆序有序的数组排序时，时间复杂度为O ( n 2 ) O(n^2)O(n 2)，此时效率最低。如果是最开始的分组方法的话。
C语言实现单向链表的基本操作
"这篇资源是关于单向链表的基础知识，包括如何在C语言中实现单向链表的初始化、创建、销毁等操作。" 在数据结构中，链表是一种非常重要的非线性数据结构。单向链表是其中一种形式，每个节点包含一个数据元素和一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值