跨平台C++毫秒计时——以Quick Sort算法为例子

#include <iostream>
#include <stdlib.h>

using namespace std;

void Qsort(int a[],int low,int high)
{
	if(low >= high) return;
	int first = low;
	int last = high;
	int key = a[first];
	while(first < last)
	{
		while(first < last && a[last] >= key) --last;
		a[first] = a[last];
		while(first < last && a[first] <= key) ++first;
		a[last] = a[first];
	}
	a[first] = key;
	Qsort(a, low, first - 1);
	Qsort(a, first + 1, high);
}

int main(int argc, char **argv)
{
	//命令行参数数量判断
	if (argc == 0) {
		cout << "Usage: quicksort N\n";
		return 0;
	}
	//命令行第2个参数转换为长整数
	long N = atoi(argv[1]);

	//随机化数
	srand( time(0) );

	//动态分配内存
	int *a;
	a = new int[N];    //C++
	for(long i = 0; i < N; i++)
		a[i] = rand();

	//计时
	clock_t t1 = clock();
	Qsort(a, 0, N-1);/*这里原文第三个参数要减1否则内存泄露*/
	clock_t t2 = clock();
	cout << (double)(t2 - t1) / CLOCKS_PER_SEC << "毫秒" << endl;
	/*//输出
	for(int i=0;i<sizeof(a)/sizeof(a[0]);i++)
	{
		cout<<a[i]<<"";
	}
	*/
	//释放申请的内存
	delete []a;  //C++
	return 0;
}

时间: 2024-09-30 00:48:26

跨平台C++毫秒计时——以Quick Sort算法为例子的相关文章

笔试算法题(54):快速排序实现之单向扫描、双向扫描(single-direction scanning, bidirectional scanning of Quick Sort)

议题:快速排序实现之一(单向遍历) 分析: 算法原理:主要由两部分组成,一部分是递归部分QuickSort,它将调用partition进行划分,并取得划分元素P,然后分别对P之前的部分和P 之后的部分递归调用QuickSort:另一部分是partition,选取划分元素P(随机选取数组中的一个元素,交换到数组末尾位置),定义两个标记 值left和right,随着划分的进行,这两个标记值将数组分成三部分,left之左的部分是小于划分元素P的值,left和right之间的部分是大 于等于划分元素P的

笔试算法题(55):快速排序实现之非递归实现,最小k值选择(non-recursive version, Minimal Kth Selection of Quick Sort)

议题:快速排序实现之五(非递归实现,短序列优先处理,减少递归栈大小) 分析: 算法原理:此算法实现适用于系统栈空间不足够快速排序递归调用的需求,从而使用非递归实现快速排序算法:使用显示下推栈存储快速排序中的每一次划分结果 (将left和right都压入堆栈),并且首先处理划分序列较短的子序列(也就是在得到一次划分的左右部分时,首先将长序列入栈,然后让段序列入栈), 这样可以保证当快速排序退化的线性效率的时候,栈大小仍旧在㏒N范围内.算法策略类似于最小子树优先遍历规则: 弱势:当序列已经就绪,每次

Collection of algorithm for sorting. 常见排序算法集(三) —— Quick Sort

Quick Sort 快排,一个排序方法能直接享受这样的名称殊荣,呵呵,可见其威力与重要性. 其中最重要的思想就是 "分治"-- divide and conquer ! 这里排序用到的思想极其简单,却是很实用的!小孩子都会的简单想法. 先把所有数据分成三个部分. 在所有数据中选取某一元素X,比X小的放左边,比X大的放右边. 接着把这一思想同样分别施加在X元素的左边和右边部分,同样继续划分,选出一个元素X' 比X'小的放左边比X'大的放右边. 继续施加这种划分策略,直到划分的元素很少(

算法 quick sort

// -------------------------------------------------------------------------------------------------------------------- // // // Respect the work. // // </copyright> // <summary> // // The quick sort. // // 高速排序(QuickSort)是对冒泡排序的一种改进.它的基本思想是:通

经典排序算法 - 快速排序Quick sort

经典排序算法 - 快速排序Quick sort 原理,通过一趟扫描将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列 举个例子 如无序数组[6 2 4 1 5 9] a),先把第一项[6]取出来, 用[6]依次与其余项进行比较, 如果比[6]小就放[6]前边,2 4 1 5都比[6]小,所以全部放到[6]前边 如果比[6]大就放[6]后边,9比[6]大,放到[6

排序算法之快速排序(Quick Sort) -- 适用于Leetcode 75 Sort Colors

Quick Sort使用了Divide and Concur的思想: 找一个基准数, 把小于基准数的数都放到基准数之前, 把大于基准数的数都放到基准数之后 Worst case: O(n^2) Average case: O(nlogN) 步骤: 初始的数组 Array a[]: 0 1 2 3 4 5 6 7 8 9 51 73 52 18 91 7 87 73 48 3 基准数: X = a[0] = 51 i 的值: i = 0 j 的值: j = 9 (a.length) Step 1:

C++: quick sort(快排序)

到目前为止, 我们已经学习到了插入排序, 冒泡排序, 选择排序(selection). 这些排序算法都是comparision based sorting algorithms(即涉及到元素大小的比较来决定元素的先后顺序). 而且算法的时间复杂度上均为O(n^2).但是comparision based 的排序算法远非这几个算法. 而且可以通过利用其它的一些手段(例如divide and conquer technique, 分治法)实现对基于比较的排序算法的时间复杂度降低到O(nlogn).

Java Sort算法

//插入排序: package org.rut.util.algorithm.support; import org.rut.util.algorithm.SortUtil; /** * @author treeroot * @since 2006-2-2 * @version 1.0 */ public class InsertSort implements SortUtil.Sort{ /** (non-Javadoc) * @see org.rut.util.algorithm.SortU

快速排序(Quick Sort)

快速排序是初学者比较难理解的几个算法之一,这里尽可简单化地讲解,希望能帮到大家. 快速排序基本步骤: 从数列中挑出一个元素,称为"基准"(pivot). 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边).在这个分区结束之后,该基准就处于数列的中间位置.这个称为分区(partition)操作. 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序. 下面这幅图会帮助你理解.选中的pivot用蓝色表示: