强化阶段 Day 18 算法笔记 7.3 链表处理

最新推荐文章于 2022-11-21 23:05:37 发布
最新推荐文章于 2022-11-21 23:05:37 发布
阅读量139 收藏
点赞数
文章标签： 链表 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aixiaoxiao13/article/details/122155564
版权

目录

1.链表的定义

2.Sharing

3.Linked List Sorting

4.Pop Sequence

5.Mice and Rice

6.Reversing Linked List

7.Deduplication on a Linked List

1.链表的定义

#include<cstdio>
#include<vector>
#include<cstring>
#include<string>
#include<stack>
#include<set>
#include<map>
#include<ctime>
#include<queue>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

struct node{
	int data;
	node* next;
};

node* create(int array[]){
	node *head,*pre,*p;
	head=new node;
	head->next=NULL;
	pre=head;
	for(int i=0;i<5;i++){
		p=new node;
		p->data=array[i];
		p->next=NULL;
		pre->next=p;
		pre=p;
	}
	return head;
}

int main(){
	
	int array[5]={0,1,2,3,4};
	node *l=create(array);
	l=l->next;
	while(l!=NULL){
		printf("%d",l->data);
		l=l->next;
	}

	return 0;
}
int search(node* head,int x){
	int count=0;
	node* p=head->next;
	while(p!=NULL){
		if(p->data==x) count++;
		p=p->next;
	}
	return count;
}
void insert(node *head,int pos,int x){
	node* p=head;
	for(int i=0;i<pos-1;i++){
		p=p->next;
	}
	node* q=new node;
	q->next=p->next;
	q->data=x;
	p->next=q;
}
void delete(node* head,int x){
	node* p=head->next;
	node* pre=head;
	while(p!=NULL){
		if(p->data==x){
			pre->next=p->next;
			delete(p);
			p=pre.next;
		}else{
			pre=p;
			p=p->next;
		}
	}
}

2.Sharing

#include<cstdio>
#include<vector>
#include<cstring>
#include<string>
#include<stack>
#include<set>
#include<map>
#include<ctime>
#include<queue>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxn=100005;
struct node{
	char letter;
	int next;
	bool flag;
}martix[maxn];

int main(){
	
	int s1,s2,n;
	scanf("%d %d %d",&s1,&s2,&n);
	int a1,a2;
	char l;
	for(int i=0;i<n;i++){
		scanf("%d %c %d",&a1,&l,&a2);
		martix[a1].letter=l;
		martix[a1].next=a2;
	}
	
	for(int i=0;i<maxn;i++){
		martix[i].flag=false;
	}
	
	for(int p=s1;p!=-1;p=martix[p].next){
		martix[p].flag=true;
	}
	
	int q;
	for(q=s2;q!=-1;q=martix[q].next){
		if(martix[q].flag==true) break;
	}
	
	if(q==-1) printf("-1\n");
	else printf("%05d\n",q);

	return 0;
}

3.Linked List Sorting

#include<cstdio>
#include<vector>
#include<cstring>
#include<string>
#include<stack>
#include<set>
#include<map>
#include<ctime>
#include<queue>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxn=100005;
struct node{
	int address;
	int key;
	int next;
	bool flag;
}martix[maxn];

void init(){
	for(int i=0;i<maxn;i++){
		martix[i].flag=false;
	}
}

bool cmp(node a,node b){
	if(a.flag==false||b.flag==false){
		return a.flag>b.flag;
	}else{
		return a.key<b.key;
	}
}

int main(){
	
	init();
	
	int n,head;
	scanf("%d %d",&n,&head);
	int address,key,next;
	for(int i=0;i<n;i++){
		scanf("%d",&address);
		martix[address].address=address;
		scanf("%d %d",&key,&next);
		martix[address].next=next;
		martix[address].key=key;
	}
	
	int p=head,count=0;
	while(p!=-1){
		martix[p].flag=true;
		count++;
		p=martix[p].next;
	}
	
	if(count==0){
		printf("0 -1");
		return 0;
	}
	
	sort(martix,martix+maxn,cmp);
	printf("%d %05d\n",count,martix[0].address);
	for(int i=0;i<count;i++){
		if(i!=count-1) printf("%05d %d %05d\n",martix[i].address,martix[i].key,martix[i+1].address);
		else printf("%05d %d -1\n",martix[i].address,martix[i].key);
		
	}

	return 0;
}

