Question

我对quicksort有一个恼人的问题。所以，我必须研究最佳，平均和最差情况下的快速排序的表现（在操作中）。

操作包括：比较+归因。

目前我在这种情况下测试快速排序（100到10.000个元素阵列）。当我测试它并且得到以下结果（例如100个元素数组）时出现问题：

最佳案例： aprox。 4853次操作

平均案例： aprox。 1468次操作

最坏情况： aprox。 9024次操作

该理论称QuickSort在最佳和最佳效率方面的效率均为O(n*log n)。平均案例。正如您所看到的，我得到了一个完全不同的结果，违反了理论。

（我使用Profiler作为自定义库来生成随机数组。FillRandomArray方法的最后一个参数是order（0 - 无序，1 - 升序，2-降序））。

以下是我使用的代码：

#include <iostream>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include "Profiler.h"

#define MIN_SIZE 100
#define MAX_SIZE 10000


struct sortingAlg{
        std::string type;
        int atributions;
        int comparisons;
};

int partition(int *givenArray, int p, int r, sortingAlg& sortingAlgoritm)
{
        int x = givenArray[r];
        int i = p - 1;
        for (int j = p; j <= r - 1; ++j)
        {
                sortingAlgoritm.comparisons += 1;
                if (givenArray[j] <= x)
                {
                        sortingAlgoritm.atributions += 2;
                        i += 1;
                        int aux = givenArray[i];
                        givenArray[i] = givenArray[j];
                        givenArray[j] = aux;
                }
        }

        sortingAlgoritm.atributions += 2;
        givenArray[r] = givenArray[i + 1];
        givenArray[i + 1] = x;
        return i + 1;
}

void quicksort(int *givenArray, int beginning, int length, sortingAlg& sortingAlgoritm)
{
        if (beginning < length)
        {
                int q = partition(givenArray, beginning, length, sortingAlgoritm);
                quicksort(givenArray, beginning, q-1,  sortingAlgoritm);
                quicksort(givenArray, q + 1, length, sortingAlgoritm);
        }
}

int main()
{
        Profiler profiler("heapProfiler");

        sortingAlg sortingAlgs[2];
        sortingAlgs[0].type = "HS";
        sortingAlgs[0].atributions = 0;
        sortingAlgs[0].comparisons = 0;

        sortingAlgs[1].type = "QS";
        sortingAlgs[1].atributions = 0;
        sortingAlgs[1].comparisons = 0;


        for (int i = MIN_SIZE; i <= MAX_SIZE; i += 100)
        {
                std::cout << "Sorting array for " << i << " elements.." << std::endl;


                sortingAlgs[1].atributions = 0;
                sortingAlgs[1].comparisons = 0;

                int *avg =  new int[i];
                FillRandomArray(avg, i, 0, 1000, false, 0);
                quicksort(avg, 1, i, sortingAlgs[1]);

                profiler.countOperation("AVG_QuickSort_ALL", i, sortingAlgs[1].atributions + sortingAlgs[1].comparisons);
                profiler.createGroup("AVG_QuickSort", "AVG_QuickSort_ALL");

                sortingAlgs[1].atributions = 0;
                sortingAlgs[1].comparisons = 0;

                int *best =  new int[i];
                FillRandomArray(best, i, 0, 1000, false, 1);
                quicksort(best, 1, i, sortingAlgs[1]);

                profiler.countOperation("BEST_QuickSort_ALL", i, sortingAlgs[1].atributions + sortingAlgs[1].comparisons);
                profiler.createGroup("BEST_QuickSort", "BEST_QuickSort_ALL");

                sortingAlgs[1].atributions = 0;
                sortingAlgs[1].comparisons = 0;


                int *worst = new int[i];
                FillRandomArray(worst, i, 0, 1000, false, 2);
                quicksort(worst, 1, i, sortingAlgs[1]);

                profiler.countOperation("WORST_QuickSort_ALL", i, sortingAlgs[1].atributions + sortingAlgs[1].comparisons);
                profiler.createGroup("WORST_QuickSort", "WORST_QuickSort_ALL");
        }
        std::cout << "Building complete...! Creating profiler groups... Opnening reports!" << std::endl;
        profiler.showReport();


        return 0;
}

有什么想法吗？感谢。

Answer 1

我认为选择数据透视时会出现问题。

对于“最佳情况”场景，您应该选择“最佳枢轴”，但您没有这样做。如果你总是选择枢轴作为中间的数字，那就可以了。

Answer 2

简短的回答是看起来就像你没有正确选择枢轴一样，以便（甚至接近）最好的情况。事实上，鉴于您似乎正在选择支点，我很惊讶按顺序排序数据并不比您所显示的更糟糕。

要使有序数据成为最佳情况，您需要选择枢轴作为您当前正在分区的部分中间的元素。在这种情况下，您不必移动任何元素来执行分区。

顺便说一句：IMO，您的代码不必要地难以阅读。例如，p和r作为参数名称非常接近无意义。更好的名称将有助于破译您的代码。但是，除非你有一个非常具体的理由不这样做，否则我也考虑更换你的：

                    int aux = givenArray[i];
                    givenArray[i] = givenArray[j];
                    givenArray[j] = aux;

有类似的东西：

using std::swap;
// ...


                   swap(givenArray[i], givenArray[j]);

这不仅更具可读性，而且对于使用除int以外的某种类型的元素的代码可能更有效，其中最有效的交换可能不是复制整个元素。

就个人而言，如果我想要描述你所拥有的比较和作业的数量，我的做法却截然不同：我定义了一种跟踪该类型的比较和分配的类型： / p>

template <class T>
class counted {
    static size_t comparisons;
    static size_t assignments;
    T val;
public:
    counted(T val) : val(val) {}
    bool operator<(counted c) {
        ++comparisons;
        return val < c.val;
    }

    counted &operator=(counted &other) { 
        ++assignments;
        val = other.val;
        return *this;
    }
    static void reset() { 
        assignments = 0;
        comparisons = 0;
    }
    std::pair<size_t, size_t> counts() { 
        return std::make_pair(assignments, comparisons); 
    }
};

然后排序代码将只进行排序，并且为了对排序代码进行分析，您只需传递处理分析的此类型的数组（或优选地，向量）。排序完成后，您可以从该类型中检索计数，重置计数，然后进行下一次测试。这样，您几乎可以对任何排序代码进行概要分析，而无需重写排序代码进行分析（例如，如果您想将各种输入订单的快速排序与std::sort进行比较，则可以非常轻松地进行分析）。

QuickSort最佳案例比一般情况更糟糕

2 个答案: