算法之排序-----排序第一篇快速排序

最新推荐文章于 2024-09-12 15:56:42 发布

p11323

最新推荐文章于 2024-09-12 15:56:42 发布

阅读量2.1k

点赞数 1

分类专栏： C++ 算法 dance with algorithm 文章标签：快速排序算法

本文链接：https://blog.csdn.net/cqs_experiment/article/details/17292043

版权

C++ 同时被 3 个专栏收录

78 篇文章 0 订阅

订阅专栏

算法

56 篇文章 0 订阅

订阅专栏

dance with algorithm

36 篇文章 1 订阅

订阅专栏

快速排序

引言

排序是所有算法里比较基本的算法了，并且非常简单。那么我为什么还要自己再写一遍呢?我觉得知识是大家的，只有你掌握了，这个知识才属于你，才能为你所用。所以接下来，我要连续的将所有的算法都做成博文。其目的，一是总结知识，提高自己；二是为大家共享知识，经验。希望大家督促并给予支持。

算法介绍

快速排序是七中排序算法里比较常用的算法.分治法的基本思想是：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。事实上，快速排序通常明显比其他Ο(n log n) 算法更快。

平均时间复杂度O（n * log n），最坏时间复杂度O（n*n）
平均空间复杂度O ( log n )，最坏空间复杂度O( n )
如果用于大量数据排序，可能函数栈溢出。

算法演示

单项遍历

标识符初始化如下

IF ES<R, then LS++,LS<->ES,ES++，如下

But ES>R,ES++,如下

But ES>R,ES++,如下

IF ES<R,LS++,LS<->ES,ES++,如下

IF ES<R,LS++,LS<->ES,ES++,如下

IF ES<R,LS++,LS<->ES,ES++,如下

IF ES<R,LS++,LS<->ES,ES++,如下

IF ES<R,LS++,LS<->ES,ES++,如下

IF ES<R,LS++,LS<->ES,ES++,如下

ES 越界,LS<->R,如下

然后，快速单向排序结束。递归对两个子数据集排序

递归到直至每个子数据集为单个元素为止。

双向遍历

各标识符初始化，如下

这时候I在R右边，IF I<R, I<->R, 同时I和R也换位， I++, 如下

这时候I在R左边，IF I<R, I++, 如下

这时候I在R左边，因为I>R, I<->R,同时I和R也换位，同时 I--, 如下

这时候I在R右边，I不小于R，I--，如下

这时候I在R右边，IF I<R, I<->R, 同时I和R也换位， I++, 如下

这时候I在R左边， I不大于R, I++, 如下

这时候I == R,一趟快速排序结束，分成这个子集，递归进行快速排序。如下

递归到子数据集只有一个元素而矣。

实验数据

单项遍历

双向遍历

调用库中的qsort，我想说差别真大。。。。。现在我怀疑往后还要自己写代码么？？？？？

代码

单向遍历

#include<iostream>
#include <windows.h>
#include<Winbase.h>
#include <ctime>
using namespace std;

// data declare
size_t const size = 1000000 ;

// function declare
template<class T>
void Initialize( T * &V );
template<class T>
void QuickSort(T * &V,size_t s,size_t e);
template<class T>
void Swap(T * &V,size_t i,size_t j);
template<class T>
void DataCout(T * &V, size_t Size);



int main()
{
	int * V = new int[size];
	DWORD time_s ,time_e;

	Initialize(V);

	//VectorCout(V);
	cout<<"quicksort "<<endl;
	time_s = GetTickCount();
	QuickSort(V, 0, size - 1);
	time_e = GetTickCount() ; 
	cout<<"给 "<<size<<" 个数据排序 用时 "<<time_e-time_s<<" 毫秒"<<endl;
	system("pause");
	DataCout(V, size);
	delete V;

	system("pause");
	return 0;
}

template<class T>
void Initialize(T * &V)
{
	if(V != NULL)
		for(size_t i = 0; i < size; i++)
		{
			V[i] = rand() % 1000;
		}
}

template<class T>
void QuickSort(T * &V,size_t s,size_t e)
{
	if(V != NULL && s < e)
	{	
		size_t key = s;
		size_t i = s, j = s + 1;
		while(j <= e)
		{
			if( V[j] < V[key] )
			{
				Swap(V, ++i, j);		
			}
			j++;
		}
		Swap(V,i,key);
		if( i > 0 )
			QuickSort(V, s, i - 1);
		QuickSort(V, i+1, e);
	}
}