4.Pop Sequence

#include<cstdio>
#include<vector>
#include<cstring>
#include<string>
#include<stack>
#include<set>
#include<map>
#include<ctime>
#include<queue>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxn=1010;
int martix[maxn];
stack<int> s;

int main(){
	
	int m,n,k;
	scanf("%d%d%d",&m,&n,&k);
	while(k--){
		while(!s.empty()) s.pop();
		for(int i=0;i<n;i++){
			scanf("%d",&martix[i]);
		}
		int current=0;
		bool flag=true;
		for(int i=1;i<=n;i++){
			s.push(i);
			if(s.size()>m){
				flag=false;
				break;
			}
			while(!s.empty()&&martix[current]==s.top()){
				current++;
				s.pop();
			}
		}
		if(flag&&s.empty()) printf("YES\n");
		else printf("NO\n");
 	}

	return 0;
}

5.Mice and Rice

#include<cstdio>
#include<vector>
#include<cstring>
#include<string>
#include<stack>
#include<set>
#include<map>
#include<ctime>
#include<queue>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxn=1010;
struct mice{
	int weight;
	int rank;
}martix[maxn];

int main(){
	
	int np,ng;
	scanf("%d %d",&np,&ng);
	for(int i=0;i<np;i++){
		scanf("%d",&martix[i]);
	}
	queue<int> q;
	int order;
	for(int i=0;i<np;i++){
		scanf("%d",&order);
		q.push(order);
	}
	
	int mice_num=np,group;
	while(q.size()!=1){
		if(mice_num%ng==0) group=mice_num/ng;
		else group=mice_num/ng+1;
		
		for(int i=0;i<group;i++){
			int max_=q.front();
			for(int j=0;j<ng;j++){
				if(i*ng+j>=mice_num) break;
				int front=q.front();
				if(martix[front].weight>martix[max_].weight){
					max_=front;
				}
				martix[front].rank=group+1;
				q.pop();
			}
			q.push(max_);
		}
		mice_num=group;
	}
	martix[q.front()].rank=1;
	for(int i=0;i<np;i++){
		printf("%d",martix[i].rank);
		if(i<np-1) printf(" ");
	}

	return 0;
}

6.Reversing Linked List

#include<cstdio>
#include<vector>
#include<cstring>
#include<string>
#include<stack>
#include<set>
#include<map>
#include<ctime>
#include<queue>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxn=100005;
struct node{
	int address,value,next;
	int order;
}martix[maxn];

bool cmp(node a,node b){
	return a.order<b.order;
}

int main(){
	
	for(int i=0;i<maxn;i++){
		martix[i].order=maxn;
	}
	
	int begin,n,step;
	scanf("%d%d%d",&begin,&n,&step);
	int address;
	for(int i=0;i<n;i++){
		scanf("%d",&address);
		scanf("%d %d",&martix[address].value,&martix[address].next);
		martix[address].address=address;
	}
	int p=begin,count=0;
	while(p!=-1){
		martix[p].order=count++;
		p=martix[p].next;
	}
	sort(martix,martix+maxn,cmp);
	n=count;
	for(int i=0;i<n/step;i++){
		for(int j=(i+1)*step-1;j>i*step;j--){
			printf("%05d %d %05d\n",martix[j].address,martix[j].value,martix[j-1].address);
		}
		printf("%05d %d ",martix[i*step].address,martix[i*step].value);
		if(i<n/step-1) printf("%05d\n",martix[(i+2)*step-1].address);
		else{
			if(n%step==0) printf("-1\n");
			else{
				printf("%05d\n",martix[(i+1)*step].address);
				for(int i=n/step*step;i<n;i++){
					printf("%05d %d ",martix[i].address,martix[i].value);
					if(i<n-1) printf("%05d\n",martix[i+1].address);
					else printf("-1\n");
				}
			}
		}
	}
	return 0;
}

7.Deduplication on a Linked List

#include<cstdio>
#include<vector>
#include<cstring>
#include<string>
#include<stack>
#include<set>
#include<map>
#include<ctime>
#include<queue>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;

