链表操作集合 - C语言

最新推荐文章于 2022-04-22 16:25:14 发布
最新推荐文章于 2022-04-22 16:25:14 发布
阅读量741 收藏
点赞数
分类专栏： C语言 文章标签： c语言 链表 单链表 指针 结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Q5578926/article/details/31424483
版权

主要是给自己以后复习知识，还有进行修改优化用的：

欢迎批评，其中链表合并的就地合并我并未掌握，我用了新的头结点以后要补上

首先是头文件定义

#ifndef ANDREW
#define ANDREW

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


#define SIZE 10

struct Lnode;
typedef int Elemtype;
typedef struct Lnode
{
	Elemtype data;
	struct Lnode *next;  //定义一个struct Lnode 类型的指针
}Lnode,*Linklist; //一个普通类型 一个指针类型

void create_and_insert1(Linklist *pList);//不带头的尾插
void create_and_insert2(Linklist *head); //不带头的头插
void create_and_insert_sort();        //不带头的顺序插
void Showlinklist(Lnode *head);     //打印链表
void create_sort_insert(Linklist* pList) ;


void Shownodelinklist(Lnode *head);    //打印带头结点的链表
Linklist Makeempty();  //初始化
Linklist Makelinklistlast(Linklist head,int n); //尾插
Linklist Makelinklistfront(Linklist head,int n);  //头插
Lnode *Islast(Lnode *head);
Lnode *Find(Linklist L,Elemtype key);
Lnode *Delete(Linklist L,Elemtype key);   //删除所有为key的结点
Lnode *Findprevious(Linklist L,Elemtype key);   //找到key结点的前驱



Linklist Elemfour(Linklist head,int k);
Linklist Middlenode(Linklist head);
Linklist Nizhilinklist(Linklist head); //链表逆置  带头结点
Linklist Sortlinklist(Linklist head);     //**************************************
Linklist Deleteallelement(Linklist head);

#endif 

#include "superman.h"
//无头结点尾插
void create_and_insert1(Linklist *pList)
{
	int number;
	Linklist Tail = *pList =(Linklist)calloc(1,sizeof(Lnode)); //第一个结点已经初始化
	int count=0;
	//srand(time(NULL));
	for(;count!=SIZE;count++)
	{
		if(count==0)
		{
			(*pList) -> data =rand()%100;
		}
		else
		{           //动态分配 不会自动释放，
			Linklist pcur=(Linklist)calloc(1,sizeof(Lnode));   //已初始化完成
// 			printf("the %dst number:\n",count);
// 			scanf("%d",&number);
			pcur->data=rand()%100;
			Tail->next=pcur;
			Tail=pcur;
		}
	}
	
}

//无头结点头插
void create_and_insert2(Linklist *head) //我理解head是一个指向结构体的指针
{
	Lnode *Tail=*head=(Lnode*)calloc(1,sizeof(Lnode));
	int count=0;
	//srand(time(NULL));
	for(;count!=SIZE;++count)
	{
		if(count==0)
		{
			(*head) -> data =rand()%100;
		}
		else
		{
			Lnode *p=(Lnode*)calloc(1,sizeof(Lnode));
			p->data=rand()%100;
			p->next= *head;         //head本身是结构体的地址
			*head=p;
		}
		
	}
}

//顺序插入
void create_and_insert_sort(Linklist *head)    //用两个指针  一个标记前驱
{   
	Linklist pre,last;
	int count=0;
	srand(time(NULL));
	*head =(Lnode*)calloc(1,sizeof(Lnode)); 
	for(;count!=SIZE;++count)
	{
		if(count==0)
		{
			(*head)->data =rand()%100;
		}
		else
		{
			
			Lnode *p=(Lnode *)calloc(1,sizeof(Lnode));  //新插入的结点
			p-> data=rand()%100;
			pre=NULL;
			last=*head;
			while(last)  //定位要插入的位置
			{
				if(p->data>=last->data)
				{
					pre=last;
					last=last->next;
					
				}
				else
					break;
			}
			if(pre==NULL)    // 判断是否在首部插入。插入首部之前
			{
				p->next=*head;
				*head=p;
			}
			else
			{
				p->next = pre->next;
				pre->next= p;
			}
		}

	}
}

//打印链表
void Showlinklist(Lnode *head)
{
	Lnode *p=head;
	while(p!=NULL)
	{
		printf("%d ",p->data);
		p=p->next;
		
	}
	printf("\n");
}

//打印带头结点的
void Shownodelinklist(Lnode *head)
{
	Lnode *p=head->next;
	while(p!=NULL)
	{
		printf("%d ",p->data);
		p=p->next;

	}
	printf("\n");
}


Linklist Makeempty()
{
	Lnode *head=(Lnode *)malloc(sizeof(Lnode));
	if(!head)
	{
		printf("Error!\n");
	}
	head->data=SIZE;
	head->next=NULL;
	return head;
}

//带头结点的尾插法 
Linklist Makelinklistlast(Linklist head,int n)   //没有返回值的时候 应该用两个解引用
{
	int i;
	int number;
	Lnode *last=head; //不存储数据的只是指针不用开辟空间，但是存储数据的需要开辟空间。
	for(i=0;i<n;++i)
	{
		Lnode *p=(Lnode *)malloc(sizeof(Lnode));
// 		printf("the %d st number:\n",i+1);
// 		fflush(stdin);
// 		scanf("%d",&number);
		p->data=rand()%100;                     //number;
		last->next=p;
		last=p;
	}
	last->next=NULL;
	return head;
}

//带头结点头插法
Linklist Makelinklistfront(Linklist head,int n)
{
	int i;
	int number;
	Lnode *front=head;
	for(i=0;i<n;++i)
	{
		Lnode *p=(Lnode *)calloc(1,sizeof(Lnode));
// 		printf("the %d st number :\n",i+1);
// 		scanf("%d",&number);
		p->data=rand()%100;                         // number;
		p->next=front->next;
		front->next=p;
	}

	return head;
}

//返回最后一个结点
Lnode *Islast(Lnode *head)
{
	Lnode *p=head;
	while(p->next!=NULL)
	{
		p=p->next;
	}
	return p;
}

//查找某个节点
Lnode *Find(Linklist L,Elemtype key)
{
	Lnode *p=L->next;
	while(p->next!=NULL && p->data !=key)
	{
		p=p->next;
	}
	return p;
}

//删除所有值为KEY的结点
Lnode *Delete(Linklist L,Elemtype key)
{
	Lnode *pre=L;           //循环查找，对头和尾特殊处理
	Lnode *last=pre->next;
	while(last)
	{
		if(last->data==key)
		{
			pre->next=last->next;
			free(last);
			last=pre->next;
		}
		else
		{
			pre=last;
			last=last->next;
		}
	}

	return L;
}

//寻找前驱
Lnode *Findprevious(Linklist L,Elemtype key)
{
	Lnode *p=L;   //从第一个节点开始查找
	while(p->next!=NULL && p->next->data !=key)   //思考是p->next还是判断p!=NULL
	{
		p=p->next;
	}
	return p;
}

//寻找倒数第K个结点 
Linklist Elemfour(Linklist head,int k)
{
	int i;
	Linklist quick,slow;
	quick=slow=head->next;     //判断单链表的长度
	for(i=0;i<k;++i)
	{
		if(quick->next==NULL)
		{
			printf("Error!\n");
			break;
		}
		quick=quick->next;
	}
	while(quick->next!=NULL)
	{
		quick=quick->next;
		slow=slow->next;
	}
	return slow;
}

