归并和sort排序简单运用

最新推荐文章于 2022-10-25 15:15:22 发布
最新推荐文章于 2022-10-25 15:15:22 发布
阅读量272 收藏
点赞数 2
分类专栏： ACM培训
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44766557/article/details/96175243
版权

Day03 排序

今天学习了归并排序和sort函数的简单运用，感觉sort函数真的是无比的神奇，能加各种神奇的东西，然后进行一些排序练习

归并排序基本代码

#include<iostream>
using namespace std;
void merge(int *data, int start, int end, int *result)
{
	if (start < end)//(end-start)>1
	{
		int mid = (end + start) / 2;
		merge(data, start, mid, result);
		merge(data, mid + 1, end, result);
		int i = start, j = mid + 1, k = 0;
		while (i <= mid && j <= end)
		{
			if (data[i] <= data[j])
				result[k++] = data[i++];
			else
				result[k++] = data[j++];
		}
		while (i <= mid)
		{
			result[k++] = data[i++];
		}
		while (j <= end)
		{
			result[k++] = data[j++];
		}
		for (int i = 0; i < k; i++)
			data[start + i] = result[i];
	}
}
int main()
{
	int data[] = { 3,6,5,8,1 };
	int result[10];
	merge(data, 0, 4, result);
	for (int i = 0; i < 5; i++)
		cout << result[i] << " ";
	system("pause");
	return 0;
}

A-Teams Forming

这道题用了sort函数和归并两种方法，归并函数比较难理解，写下代码，以后忘了方便找。归并重要还是要理解递归的调用。
代码如下：

#include<iostream>
#include<algorithm>
using namespace std;
/*void merge(int *data, int start, int end, int *result)//归并
{
	if (start < end)//(end-start)>1
	{
		int mid = (end + start) / 2;
		merge(data, start, mid, result);
		merge(data, mid + 1, end, result);
		int i = start, j = mid + 1, k = 0;
		while (i <= mid && j <= end)
		{
			if (data[i] <= data[j])
				result[k++] = data[i++];
			else
				result[k++] = data[j++];
		}
		while (i <= mid)
		{
			result[k++] = data[i++];
		}
		while (j <= end)
		{
			result[k++] = data[j++];
		}
		for (int i = 0; i < k; i++)
			data[start + i] = result[i];
	}
}
int result[110];*/
int a[110];
int main()
{
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
		cin >> a[i];
	//merge(a, 0, n - 1, result);
	
	int counts = 0;
	sort(a, a + n);
	for (int i = 0; i < n; i += 2)
	{
		if (a[i] < a[i + 1])
		{
			while (a[i] < a[i + 1])
			{
				a[i]++;
				counts++;
			}
		}
	}
	/*for (int i = 0; i < n; i += 2)//归并
	{
		if (result[i] < result[i + 1])
		{
			while (result[i]<result[i+1])
			{
				result[i]++;
				counts++;
			}
		}
	}*/
	cout << counts;
	system("pause");
	return 0;
}

Where is the Marble？

这道题就是排序和检索
代码如下：

#include<iostream>
#include<algorithm>
using namespace std;
int a[10010];
int main()
{
	int N, Q;
	int x = 1;
	while (cin>>N>>Q&&(N!=0 && Q!=0))
	{
		for (int i = 0; i < N; i++)
			cin >> a[i];
		sort(a, a + N);
		cout << "CASE# " << x << ":" << endl;
		bool find;
		while (Q--)
		{
			int b,index;
			cin >> b;
			find = false;
			for (int j = 0; j < N; j++)
			{
				if (a[j] == b)
				{
					find = true;
					index = j + 1;
					break;
				}
			}
			if (find)
				cout << b << " found at " << index << endl;
			else
				cout << b << " not found" << endl;
		}
		x++;
	}
	system("pause");
	return 0;
}

C-sort

这道题就是sort函数的运用，但是可能会超时，所以运用printf输出，printf比cout速度更快。还有cin的优化 std:ios::sync_with_stdio(false);
加入这行代码速度会和scanf差不多。
代码如下：

#include<iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
int a[1000000];
int main()
{
	int n, m;
	std::ios::sync_with_stdio(false);
	while (cin>>n>>m)
	{
		for (int i = 0; i < n; i++)
			cin >> a[i];
		sort(a, a + n);
		int count = 0;
		for (int i = n - 1; i >= 0; i--)
		{
			if (count == m||count ==n)
				break;
			printf("%d", a[i]);
			if (count == m - 1)
				printf("\n");
			else
			    printf(" ");
			count++;
		}
	}
	system("pause");
	return 0;
}