const int maxn=100005;
struct node{
	int address,value,next;
	int order;
}martix[maxn];

bool cmp(node a,node b){
	return a.order<b.order;
}

bool exist[maxn]={0};

int main(){
	
	for(int i=0;i<maxn;i++) martix[i].order=2*maxn;
	
	int begin,n;
	scanf("%d%d",&begin,&n);
	int address;
	for(int i=0;i<n;i++){
		scanf("%d",&address);
		scanf("%d%d",&martix[address].value,&martix[address].next);
		martix[address].address=address;
	}
	int p=begin,valid=0,unvalid=0;
	while(p!=-1){
		if(!exist[abs(martix[p].value)]){
			martix[p].order=valid++;
			exist[abs(martix[p].value)]=1;
		}else{
			martix[p].order=maxn+unvalid;
			unvalid++;
		}
		p=martix[p].next;
	}
	sort(martix,martix+maxn,cmp);
	for(int i=0;i<valid;i++){
		if(i!=valid-1){
			printf("%05d %d %05d\n",martix[i].address,martix[i].value,martix[i+1].address);
		}else{
			printf("%05d %d -1\n",martix[i].address,martix[i].value);
		}
	}
	for(int i=valid;i<valid+unvalid;i++){
		if(i!=valid+unvalid-1){
			printf("%05d %d %05d\n",martix[i].address,martix[i].value,martix[i+1].address);
		}else{
			printf("%05d %d -1\n",martix[i].address,martix[i].value);
		}
	}

	return 0;
}