//找出单链表的中间元素
Linklist Middlenode(Linklist head)
{
	int i=0;
	Linklist quick,slow,longlist;
	longlist=head;
	quick=slow=head->next;
	while(longlist!=NULL)
	{
		longlist=longlist->next;
		i++;
	}
	if(i%2==0)
	{
		while(quick->next->next!=NULL)
		{
			quick=quick->next->next;
			slow=slow->next;
		}
	}
	else
	{
		while(quick->next=NULL)
		{
			quick=quick->next->next;
			slow=slow->next;
		}
	}

//删除无头单链表的一个节点q
Linklist Deletenode(Linklist q)
{
	Elemtype temp;
	Linklist last;
	last=q->next;
	temp=q->data;
	q->data=last->data;
	last->data=temp;
	q->next=q->next->next;
	return q;

}

//单链表逆置
Linklist Nizhilinklist(Linklist head)
{
	Linklist pre,mid,last;
	pre=head->next;

	while(pre->next!=NULL)
	{
		mid=pre->next;
		last=pre->next->next;
		mid->next=head->next;
		head->next=mid;
		pre->next=last;
	}
	return head;
}


//链表合并（新建一个头结点）
Linklist Mergelinklist(Linklist head1,Linklist head2)
{
	Linklist pre1,pre2,tail;
	Lnode *head;
	tail=(Lnode *)calloc(1,sizeof(Lnode));
	head=tail;

	pre2=head2;
	pre1=head1;
	while(pre1  &&  pre2)
	{
		if(pre1->data<pre2->data)
		{
			tail->next=pre1;
			tail=pre1;
			pre1=pre1->next;
		}
		else
		{
			tail->next=pre2;
			tail=pre2;
			pre2=pre2->next;
		} 
	}
	if(pre1)
	{
		tail->next=pre1;
	}
	else if(pre2)
	{
		tail->next=pre2;
	}
	return head;
}

//判断单链表是否有环？
 void Circlelinklist(Linklist head)
 {
	 Linklist quick,slow;
	 slow=quick=head->next;
	 while(quick && quick->next!=NULL)   //可以quick走到链表的终点
	 {
		 quick=quick->next->next;
		 slow=slow->next;
		 if(quick==slow)
		 {
			 printf("it has circle ! \n");
			 break;
		 }
			 
	 }
	 
 }

//判断两个单链表是否相交
 void Intersectlinklist(Linklist head1,Linklist head2)
 {
	 int i,j;
	 Linklist first,second;
	 int dis;
	 i=j=0;
	 first=head1->next;
	 second=head2->next;
	 while(first)
	 {
		 first=first->next;
		 ++i;
	 }
	 first=head1;
	 while(second)
	 {
		 second=second->next;
		 ++j;
	 }
	 second=head2;
	 if(i>j)
	 {
		 dis=i-j;
		while(dis)
		{
			first=first->next;
			dis--;
		}
		while(first&&first->next!=NULL)
		{
			first=first->next;
			second=second->next;
			if(first==second)
			{
				printf("Intersect!!\n");
				break;
			}
		}
	 }
	 else if(i==j)
	 {
		 while(first&&first->next!=NULL)
		 {
			 first=first->next;
			 second=second->next;
			 if(first==second)
			 {
				 printf("Intersect!!\n");
				 break;
			 }
		 }
	 }
	 else
	 {
		 dis=j-i;
		 while(dis)
		 {
			 second=second->next;
			 dis--;
		 }
		 while(first&&first->next!=NULL)
		 {
			 first=first->next;
			 second=second->next;
			 if(first==second)
			 {
				 printf("Intersect!!\n");
				 break;
			 }
		 }
	 }
 }

//单链表排序  插入排序
 Linklist Sortlinklist(Linklist head)
 {
	 //无头指针的排序
	 Linklist pre,pnext,mark,markbehind;
	 mark=head->next;
	 head->next=NULL;  //头部断开作为有序链
	 while(mark)
	 {
		 markbehind=mark->next;//标记操作结点的下一个位置
		 if(mark->data<=head->data)  //比头结点还小 插入头结点前面
		 {
			 mark->next=head;
			 head=mark;
		 }
		 else
		 {
			 pre=head;      //用于记录比较结点和结点的前驱
			 pnext=head->next;
			 while(pnext&&pnext->data<mark->data)  //在有序链中找到合适的位置
			 {
				 pre=pnext;
				 pnext=pnext->next;
			 }
			 mark->next=pre->next;
			 pre->next=mark;

		 }
		 mark=markbehind;

	 }
	 return head;//返回新的头结点
	 
 }


自信的恐龙哥拼搏在路上-刘斌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表操作算法集合（18种）
04-10
/* 1.初始化线性表，即置单链表的表头指针为空 *//* 2.清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为一个空表 *//* 3.返回单链表的长度 *//* 4.检查单链表是否为空，若为空则返回１，否则返回０ *//* 5.返回单链表中第pos个结点中的元素，若pos超出范围，则停止程序运行 *//* 6.遍历一个单链表 *//* 7.从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL *//* 8.把单链表中第pos个结点的值修改为x的值，若修改成功返回１，否则返回０ *//* 9.向单链表的表头插入一个元素 *//* 10.向单链表的末尾添加一个元素 *//* 11.向单链表中第pos个结点位置插入元素为x的结点，若插入成功返回１，否则返回０ *//* 12.向有序单链表中插入元素x结点，使得插入后仍然有序 *//* 13.从单链表中删除表头结点，并把该结点的值返回，若删除失败则停止程序运行 *//* 14.从单链表中删除表尾结点并返回它的值，若删除失败则停止程序运行 *//* 15.从单链表中删除第pos个结点并返回它的值，若删除失败则停止程序运行 *//* 16.从单链表中删除值为x的第一个结点，若删除成功则返回1,否则返回0 *//* 17.交换2个元素的位置 *//* 18.将线性表进行快速排序 */
链表操作集合
Sunburst的专栏
04-15 776
#include<stdio.h> #include<stdlib.h> typedef int ElemType; typedef struct Node { ElemType data; struct Node *next; }Node,LinkList; void Insert(LinkList *L,LinkList *p); void Build(LinkList *L){//建立一个空
（C语言）链表的实现集合的相关操作
kobe_jr的博客
06-01 2331
集合的特征：确定性/ 互异性/ 无序性。常见的操作：1、查找集合中是否包含这个数据元素：Contains();2、添加一个新成员数据，集合中不能存在这个元素。AddMember();3、删除指定元素， 找到这个元素， 删除；如果没找到，则提示没找到，返回0（表示false）。Delete();4、合并两个集合，不能有相同的元素。5、求交集，找相同的元素。6、求差集，例如：A{1, 2, 3}。B{...
链表基本操作集合
肥仔的博客
03-18 267
文章目录概述一、按字典序插入二、按关键字删除节点三、按关键字查找节点四、总结 概述 代码的背景是这样的，一个链表，里面存着图书的信息，图书的信息有书名，作者姓名，出版社，年份，按字典序升序排列，按书名的关键字删除和查找书本信息。 typedef struct info{ char book_name[maxbookname]; char writer[max_writer_name...
链表的操作集合
邱鑫不甜的博客
02-14 149
话不多说直接上代码！！！ #include<stdio.h> #include<malloc.h> #include<stdlib.h> typedef struct Node{ int data; //数据域 struct Node *pNext; //指针域(指向跟本身数据类型一样的节点) }NODE,*PNODE; ...
链表---链表大集合
07-27
包含各种类型的链表，例如简单链表、带头结点的链表、双向链表、合并链表、递归链表等。
链表实现集合运算 链表实现集合交并差运算
12-27
链表实现集合运算 链表实现集合交并差运算
c语言链表集合
06-04
C语言 开发集合链表
用C语言实现单链表的各种操作(二)
01-20
用C语言实现单链表的各种操作(一)>主要是单链表的一些最基本的操作，下面，主要是一些其他的典型的算法和测试程序。 代码如下:/* 对单链表进行排序处理*/struct LNode *sort(struct LNode *head){ LinkList *p; ...
C语言工程实践I (数组与链表的集合合并、有序表合并)
01-09
C语言程序设计课程的第一次工程实践，文件中各个函数严格按照老师所给函数...文件中有四份代码，分别是集合合并（数组、链表），有序表合并（数组、链表）。集合合并中会自动将重复元素删除，有序表合并后仍是有序表。
用链表对集合进行操作
10-19
用链表对集合进行操作，包括求两的集合的交、差、并，以及求集合的补，判断某个元素是否在集合中等
链表常用操作大集合
onlymayao的博客
05-17 218
前言 主要是做一个汇总，方便自己和有需要的人查看。一个一个搜比较费劲。 目录 如何实现链表 如何知道链表是否有环 链表如何反转 判断两个链表是否相交并找出相交点 如何从尾部打印链表 持续更新！！！ ...
链表常用操作汇总
qq_44271654的博客
04-22 575
链表是比较常用的数据结构 以下是链表常用操作的7种，注释中介绍了不同操作的时间复杂度，记住这些常用操作，写代码时将会更加顺手。 # 作者：zff # 日期：2022/4/22 # 目的：链表常用操作 from collections import deque print('--------1、创建链表---------') linkedlist=deque() print('--------2、添加元素---------') #Time Complexity:O(1) linkedlist.append
[C/C++标准库]_[初级]_[集合操作]
Tobey(我是机器人)
02-07 1616
场景: 1.需要合并集合或过滤出不同集合里的元素便于操作.如一个集合里有索引值1,2.总集合里有1,2,3,4,5.需要找出3,4,5时,就需要set_symmetric_difference #include #include #include #include #include #include using namespace std; //1.可重复值 //2.集
【C语言】 数组操作集合
python_LC_nohtyp的博客
04-12 1021
【C语言】 数组操作集合 创建数组 根据数组的类型我们可以把数组大致的分为数值型数组和字符串数组（我自己分的），当然还有指针数组在这次的总结里不多做数目。创建方式大致就是 变量名 + 大小 int array[10]; char array[10]; 在创建数组的时候你可以选择对数据进行初始化，比如 int a[10] = {0} 数组的内存 数组在内存中是顺序存储的，即内存地址是连在一块的...
集合之链表
Madridcrls7的博客
05-19 692
数组和数组列表都有一个很大的缺陷---从数组的中间位置删除一个元素要很大的代价：数组中处于被删除元素之后的所有元素都要向数组的前端移动，在数组中插入一个元素也是如此。链表可以完美解决这个问题。数组在连续的存储位置上存放对象引用，但链表将每个对象存放在独立的结点中，每个结点还存放着序列中下个结点的引用，Java中所有链表都是双向连接-即每个结点还存放着指向前驱结点的引用。链表是一个有序集合，每个对象...
剖析链表，链表常用操作集合
pivilion的博客
05-08 195
在读SICP的时候，我就接触了里面的基本数据结构序对(Pairs)，那时还没有学习数据结构，没想到就是链表。链表是一种递归的数据结构，Scheme是一种函数式编程语言，Scheme程序随处可见递归，用它来做基本的数据结构再合适不过了。本文介绍的链表操作多数来源于LeetCode上链表专题上的算法题。
集合的定义与并查操作(C语言)
m0_51955470的博客
11-16 655
#define MAXN 1000 /* 集合最大元素个数 */ typedef int ElementType; /* 默认元素可以用非负整数表示 */ typedef int SetName; /* 默认用根结点的下标作为集合名称 */ typedef ElementType SetType[MAXN]; /* 假设集合元素下标从0开始 */ void Union( SetType S, SetName Root1, S
管道-pipe函数-fdopen函数-popen函数详解-C语言
Q5578926的专栏
06-26 3291
管道和有名管道是最早的进程间通信机制之一，管道可用于具有亲缘关系进程间的通信，有名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。  管道是Linux支持的最初Unix IPC形式之一，具有以下特点： 管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道；只能用于父子进程或者兄弟进程之间（具有亲缘关系的进程）；单独
c语言实现集合交并差链表
最新发布
05-12
在C语言中，可以使用链表来实现这些集合操作。 链表是一种数据结构，由若干个节点组成，每个节点都包括一个数据元素和指向下一个节点的指针。在C语言中，可以使用结构体来定义一个节点，如下所示： ``` struct ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值