算法学习笔记之快速排序
2016-09-11 10:30
429 查看
快速排序的基本步骤是什么:
1、 判断输入参数的合法性
2、把数组的第一个数据作为比较的中轴数,比该数据小的数据排列在左边,比该数据大的数据排列在右边
3、按照(2)的方法分别对左边的数组和右边的数据进行和(2)一样的数据排列
那么实际编写代码中,应该怎么做呢?
a)首先,判断数据的合法性?
[cpp] view
plain copy
void quick_sort(int array[], int length)
{
int median = 0;
if(NULL == array || 0 == length)
return;
_quick_sort(array, 0, length -1);
}
b)寻找中间数,分别对左边和右边的数据进行排序
[cpp] view
plain copy
void _quick_sort(int array[], int start, int end)
{
int middle;
if(start >= end)
return;
middle = get_middle(array, start, end);
_quick_sort(array, start, middle -1); //中轴前
_quick_sort(array, middle + 1, end); //中轴后
}
void quick_sort(int array[], int length)
{
int median = 0;
if(NULL == array || 0 == length)
return;
_quick_sort(array, 0, length-1); //递归函数
}
c)那么这里的中间数应该怎么安排呢?
[cpp] view
plain copy
int get_middle(int array[], int start, int end)
//以数组的第一个元素做中轴分离
{
int front = 0;
int tail = end - start;
int value = array[start];
int length = end - start + 1;
int loop = start + 1;
while(loop <= end){
if(array[loop] < value){
gQuickSort[front] = array[loop];
front ++;
}else{
gQuickSort[tail] = array[loop];
tail --;
}
loop ++;
}
gQuickSort[front] = value;
memmove(&array[start], gQuickSort, sizeof(int) * (length));
return start + front ;
}
注意:这里gQuickSort是一个全局数组,主要是为了作为排序的临时数组使用,实际环境中大家可以灵活运用各种方法。
d)基本的快速排序就完成了,那我们怎么测试呢?我们可以编写几个简单的测试用例?
[cpp] view
plain copy
static void test1()
{
int array[] = {1};
quick_sort(array, sizeof(array)/sizeof(int));
}
static void test2()
{
int array[] = {2, 1};
quick_sort(array, sizeof(array)/sizeof(int));
assert(1 == array[0]);
assert(2 == array[1]);
}
static void test3()
{
int array[] = {4, 3, 2,1};
quick_sort(array, sizeof(array)/sizeof(int));
assert(1 == array[0]);
assert(2 == array[1]);
assert(3 == array[2]);
assert(4 == array[3]);
}
static void test4()
{
int array[] = {3, 2, 1};
quick_sort(array, sizeof(array)/sizeof(int));
assert(1 == array[0]);
assert(2 == array[1]);
assert(3 == array[2]);
}
快速排序算法效率与稳定性分析
当基数值不能很好地分割数组,即基准值将数组分成一个子数组中有一个记录,而另一个子组组有 n -1 个记录时,下一次的子数组只比原来数组小 1,这是快速排序的最差的情况。如果这种情况发生在每次划分过程中,那么快速排序就退化成了冒泡排序,其时间复杂度为O(n2)。
如果基准值都能讲数组分成相等的两部分,则出现快速排序的最佳情况。在这种情况下,我们还要对每个大小约为 n/2 的两个子数组进行排序。在一个大小为 n 的记录中确定一个记录的位置所需要的时间为O(n)。若T(n)为对n个记录进行排序所需要的时间,则每当一个记录得到其正确位置,整组大致分成两个相等的两部分时,我们得到快速排序算法的最佳时间复杂性。
T(n) <= cn + 2T(n/2) c是一个常数
<= cn + 2(cn/2+2T(n/4)) = 2cn+ 4T(n/4)
<= 2cn + 4(cn/4+ 2T(n/8)) = 3cn + 8T(n/8)
…… ……
<= cnlogn + nT(1) = O(nlogn) 其中cn 是一次划分所用的时间,c是一个常数
最坏的情况,每次划分都得到一个子序列,时间复杂度为:
T(n) = cn + T(n-1)
= cn + c(n-1) + T(n - 2) = 2cn -c + T(n-2)
= 2cn -c + c(n - 2) + T(n-3) = 3cn -3c + T(n-3)
……
= c[n(n+1)/2-1] + T(1) = O(n2)
快速排序的时间复杂度在平均情况下介于最佳与最差情况之间,假设每一次分割时,基准值处于最终排序好的位置的概率是一样的,基准值将数组分成长度为0 和 n-1,1 和 n-2,……的概率都是 1/n。在这种假设下,快速排序的平均时间复杂性为:
T(n) = cn + 1/n(T(k)+ T(n-k-1)) T(0) = c, T(1) = c
这是一个递推公式,T(k)和T(n-k-1)是指处理长度为 k 和 n-k-1 数组是快速排序算法所花费的时间, 根据公式所推算出来的时间为 O(nlogn)。因此快速排序的平均时间复杂性为O(nlogn)。
快速排序需要栈空间来实现递归,如果数组按局等方式被分割时,则最大的递归深度为 log n,需要的栈空间为 O(log n)。最坏的情况下在递归的每一级上,数组分割成长度为0的左子数组和长度为 n - 1 的右数组。这种情况下,递归的深度就成为 n,需要的栈空间为 O(n)。
因为快速排序在进行交换时,只是根据比较基数值判断是否交换,且不是相邻元素来交换,在交换过程中可能改变相同元素的顺序,因此是一种不稳定的排序算法。
1、 判断输入参数的合法性
2、把数组的第一个数据作为比较的中轴数,比该数据小的数据排列在左边,比该数据大的数据排列在右边
3、按照(2)的方法分别对左边的数组和右边的数据进行和(2)一样的数据排列
那么实际编写代码中,应该怎么做呢?
a)首先,判断数据的合法性?
[cpp] view
plain copy
void quick_sort(int array[], int length)
{
int median = 0;
if(NULL == array || 0 == length)
return;
_quick_sort(array, 0, length -1);
}
b)寻找中间数,分别对左边和右边的数据进行排序
[cpp] view
plain copy
void _quick_sort(int array[], int start, int end)
{
int middle;
if(start >= end)
return;
middle = get_middle(array, start, end);
_quick_sort(array, start, middle -1); //中轴前
_quick_sort(array, middle + 1, end); //中轴后
}
void quick_sort(int array[], int length)
{
int median = 0;
if(NULL == array || 0 == length)
return;
_quick_sort(array, 0, length-1); //递归函数
}
c)那么这里的中间数应该怎么安排呢?
[cpp] view
plain copy
int get_middle(int array[], int start, int end)
//以数组的第一个元素做中轴分离
{
int front = 0;
int tail = end - start;
int value = array[start];
int length = end - start + 1;
int loop = start + 1;
while(loop <= end){
if(array[loop] < value){
gQuickSort[front] = array[loop];
front ++;
}else{
gQuickSort[tail] = array[loop];
tail --;
}
loop ++;
}
gQuickSort[front] = value;
memmove(&array[start], gQuickSort, sizeof(int) * (length));
return start + front ;
}
注意:这里gQuickSort是一个全局数组,主要是为了作为排序的临时数组使用,实际环境中大家可以灵活运用各种方法。
d)基本的快速排序就完成了,那我们怎么测试呢?我们可以编写几个简单的测试用例?
[cpp] view
plain copy
static void test1()
{
int array[] = {1};
quick_sort(array, sizeof(array)/sizeof(int));
}
static void test2()
{
int array[] = {2, 1};
quick_sort(array, sizeof(array)/sizeof(int));
assert(1 == array[0]);
assert(2 == array[1]);
}
static void test3()
{
int array[] = {4, 3, 2,1};
quick_sort(array, sizeof(array)/sizeof(int));
assert(1 == array[0]);
assert(2 == array[1]);
assert(3 == array[2]);
assert(4 == array[3]);
}
static void test4()
{
int array[] = {3, 2, 1};
quick_sort(array, sizeof(array)/sizeof(int));
assert(1 == array[0]);
assert(2 == array[1]);
assert(3 == array[2]);
}
快速排序算法效率与稳定性分析
当基数值不能很好地分割数组,即基准值将数组分成一个子数组中有一个记录,而另一个子组组有 n -1 个记录时,下一次的子数组只比原来数组小 1,这是快速排序的最差的情况。如果这种情况发生在每次划分过程中,那么快速排序就退化成了冒泡排序,其时间复杂度为O(n2)。
如果基准值都能讲数组分成相等的两部分,则出现快速排序的最佳情况。在这种情况下,我们还要对每个大小约为 n/2 的两个子数组进行排序。在一个大小为 n 的记录中确定一个记录的位置所需要的时间为O(n)。若T(n)为对n个记录进行排序所需要的时间,则每当一个记录得到其正确位置,整组大致分成两个相等的两部分时,我们得到快速排序算法的最佳时间复杂性。
T(n) <= cn + 2T(n/2) c是一个常数
<= cn + 2(cn/2+2T(n/4)) = 2cn+ 4T(n/4)
<= 2cn + 4(cn/4+ 2T(n/8)) = 3cn + 8T(n/8)
…… ……
<= cnlogn + nT(1) = O(nlogn) 其中cn 是一次划分所用的时间,c是一个常数
最坏的情况,每次划分都得到一个子序列,时间复杂度为:
T(n) = cn + T(n-1)
= cn + c(n-1) + T(n - 2) = 2cn -c + T(n-2)
= 2cn -c + c(n - 2) + T(n-3) = 3cn -3c + T(n-3)
……
= c[n(n+1)/2-1] + T(1) = O(n2)
快速排序的时间复杂度在平均情况下介于最佳与最差情况之间,假设每一次分割时,基准值处于最终排序好的位置的概率是一样的,基准值将数组分成长度为0 和 n-1,1 和 n-2,……的概率都是 1/n。在这种假设下,快速排序的平均时间复杂性为:
T(n) = cn + 1/n(T(k)+ T(n-k-1)) T(0) = c, T(1) = c
这是一个递推公式,T(k)和T(n-k-1)是指处理长度为 k 和 n-k-1 数组是快速排序算法所花费的时间, 根据公式所推算出来的时间为 O(nlogn)。因此快速排序的平均时间复杂性为O(nlogn)。
快速排序需要栈空间来实现递归,如果数组按局等方式被分割时,则最大的递归深度为 log n,需要的栈空间为 O(log n)。最坏的情况下在递归的每一级上,数组分割成长度为0的左子数组和长度为 n - 1 的右数组。这种情况下,递归的深度就成为 n,需要的栈空间为 O(n)。
因为快速排序在进行交换时,只是根据比较基数值判断是否交换,且不是相邻元素来交换,在交换过程中可能改变相同元素的顺序,因此是一种不稳定的排序算法。
相关文章推荐
- 算法学习笔记--排序之快速排序
- 8大内部排序算法学习笔记--(2)快速排序 Java实现
- 基础算法学习笔记—快速排序
- 学习笔记之快速排序——quicklySort——基础算法——java
- 算法第四版学习笔记之快速排序 QuickSort
- 数据结构&算法学习笔记: 快速排序
- 快速排序(Quicksort)学习笔记
- 快速排序学习笔记
- [算法学习笔记]线性时间排序----计数排序
- 算法学习之三:快速排序
- 算法学习笔记之排序--基于值的插入排序
- 算法(第四版)学习笔记之java实现选择排序
- 算法学习笔记-排序
- [学习笔记]排序算法之冒泡排序
- 算法学习-1 快速排序
- 【算法学习笔记】51. 贪心法 区间排序问题 SJTU OJ 1360 偶像丁姐的烦恼
- 算法学习笔记----第二部分:排序和顺序统计量----第6章、堆排序
- 【算法学习】排序算法-快速排序
- 算法学习--希尔和快速排序
- 【算法导论】学习笔记——第8章 线性时间排序