是小肖啊！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++ const 总结
qq_33690457的博客
05-09 626
前言 const 的作用很多，而且在被用作 常量指针 和 指针常量 的时候经常容易搞混，今天就来总结一下 所有 const 的用法； 一、const 在普通变量中的应用 1、修饰内置类型 i）左右皆可 const 修饰内置类型时，位置出现在 变量类型 的左边或者右边，其含义一样，代表被修饰的对象是一个常量，生命周期内不能被改变； const int maxn = 1024; int const maxm = 1024; 复制代码 ii）常量的非法修改 直接通过赋值修改常量，编译器会报错；
C++——限定符const
zy2317878的博客
06-12 977
写在前面 这一篇博客总结一下我对于C++中const限定符的理解。由于我学习年限不长，所以不能添加很多自己实际经验的理解，所以这篇博客主要是自己查阅网上的一些资料，对资料进行整合、分类、理解，然后整理的一篇博客。一方面能帮助自己更好的理解这个灵活的限定符，另一方面提供一些自己的简单的理解。还望多多批评指正。 参考文献： C++ 中的 const 详解 《C++ Primer 中文版》 关于...
C语言const的用法
sdjfnhj的博客
11-21 237
在一个盒子里有n个数字，抽数字，抽完记下数字后放回，设定一个数值m，问是抽到的数加起来是否有达到m的可能，如果有，则输出YES，反之NO。比如我们想规定一个变量的最大值或者最小值什么的，就可以用到const来限定这个变量，而且它是在整个代码内都不可改变。我们在初学C语言时，会遇到很多类似的关键字不知道其作用，例如你搜的这个const。
2022 牛客暑假第一场
qq_63623834的博客
07-24 228
2022牛客暑假第一场
C语言关键字const
weixin_48105048的博客
02-27 546
const修饰的数据类型是指常类型，常类型的变量或对象的值是不能被更新的。 目的 编辑 const 推出的初始目的，正是为了取代预编译指令，消除它的缺点，同时继承它的优点。 主要作用 编辑 （1）可以定义const常量，具有不可变性。 　　例如：constintMax=100; Max++会产生错误; 　　（2）便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。 　　例如： void f(const int i) { .........}编译器就会知道i是一个常量...
算法笔记，有序链表转为二叉搜索树
03-19
首先找到中位数，然后以中位数为根节点，递归处理中位数左边的子链表和右边的子链表，重复此过程直至链表为空。 **解题流程**： 1. 初始化两个指针，一个快指针`fast`和一个慢指针`slow`，都指向链表的开始。快指针...
算法笔记1_算法笔记PAT_算法笔记_
10-01
《算法笔记1_算法笔记PAT_算法笔记》是一份针对浙江大学计算机科学与技术学院机试以及PAT（Programming Ability Test）考试的学习参考资料，主要以C/C++编程语言为载体，深入讲解了各种算法的设计与实现。这份笔记...
Java算法练习-链表的分化练习题
10-07
java
Java算法设计-链表的回文结构练习题
10-08
java
Java算法练习-链表指定值清除练习题
10-08
java
【NOIP2013提高组】火柴排队
ETO的博客
09-16 1636
题目背景 NOIP2013 提高组 Day1 试题 题目描述 涵涵有两盒火柴，每盒装有 n 根火柴，每根火柴都有一个高度。现在将每盒中的火柴各自排成一列，同一列火柴的高度互不相同，两列火柴之间的距离定义为： 其中 ai 表示第一列火柴中第 i个火柴的高度，bi 表示第二列火柴中第 i 个火柴的高度。  每列火柴中相邻两根火柴的位置都可以交换，请你通过交换使得两列火柴之间的距离最小。请...
memset的使用
JRcoder
02-02 2443
memset memset是内存初始化函数 最简单的调用是将一个数组清零 const int maxn = 1024; int a[maxn]; memset(a, 0, sizeof(a)); // a[0]=a[1]=a[...]=0; sizeof(a) = maxn * 4 = 4096； 表示的是将数组首地址a开始往后的4096个字节都设置为0。 memset常见误区 memset实现原理是根据字节来设置的 比如对于字节数组char a[100]，将所有字节都设置为5，就可以调用：
c语言中的const的作用及解析
weixin_30410119的博客
03-09 881
有时候我们希望定义这样一种变量，它的值不能被改变，在整个作用域中都保持固定。例如，用一个变量来表示班级的最大人数，或者表示缓冲区的大小。为了满足这一要求，可以使用const关键字对变量加以限定： const int MaxNum = 100; //班级的最大人数 这样 MaxNum 的值就不能被修改了，任何对 MaxNum 赋值的行为都将引发错误： MaxNum = ...
《C/C++ 面试 100 例》（七）const 全网最全总结
热门推荐
英雄哪里出来
10-10 13万+
面试官：const 能够作为静态成员函数的后缀修饰吗？
求逆序对数
菜鸟成长ing
11-03 622
//暴力 #include "stdio.h" const int maxn = 5005; int a[maxn]; int n; int main() { int i,j; while( scanf("%d",&n)!=EOF ) { for( i=0; i<n; i++ ) { scanf("%d",&a[i]); } int ans=0,Min=1<<29;
const int INF=0x3f3f3f3f;——ACM中的无穷大常量
while_black的博客
04-07 4489
0x3f3f3f3f 0x开头的 是十六进制常数， 等于 十进制 1061109567 等于 二进制： 00111111 00111111 00111111 00111111 const int inf=0x3f3f3f3f -- 声明 inf 是 const int型 , const 表示 inf 一旦有了值以后就不允许（通过赋值 来）改变它的值. 在算法竞赛中，我们常常需要用到设置一个...
C - 最大数maxn-巧妙暴力
BePosit的博客
08-29 4388
题意： 往队列尾部不断插入数字。 每次在后面输入新的数之后向前更新维护最大值 因为数组中每一个都是存的到结尾的最大值所以只需相邻比较即可。 注意如果遇到前面大于后面终止即可。 #include&lt;bits/stdc++.h&gt; using namespace std; #define maxn 200005 long long m,d,n,ans,t,f; long lo...
const关键字区别
张之海的博客
03-07 323
1.const修饰参数：表示该方法不会改变参数本身的值。 Bign{   Bign ( const* Bign b){ //不能修改b的值   } } 2.const放在方法头后：在方法内不会修改调用该方法的对象。 Bign {   Bign operator +(const* Bign b ) const { //不能修改this的值 } }
力扣刷题笔记总结记录666
最新发布
01-13
本文档是一份关于力扣...这份笔记是针对LeetCode编程挑战的实用参考资料，适合用于学习链表基础、提升算法能力和准备面试。通过阅读和实践这些内容，可以帮助程序员巩固数据结构知识，提高代码实现和解决问题的能力。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值