数据结构实验4(排序算法的实现及性能分析)

实现了选择排序, 插入排序, 冒泡排序, 快速排序, 改进后的快速排序, 以及两路合并排序.

通过随机函数随机生成100个数, 进行各种排序, 记录排序开始时间以及结束时间, 计算消耗的时间来比较算法的优略.

实现代码:

#include "iostream"
#include "cstdio"
#include "cstring"
#include "algorithm"
#include "queue"
#include "stack"
#include "cmath"
#include "utility"
#include "map"
#include "set"
#include "vector"
#include "list"
#include "string"
#include "cstdlib"
#include "ctime"
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int MAXN = 1005;
template <class T>
void SelectSort(T A[], int n)
{
	int small;
	for(int i = 0 ; i < n; ++i) {
		small = i;
		for(int j = i + 1; j < n; ++j)
			if(A[j] < A[small]) small = j;
		swap(A[i], A[small]);
	}
}
template <class T>
void InsertSort(T A[], int n)
{
	for(int i = 1; i < n; ++i) {
		int j = i;
		T tmp = A[j];
		while(j > 0 && tmp < A[j - 1]) {
			A[j] = A[j - 1];
			j--;
		}
		A[j] = tmp;
	}
}
template <class T>
void BubbleSort(T A[], int n)
{
	int i = n - 1, j, last;
	while(i > 0) {
		last = 0;
		for(int j = 0; j < i; ++j)
			if(A[j + 1] < A[j]) {
				swap(A[j], A[j + 1]);
				last = j;
			}
		i = last;
	}
}
template <class T>
void QSort(T A[], int left, int right)
{
	int i, j;
	if(left < right) {
		i = left, j = right + 1;
		do {
			do i++; while(A[i] < A[left]);
			do j--; while(A[j] > A[left]);
			if(i < j) swap(A[i], A[j]);
		}while(i < j);
		swap(A[left], A[j]);
		QSort(A, left, j - 1);
		QSort(A, j + 1, right);
	}
}
template <class T>
void QuickSort(T A[], int n)
{
	QSort(A, 0, n - 1);
}
template <class T>
void MagicQSort(T A[], int left, int right)
{
	int i, j;
	if(right >= 9) {
		if(left < right) {
			i = left, j = right + 1;
			do {
				do i++; while(A[i] < A[left]);
				do j--; while(A[j] > A[left]);
				if(i < j) swap(A[i], A[j]);
			}while(i < j);
			swap(A[left], A[j]);
			MagicQSort(A, left, j - 1);
			MagicQSort(A, j + 1, right);
		}
	}
	else {
		InsertSort(A, right - left + 1);
		return;
	}
}
template <class T>
void MagicQuickSort(T A[], int n)
{
	MagicQSort(A, 0, n - 1);
}
template <class T>
void Merge(T A[], int i1, int j1, int i2, int j2)
{
	T *tmp = new T[j2 - i1 + 1];
	int i = i1, j = i2, k = 0;
	while(i <= j1 && j <= j2) {
		if(A[i] <= A[j]) tmp[k++] = A[i++];
		else tmp[k++] = A[j++];
	}
	while(i <= j1) tmp[k++] = A[i++];
	while(j <= j2) tmp[k++] = A[j++];
	for(int i = 0; i < k; ++i)
		A[i1++] = tmp[i];
	delete []tmp;
}
template <class T>
void MergeSort(T A[], int n)
{
	int i1, j1, i2, j2, size = 1;
	while(size < 1) {
		i2 = i1 + size;
		j1 = i2 - 1;
		if(i2 + size - 1 > n - 1) j2 = n - 1;
		else j2 = i2 + size - 1;
		Merge(A, i1, j1, i2, j2);
		i1 = j2 + 1;
	}
	size *= 2;
}
int main(int argc, char const *argv[])
{
	clock_t start, finish;
	srand(time(NULL));
	int n = 100, i;
	int *a = new int[n];
	int *b = new int[n];
	int *c = new int[n];
	int *d = new int[n];
	int *e = new int[n];
	int *f = new int[n];
	cout  <<  "待排序序列为:"  <<  endl;
	for(int i = 0; i < n; ++i)
	{
		a[i] = rand()%91;
		cout  <<  a[i]  <<  " ";
		b[i] = a[i];
		c[i] = a[i];
		d[i] = a[i];
		e[i] = a[i];
		f[i] = a[i];
	}
	cout  <<  endl;
	start = clock();
	SelectSort(a, n);
	cout  <<  "经过简单选择排序后的序列为:"  <<  endl;
    for(i = 0; i < n; ++i)
		cout  <<  a[i]  <<  " ";
	cout  <<  endl;
	finish = clock();
	cout  <<  "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start)/ CLOCKS_PER_SEC << endl;
	start = clock();
	InsertSort(b, n);
	cout << "经过直接插入排序后的序列为:" << endl;
	for(i = 0; i < n; ++i)
		cout << b[i] << " ";
	cout << endl;
	finish = clock();
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start)/ CLOCKS_PER_SEC << endl;
	start = clock();
	BubbleSort(c, n);
	cout << "经过冒泡排序后的序列为:" << endl;
	for(i = 0; i < n; ++i)
		cout << c[i] << " ";
	cout << endl;
	finish = clock();
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start)/ CLOCKS_PER_SEC << endl;
	start = clock();
	QuickSort(d, n);
	cout << "经过快速排序后的序列为:" << endl;
	for(i = 0; i < n; i++)
		cout << d[i] << " ";
	cout << endl;
	finish = clock();
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start)/ CLOCKS_PER_SEC << endl;
	start = clock();
	MergeSort(e, n);
	cout << "经过两路合并排序后的序列为:" << endl;
	for(i = 0; i < n; i++)
		cout << e[i] << " ";
	cout << endl;
	finish = clock();
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start)/ CLOCKS_PER_SEC << endl;
	start = clock();
	MagicQuickSort(f, n);
	cout << "经过改进后的快速排序后的序列为:" << endl;
	for(i = 0; i < n; ++i)
		cout << f[i] << " ";
	cout << endl;
	finish = clock();
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start)/ CLOCKS_PER_SEC << endl;
	return 0;
}
时间: 2024-11-05 11:23:10