template<class T>
void Swap(T * &V,size_t i,size_t j)
{
	if(i >= 0 && j >= 0 )
	{
		T d = V[i];
		V[i] = V[j];
		V[j] = d;
	}
}

template<class T>
void DataCout(T * &V, size_t Size)
{
	cout<<"data follows"<<endl;
	for(size_t i = 0; i < Size; i++)
	{
		cout<<V[i]<<" ";
	}
	cout<<endl;
}

双向遍历

#include<iostream>
#include <windows.h>
#include<Winbase.h>
#include <ctime>
using namespace std;

// data declare
size_t const size = 1000000 ;

// function declare
template<class T>
void Initialize( T * &V ,size_t s);
template<class T>
void QuickSort(T * &V,size_t s,size_t e,size_t Size);
template<class T>
void Swap(T * &V,size_t i,size_t j,size_t Size);

void SwapInt(size_t &i,size_t &j);
template<class T>
void DataCout(T * &V, size_t Size);



int main()
{
	int * V = new int[ size ];
	DWORD time_s ,time_e;

	Initialize(V,size);

	//VectorCout(V);
	cout<<"quick sort"<<endl;
	time_s = GetTickCount();
	QuickSort(V,0,size - 1,size);
	time_e = GetTickCount() ; 
	cout<<"给 "<<size<<" 个数据排序 用时 "<< time_e - time_s <<" 毫秒"<<endl;
	//system("pause");
	//DataCout(V,size);
	delete V;

	system("pause");
	return 0;
}

template<class T>
void Initialize( T * &V ,size_t s)
{
	if( V && s >= 0 )
		for(size_t i = 0; i < size; i++)
		{
			V[i] = rand() % 1000 ;
		}
}

// Bi-directed
template<class T>
void QuickSort(T * &V,size_t s,size_t e,size_t Size)
{
	if(V && 0 <= s && s < e && e < Size )
	{	
		size_t key = s;
		size_t i = e ;

		while( i != key )
		{
			if( i > key )
			{
				if( V[i] < V[key] )
				{
					Swap(V,i,key,Size);
					SwapInt(i,key);
					i++;
				}
				else
					i--;
			}
			else
			{
				if( V[i] > V[key] )
				{
					Swap(V,i,key,Size);
					SwapInt(i,key);
					i--;
				}
				else
					i++;
			}
		}
		QuickSort(V,s,key-1,Size);
		QuickSort(V,key+1,e,Size);
	}
}

template<class T>
void Swap(T * &V,size_t i,size_t j,size_t Size)
{
	if(i >= 0 && i < Size && j >= 0 && j < Size )
	{
		int d = V[i];
		V[i] = V[j];
		V[j] = d;
	}
}


void SwapInt(size_t &i, size_t &j)
{
	size_t d = i ;
	i = j;
	j = d;
}

template<class T>
void DataCout(T * &V, size_t Size)
{
	cout<<"data follows"<<endl;
	for(size_t i = 0; i < Size; i++)
	{
		cout<<V[i]<<" ";
	}
	cout<<endl;
}

库中的qsort调用

#include<iostream>
#include<algorithm>
#include<vector> 
#include <windows.h>
#include<Winbase.h>
#include <ctime>
using namespace std;

// data declare 1000,000
size_t const size = 1000000 ;

// function declare
int compare(const void * a, const void * b);


int main()
{
	DWORD time_s ,time_e;
	int *d = new int[size];
	for(size_t i =0; i<size; i++)
	{
		d[i] = rand() % 1000;
	}

	cout<<"quick sort"<<endl;

	time_s = GetTickCount();
	qsort(d,size,sizeof(int),compare);
	time_e = GetTickCount() ;

	cout<<"给 "<<size<<" 个数据排序 用时 "<< time_e - time_s <<" 毫秒"<<endl;

	system("pause");
	for(size_t i =0; i<size; i++)
	{
		cout<<d[i]<<" ";
	}
	system("pause");
	return 0;
}


int compare(const void * a, const void * b)
{
	return *(int*)a - *(int*)b;
}