D-稳定排序

这道题是判断所给数据的排序是否对，以及是否稳定。所以必须找到一种稳定的排序方式。刚开始想到冒泡排序，但是却会超时。最后用了sort函数的排序sort（s，s+n，cmp）；
代码如下：

#include<iostream>
#include<algorithm>
#include<string>
using namespace std;
struct S
{
	string name;
	int score;
	int k;
}s1[310],s2[310];
int cmp(S a,S b)
{
	if (a.score == b.score)
		return a.k < b.k;
	return a.score > b.score;
}
int main()
{
	int N;
	while (cin>>N)
	{
		for (int i = 0; i < N; i++)
		{
			cin >> s1[i].name >> s1[i].score;
			s1[i].k = i;
		}
		for (int i = 0; i < N; i++)
		{
			cin >> s2[i].name >> s2[i].score;
			s2[i].k = i;
		}
		sort(s1, s1 + N, cmp);
		bool stable = false , answer = false;
		for (int i = 0; i < N; i++)
		{
			if (s1[i].score != s2[i].score)
			{
				answer = true;
				break;
			}
		}
		if (!answer)
		{
			for (int i = 0; i < N; i++)
			{
				if (s1[i].name != s2[i].name)
				{
					stable = true;
					break;
				}
			}
		}
		if (answer)
		{
			cout << "Error" << endl;
			for (int i = 0; i < N; i++)
				cout << s1[i].name << " " << s1[i].score << endl;
		}
		else
		{
			if (stable)
			{
				cout << "Not Stable" << endl;
				for (int i = 0; i < N; i++)
					cout << s1[i].name << " " << s1[i].score << endl;

			}
			else
				cout << "Right" << endl;
		}
	}
	system("pause");
	return 0;
}

F-EXCEL排序

这道题分为几种方式的排序，实际就是sort函数排序的运用。
代码如下：中间还有冒泡排序的写法