数据结构实验4(排序算法的实现及性能分析)的相关文章

Python学习(三) 八大排序算法的实现(下)

本文Python实现了插入排序.基数排序.希尔排序.冒泡排序.高速排序.直接选择排序.堆排序.归并排序的后面四种. 上篇:Python学习(三) 八大排序算法的实现(上) 1.高速排序 描写叙述 通过一趟排序将要排序的数据切割成独立的两部分,当中一部分的全部数据都比另外一部分的全部数据都要小,然后再按此方法对这两部分数据分别进行高速排序,整个排序过程能够递归进行,以此达到整个数据变成有序序列. 1.先从数列中取出一个数作为基准数. 2.分区过程,将比这个数大的数全放到它的右边,小于或等于它的数全

七种排序算法的实现和总结

最近把七种排序算法集中在一起写了一遍. 注释里有比较详细的说明. 1 /*排序算法大集合**/ 2 #include <stdio.h> 3 #include <string.h> 4 #include <stdlib.h> 5 6 //------------------快速排序------------------// 7 /* 8 核心: 9 如果你知道多少人该站你前面,多少人站你后面,你一定知道你该站哪个位置. 10 算法: 11 1.选取分界数,参考这个分界数,

探讨排序算法的实现

排序算法是我们工作中使用最普遍的算法,常见的语言库中基本都会有排序算法的实现,比如c标准库的qsort,stl的sort函数等.本文首先介绍直接插入排序,归并排序,堆排序,快速排序和基数排序等比较排序算法,然后介绍计数排序,基数排序等具有线性时间的排序算法.本文主要讨论算法的实现方法,并不会过多介绍基本理论. 评价一个排序算法优劣适用与否,一般需要从三个方面来分析 时间复杂度.用比较操作和移动操作数的最高次项表示,由于在实际应用中最在乎的是运行时间的上限,所以一般取输入最坏情况的下的运行时间作为

SDUT 3404 数据结构实验之排序七:选课名单.!?

数据结构实验之排序七:选课名单 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 随着学校规模的扩大,学生人数急剧增加,选课名单的输出也成为一个繁重的任务,我校目前有在校生3万多名,两千多门课程,请根据给定的学生选课清单输出每门课的选课学生名单. Input 输入第一行给出两个正整数N( N ≤ 35000)和M(M ≤ 2000),其中N是全校学生总数,M是课程总数,随后给出N行,每行包括

Python 排序算法的实现

冒泡排序: 1 def bubble(l): 2 length = len(l) 3 for i in range(length): 4 for j in range(i+1, length): 5 if l[i] > l[j]: 6 l[i], l[j] = l[j], l[i] 7 print l 选择排序: 1 def select(l): 2 length = len(l) 3 for i in range(length): 4 minn = i 5 for j in range(i+1

SDUT 3403 数据结构实验之排序六:希尔排序

数据结构实验之排序六:希尔排序 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 我们已经学习了各种排序方法,知道在不同的情况下要选择不同的排序算法,以期达到最好的排序效率:对于待排序数据来说,若数据基本有序且记录较少时, 直接插入排序的效率是非常好的,希尔排序就是针对一组基本有序的少量数据记录进行排序的高效算法.你的任务是对于给定的数据进行希尔排序,其中增量dk=n/(2^k)(k=1,2

SDUT 3399 数据结构实验之排序二:交换排序

数据结构实验之排序二:交换排序 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 冒泡排序和快速排序都是基于"交换"进行的排序方法,你的任务是对题目给定的N个(长整型范围内的)整数从小到大排序,输出用冒泡和快排对这N个数排序分别需要进行的数据交换次数. Input 连续多组输入数据,每组数据第一行给出正整数N(N ≤ 10^5),随后给出N个整数,数字间以空格分隔. Output

SDUT 3398 数据结构实验之排序一:一趟快排

数据结构实验之排序一:一趟快排 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 给定N个长整型范围内的整数,要求输出以给定数据中第一个数为枢轴进行一趟快速排序之后的结果. Input 连续输入多组数据,每组输入数据第一行给出正整数N(N < = 10^5),随后给出N个长整型范围内的整数,数字间以空格分隔. Output 输出一趟快速排序后的结果,数字间以一个空格间隔,行末不得有多余空格.

数据结构实验之排序八:快速排序

数据结构实验之排序八:快速排序 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 给定N(N≤10^5)个整数,要求用快速排序对数据进行升序排列,注意不得使用STL. Input 连续输入多组数据,每组输入数据第一行给出正整数N(≤10^5),随后给出N个整数,数字间以空格分隔. Output 输出排序后的结果,数字间以一个空格间隔,行末不得有多余空格. Example Input 8 49