什么时候merge_sort优于quick_sort
When does merge_sort beat quick_sort?
SO Posts
何时使用归并排序,何时使用快速排序?
快速排序Vs归并排序
维基百科http://en.wikipedia.org/wiki/Merge_sort http://en.wikipedia.org/wiki/Quicksortquick_sort应该有最坏的情况O(n^2),但merge_sort应该没有最坏的情况,总是O(n *log n)。我认为这取决于数据集的顺序-反向顺序,正向顺序或随机,但当我运行测试时…Quick_sort总是更快。我使用的代码如下:
/*
Needs a reszie function added
*/
#include "c_arclib.cpp"
template <class T> class dynamic_array
{
private:
T* array;
T* scratch;
public:
int size;
dynamic_array(int sizein)
{
size=sizein;
array = new T[size]();
}
void print_array()
{
for (int i = 0; i < size; i++) cout << array[i] << endl;
}
void merge_recurse(int left, int right)
{
if(right == left + 1)
{
return;
}
else
{
int i = 0;
int length = right - left;
int midpoint_distance = length/2;
int l = left, r = left + midpoint_distance;
merge_recurse(left, left + midpoint_distance);
merge_recurse(left + midpoint_distance, right);
for(i = 0; i < length; i++)
{
if((l < (left + midpoint_distance)) && (r == right || array[l] > array[r]))
{
scratch[i] = array[l];
l++;
}
else
{
scratch[i] = array[r];
r++;
}
}
for(i = left; i < right; i++)
{
array[i] = scratch[i - left];
}
}
}
int merge_sort()
{
scratch = new T[size]();
if(scratch != NULL)
{
merge_recurse(0, size);
return 1;
}
else
{
return 0;
}
}
void quick_recurse(int left, int right)
{
int l = left, r = right, tmp;
int pivot = array[(left + right) / 2];
while (l <= r)
{
while (array[l] < pivot)l++;
while (array[r] > pivot)r--;
if (l <= r)
{
tmp = array[l];
array[l] = array[r];
array[r] = tmp;
l++;
r--;
}
}
if (left < r)quick_recurse(left, r);
if (l < right)quick_recurse(l, right);
}
void quick_sort()
{
quick_recurse(0,size);
}
void rand_to_array()
{
srand(time(NULL));
int* k;
for (k = array; k != array + size; ++k)
{
*k=rand();
}
}
void order_to_array()
{
int* k;
int i = 0;
for (k = array; k != array + size; ++k)
{
*k=i;
++i;
}
}
void rorder_to_array()
{
int* k;
int i = size;
for (k = array; k != array + size; ++k)
{
*k=i;
--i;
}
}
};
int main()
{
dynamic_array<int> d1(1000000);
d1.order_to_array();
clock_t time_start=clock();
d1.merge_sort();
clock_t time_end=clock();
double result = (double)(time_end - time_start) / CLOCKS_PER_SEC;
cout << result;
}
快速排序的最坏情况是每次递归时,主元素都是数组中最大或最小的元素。在这种情况下,你将不得不进行n-1次递归(你分割的一个数组总是只有一个元素),这给你一个O(n2)。
如果您使用已经排序的数组并选择第一个或最后一个元素作为枢轴元素,则可以重现快速排序的最坏情况。
合并排序对于内存无法容纳的数据非常有效,因为每次传递都是线性的,可以读/写到磁盘。在这种情况下,快速排序甚至不是一个选项,尽管两者可以组合在一起-快速排序适合内存的块,并对这些块进行合并排序,直到完成。
也要考虑容器类型——归并排序在链表中工作得更好,因为你可以通过遍历列表并将节点分配给备用子列表来将列表分成相等的部分;在快速排序中,围绕枢轴重新排列要复杂得多。
相关文章:
- 为什么 std::unique 不调用 std::sort?
- 对字符串进行排序时,在c++中处理sort()
- std::sort()函数无法对向量的一部分进行排序
- Qt Quick-如何仅从c++代码与qml属性交互
- 使用自定义比较函数使用std::sort()对矢量字符串进行排序时出现问题
- 使用的未初始化局部变量'Quick'
- C++中"std::sort"比较器的不同类型
- 如何使 std::sort 在 std::swap 和我的命名空间的模板化交换之间没有名称冲突?
- 按字母顺序对字符串中的字母进行排序,而无需使用内置的 sort()
- Qt Quick,如何更改 Ui 源代码?
- c++无值sort()的问题是什么?
- 将用户定义的类型与 std::vector 和 std::sort 一起使用
- 使用 std::sort 对向量进行稳定排序
- 如何使用 QSortFilterProxyModel::sort 对 Qlist 中的数据进行排序
- std::sort 如何处理重复的数字?
- 为什么 std::sort 找不到合适的(静态成员)函数重载?
- C++ <algorithm> 使用对象作为比较定义的 sort()
- QUICK SORT堆栈溢出c++大数字
- std::partition quick sort implementation
- Quick Sort c++,代码在int main()中实现