#include<string>
#include<iostream>
#include<algorithm>
using namespace std;
struct S
{
	string s1;
	string s2;
	int a;
}s[100000];
bool cmp1(S x, S y)
{
	return x.s1 < y.s1;
}
bool cmp2(S x, S y)
{
	if (x.s2 == y.s2)
		return x.s1 < y.s1;
	return x.s2 < y.s2;
}
bool cmp3(S x, S y)
{
	if (x.a == y.a)
		return x.s1 < y.s1;
	return x.a < y.a;
}
/*void first(S *s,int *a,int N)
{
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < N - 1; j++)
		{
			if (s[j].s1 > s[j + 1].s1)
			{
				string temp1 = s[j].s1;
				s[j].s1 = s[j + 1].s1;
				s[j + 1].s1 = temp1;
				string temp2 = s[j].s2;
				s[j].s2 = s[j + 1].s2;
				s[j + 1].s2 = temp2;
				int temp3 = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp3;
			}
		}
	}
}*/
/*void second(S *s, int *a, int N)
{
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < N - 1; j++)
		{
			if (s[j].s2 > s[j + 1].s2)
			{
				string temp1 = s[j].s1;
				s[j].s1 = s[j + 1].s1;
				s[j + 1].s1 = temp1;
				string temp2 = s[j].s2;
				s[j].s2 = s[j + 1].s2;
				s[j + 1].s2 = temp2;
				int temp3 = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp3;
			}
			if (s[j].s2 == s[j + 1].s2)
			{
				if (s[j].s1 > s[j + 1].s1)
				{
					string temp1 = s[j].s1;
					s[j].s1 = s[j + 1].s1;
					s[j + 1].s1 = temp1;
					string temp2 = s[j].s2;
					s[j].s2 = s[j + 1].s2;
					s[j + 1].s2 = temp2;
					int temp3 = a[j];
					a[j] = a[j + 1];
					a[j + 1] = temp3;
				}
			}
		}
	}
}*/
/*void third(S *s, int *a, int N)
{
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < N - 1; j++)
		{
			if (a[j] > a[j+1])
			{
				string temp1 = s[j].s1;
				s[j].s1 = s[j + 1].s1;
				s[j + 1].s1 = temp1;
				string temp2 = s[j].s2;
				s[j].s2 = s[j + 1].s2;
				s[j + 1].s2 = temp2;
				int temp3 = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp3;
			}
			if (s[j].s2 == s[j + 1].s2)
			{
				if (s[j].s1 > s[j + 1].s1)
				{
					string temp1 = s[j].s1;
					s[j].s1 = s[j + 1].s1;
					s[j + 1].s1 = temp1;
					string temp2 = s[j].s2;
					s[j].s2 = s[j + 1].s2;
					s[j + 1].s2 = temp2;
					int temp3 = a[j];
					a[j] = a[j + 1];
					a[j + 1] = temp3;
				}
			}
		}
	}
}*/
//int a[100000];
int main()
{
	int N, C;
	//S s[10000];
	int x = 1;
	while (cin>>N>>C && (N!=0))
	{
		for (int i = 0; i < N; i++)
			cin >> s[i].s1 >> s[i].s2 >> s[i].a;
		if (C == 1)
			sort(s, s + N, cmp1);
		//first(s,a N);
		else if (C == 2)
			sort(s, s + N, cmp2);
		//second(s, a, N);
		else if (C == 3)
			sort(s, s + N, cmp3);
			//third(s, a, N);
		cout << "Case " << x << ":" << endl;
		for (int i = 0; i < N; i++)
			cout << s[i].s1 << " " << s[i].s2 << " " << s[i].a<<endl;
		x++;
	}
	return 0;
}
今天做了这几道题目感觉学到了不少，了解了递归和sort函数的运用，算是排序勉强入门吧，还需继续努力。排序重要还是要理解原理，还要回灵活运用。
耀光少年
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
排序-归并排序(merge_sort)
u010837491的博客
08-01 141
归并排序的基本思想 将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 归并排序的时间复杂度: nlogn 动图演示 代码演示(C++) 题目描述 给定你一个长度为n的整数数列。 请你使用归并排序对这个数列按照从小到大进行排序。 并将排好序的数列按顺序输出。 输入格式 输入共两行，第一行包含整数 n。 第二行包含 n 个整数（所有整数均在1~109范围内），表示整个数列。 输出格式 输出共一行，包含 n 个整数，表示排好序的数
归并排序及对sort函数与stable_sort函数的分析
wzzzj的博客
02-29 327
归并排序是一种稳定且高效的排序算法，在最好，最坏和平均情况下时间复杂度都是nlogn。该算法采用了分而治之的策略，将整个数组逐渐细分（二分的方法）直到每个小的数组只有一个元素，所以它一定是有序的，然后再逐层合并小数组得到有序的原数组。而每层合并的复杂度为O（n)。 本算法只有在合并时的代码多（也即是本算法的主要内容），但是合并两个有序数组并不难，我们可以再开一个临时的数组来辅助（这里是temp数组...
nyoj 322 sort（树状数组求逆序数）
08-09 617
难度：4 描述 You want to processe a sequence of n distinct integers by swapping two adjacent sequence elements until the sequence is sorted in ascending order. Then how many times it need. For example,
sort,Qsort,归并排序三种排序方法的比较
10-28
三种代码的一种简单比较，可以看出qsort是最快的
归并排序(Merge Sort)
ChineseSoftware的博客
06-17 541
归并排序(Merge Sort)
排序算法-基于Java实现的排序算法之BogoSort实现.zip
最新发布
03-27
在学习排序算法时，除了关注效率高的算法如快速排序、归并排序等，了解这些效率低下的算法也能帮助我们更好地理解和对比各种排序算法的优劣。同时，BogoSort的Java实现也展示了如何在编程中运用随机数生成来实现随机...
java sort排序算法实例完整代码
08-01
- 在算法竞赛和面试中，排序算法是常考的题目，理解并熟练运用各种排序算法有助于提高解题能力。 总结，Java的`sort`排序算法通过高效的TimSort算法实现了稳定且高效的排序，不仅适用于基本类型数组和对象数组，还...
MATLAB二分归并排序算法实验.rar
04-11
在MATLAB环境中实现二分归并排序，可以让我们更好地理解和运用这种算法。以下将详细阐述二分归并排序的工作原理、MATLAB实现过程以及相关知识点。 **二分归并排序原理** 1. **分治策略**：二分归并排序首先将大...
Sort_Template.rar_template sort_排序类Sort_类模板
09-23
在实际编程中，还可以考虑优化冒泡排序，比如引入标志位检查是否已经完成排序，或者使用更高效的排序算法（如快速排序、归并排序等），以提高性能。同时，对于大型数据集，可以考虑使用STL（标准模板库）中的`std::...
C# Sort 按年龄排序
03-15
在C#中，我们可以利用内置的`Array`类的`Sort`方法，但这个方法默认使用的是快速排序，不是归并排序。如果需要使用归并排序，我们需要自定义一个排序函数。以下是一个基本的归并排序实现： ```csharp public static...
排序算法之结合sort进行快速排序和归并排序
墨夜之枫的博客
10-08 191
c++排序算法选择排序冒泡排序快速排序归并排序 选择排序 冒泡排序 快速排序 for (i=1; i<n; i++) { int temp = a[i]; for (j=i-1; j>=0 && temp<a[j]; j--) { a[j+1] = a[j]; } a[j+1] = temp; // 每一趟的结果 for...
归并排序demo，帮助理解
perfect_red的博客
11-22 98
@Test public void sortTest(){ int[] a = {1,8,2,6,5,4}; // 归并排序 sort(a,0,a.length - 1); System.out.println(Arrays.toString(a)); } /** * * 归并排序法，用递归的方式 * * @param a * @param low .
排序——归并排序
winner_20020626的博客
11-15 1033
归并排序（merge sort）的基本思想： 归并排序使用的是分治的思想，分治（devide and conquer），字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。递归的思想在某种程度上来说和分治的思想不谋而合，即函数直接或间接调用自身，把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解。所以说分治
八大排序之归并排序
qq_56299755的博客
10-25 343
java中的Collections.sort()方法使用的是归并排序而不是效率最高的快速排序。原因是因为归并排序相比于快排有一个主要的优点：归并排序是稳定的，也就是说归并排序不会改变相等元素的顺序。归并排序最吸引人的性质是它能够保证将任意长度为N的数组排序所需时间和NlogN成正比;它的主要缺点则是它需要的额外空间和N成正比.归并就是将两个有序数组归并成一个更大的有序数组。
c语言算法的学习（归并排序法，快速排序算法，sort函数）
seekerzhz的博客
01-25 259
归并排序法 参考[博主dreamcatcher-cx的博客](https://www.cnblogs.com/chengxiao/p/6194356.html)
基本排序方式——（五）归并排序
weixin_44324174的博客
02-07 175
1. 图示过程 (1) 归并排序的流程 (2) 合并两个有序数组的流程 2. 动图展示 3. Java代码实现 public static void mergeSort(int[] arr) { sort(arr, 0, arr.length - 1); } public static void sort(int[] arr, int L, int...
高阶函数-sort()与sorted() （三分钟读懂）
LuiChun
10-29 451
sort() 该方法用来对列表中的元素进行排序 sort()方法默认是直接比较列表中的元素的大小 在sort()可以接收一个关键字参数 ， key key需要一个函数作为参数， 当设置了函数作为参数，每次都会以列表中的一个元素作为参数来调用函数，并且使用函数的返回值来比较元素的大小 a = ['b','aa','ccc','dddd','ffff'] a.sort() print(a) # 返回 ['aa', 'b', 'ccc', 'dddd', 'ffff'] b = ['b','aa','ccc',
归并排序和快速排序比较
热门推荐
Jymn_Chen
12-30 3万+
最近在做一个算法实验：归并排序和快速排序的比较。 这两种算法在排序方面是非常非常的通俗的了，权威的文献和网上的相关文章也是一大堆，在这里就简单贴下代码，写下个人从这个实验中学到的东西。 先说说个人对这两个算法的理解： 归并排序，简单来说就是先将数组不断细分成最小的单位，然后每个单位分别排序，排序完毕后合并，重复以上过程最后就可以得到排序结果。 快速排序，简单来说就是先选定一个基准元素，然后
算法之——归并排序和快速排序
IT荻的博客
02-08 4231
归并排序 归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法： 自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）； 自下而上的迭代； 和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的...
java 归并排序_归并排序就这么简单
05-26
归并排序是一种基于分治思想的排序算法，它的基本思路是将待排序的序列分成若干子序列，分别进行排序，最后将子序列合并成一个有序的序列。...虽然它的实现过程比较简单，但是对于初学者来说，还是需要仔细理解和掌握。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值