快速排序(Quicksort)是对冒泡排序的一种改进。
我们知道快速排序用的是分治的基本思想:将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归的解决这些子问题,然后将这些子问题的解组合为原问题的解。
快速排序的基本思想是:
通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
快速排序的基本思想用分治法可描述为:
当begin小于end不成立,即begin==end时,判断a[begin]与key两个值,如果a[begin]>key,那么交换两个值。
上面判断a[begin]>key的目的是:当一个数组只有两个数字的时候,如果不进行判断,会多一次交换。
上面的过程有些抽象,现在放上代码:
int PartSort(int* a, int left, int right)
{
int key = a[right];
int begin = left;
int end = right-1;
while (begin < end)
{
// 找大
while (begin < end && a[begin] <= key)
++begin;
// 找小
while (begin < end && a[end] >= key)
--end;
if (begin < end)
swap(a[begin], a[end]);
}
if (a[begin] > a[right])
{
swap(a[begin], a[right]);
return begin;
}
else
{
return right;
}
}
现在来分析一下只有两个值的时候:
int a[2]={4,3};
此时left = 0,right = 1;key = a[right] ;
begin = 0;end = 0;
所以一开始begin < end条件就不成立,直接跳出循环,判断a[begin]与key的大小,得a[begin]>key,swap即可。
排序成功。
那么现在分析一下有序序列:
int a[2]={3,4};
此时left = 0,right = 1;key = a[right] ;key==4
begin = 0;end = 0;
所以一开始begin < end条件就不成立,直接跳出循环,判断a[begin]与key的大小,得a[begin] < key,不进行swap直接return。
排序成功。
上面只是单趟排序的算法。
整体排序算法:
void QuickSort(int* a, int left, int right)
{
assert(a);
if (left >= right)
return;
if(right - left < 50)
{
InsertSort(a+left, right-left+1);
return;
}
int div = PartSort(a, left, right);
QuickSort(a, left, div-1);
QuickSort(a, div+1, right);
}
void TestQuickSort()
{
//int a[] = {5,5,4,2,3,6,8,5,1,5};
//int a[] = {9,0,4,2,3,6,8,7,1,5};
int a[] = {0,1,2,3,4,5,6,7,8,9};
QuickSort(a, 0, sizeof(a)/sizeof(a[0])-1);
PrintArray(a, sizeof(a)/sizeof(a[0]));
}
上面的快速排序对其进行了优化,在数量小于50的情况下,其实用直接插入排序效果更好一些。
挖坑法是快速排序单趟排序第二种方法:
我们设定end下标是一个坑,当begin找到比key值大的数的时候,将该值放入坑内,接着下一个坑就是begin下标所在位置,再从end开始往前找,找比key值小的数字,当找到后,再将值放入begin坑内,此时将坑变为end所在下标,直到begin小于end条件不成立为止。
上图中,蓝色方框代表坑,绿色圆圈代表改变的数据。
代码为:
// 挖坑法
int PartSort(int* a, int left, int right)
{
int key = a[right];
int begin = left;
int end = right;
while (begin < end)
{
while(begin < end && a[begin] <= key)
++begin;
if (begin < end)
a[end] = a[begin];
while (begin < end && a[end] >= key)
--end;
if (begin < end)
a[begin] = a[end];
}
a[begin] = key;
return begin;
}
利用栈进行非递归存放数据。
代码如下:
#include
void QuickSort_NonR(int* a, int left, int right)
{
stack<int> s;
s.push(right);
s.push(left);
while (!s.empty())
{
int begin = s.top();
s.pop();
int end = s.top();
s.pop();
int div = PartSort2(a, begin, end);
// [begin div-1] [div+1, end]
if (begin < div-1)
{
s.push(div-1);
s.push(begin);
}
if (div+1 < end)
{
s.push(end);
s.push(div+1);
}
}
}
归并排序是利用归并技术来进行排序。
归并是指将若干个已排序的子文件合并成一个有序的文件。
两路归并算法的基本思路:
归并过程为:比较a[i]和a[j]的大小,若a[i]≤a[j],则将第一个有序表中的元素a[i]复制到r[k]中,并令i和k分别加上1;否则将第二个有序表中的元素a[j]复制到r[k]中,并令j和k分别加上1,如此循环下去,直到其中一个有序表取完,然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现,先把待排序区间[s,t]以中点二分,接着把左边子区间排序,再把右边子区间排序,最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。
归并排序有两种实现方法:自底向上和自顶向下
基本思想:
代码如下:
void _Merge(int* a, int* tmp
,int begin1, int end1
,int begin2, int end2)
{
int index = begin1;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
tmp[index++] = a[begin1++];
else
tmp[index++] = a[begin2++];
}
while(begin1 <= end1)
tmp[index++] = a[begin1++];
while (begin2 <= end2)
tmp[index++] = a[begin2++];
}
void _MergeSort(int* a, int* tmp, int left, int right)
{
if (left < right)
{
int mid = left+(right-left)/2;
// [left, mid] [mid, right]
_MergeSort(a, tmp, left, mid);
_MergeSort(a, tmp, mid+1, right);
_Merge(a, tmp, left, mid, mid+1, right);
memcpy(a+left, tmp+left, sizeof(int)*(right-left+1));
}
}
void MergeSort(int* a, size_t n)
{
assert(a);
int* tmp = new int[n];
_MergeSort(a, tmp, 0, n-1);
delete [] tmp;
}
void TestMergeSort()
{
//int a[] = {5,5,4,2,3,6,8,5,1,5};
int a[] = {9,0,4,2,3,6,8,7,1,5};
//int a[] = {0,1,2,3,4,5,6,7,8,9};
MergeSort(a, sizeof(a)/sizeof(a[0]));
PrintArray(a, sizeof(a)/sizeof(a[0]));
}