排序算法总结——快速排序（C++实现）

快速排序（quick sort）

在每一轮挑选一个基准元素，并让其他比它大的元素移动到数列的一边，比它小的元素移动到数列的另一边。从而把数列拆解成两个部分（分治法）。

假设元素个数是n，每一轮的比较和变换，需要把数组全部元素遍历一遍，时间复杂度是O(n)，平均情况下需要logn轮，则快速排序总体的平均时间复杂度是O(nlogn)。极端情况下会退化成O(n2)（数列完全逆序），为了避免这种情况，可以随机选择一个元素作为基准元素，并且让基准元素和数列首元素交换位置。

 1. 双边循环

选定一个基准元素pivot，并设置两个指针left和right，指向数列的最左和最右两个元素。

① 从right指针开始，让指针所指向的元素和基准元素比较，如果大于或等于pivot，指针向左移动；如果小于，则right指针停止移动，切换到left指针；

② 对于left指针，让指针所指向的元素和基准元素做比较，如果小于或等于pivot，指针向右移动；如果大于，left指针停止移动，切换到right，进行第二轮。

…….

class Solution
{
public:
    void quickSort2(int* data, int length, int start, int end)
    {
        if (data == nullptr || length <= 0)
            return;
        //递归结束条件
        if (start == end)
            return;
        // 得到基准元素
        int pivot = partition(data, start, end);
        if (pivot > start)
            quickSort2(data,length,start, pivot - 1);
        if (pivot < end)
            quickSort2(data,length, pivot + 1, end);
    }

    int partition(int* data,  int startIndex, int endIndex)
    {
        // 选择中间元素作为基准元素，并让基准元素和数列首元素交换位置
        int pivot = ((endIndex - startIndex) >> 1) + startIndex;
        swap(&data[pivot], &data[startIndex]);
        int pivotData = data[startIndex];    

        int left = startIndex;
        int right = endIndex;

        while (left != right)
        {
            // 控制right指针比较并左移
            while (left < right && data[right] > pivotData)
                right--;
            // 控制left指针比较并且右移
            while (left < right && data[left] <= pivotData)
                left++;

            if (left < right)
                swap(&data[left], &data[right]);                

        }
        //pivot和指针重合点交换
        data[startIndex] = data[left];
        data[left] = pivotData;
        return left;
    }
    // 交换left 和right指针所指向的元素
    void swap(int *a, int *b)
    {
        int t = *a;
        *a = *b;
        *b = t;
    }
};

测试代码：

void test()
{
    int data[] = { 9, 8, 7, 8, 4, 3, 2, 1 };
    int length = sizeof(data) / sizeof(int);

    Solution M;
    M.quickSort2(data, length, 0, length - 1);

    for (int i = 0; i < length; ++i)
        cout << data[i] << "  ";
    cout << endl;
}

 

2. 单边循环

只从数组的一边对元素进行遍历和交换。首先选定基准元素pivot。同时设置一个mark指针指向数列的起始位置，这个mark针代表小于基准元素的区域边界。

① 从基准元素的下一个位置开始遍历数组。如果遍历到的元素大于基准元素，就继续往后遍历。

② 如果遍历到的元素小于基准元素，则需要做两件事：第一，将mark指针右移1位，因为小于pivot的区域边界增大了1；第二，让最新遍历到的元素和mark指针所在位置的元素交换位置，因为最新遍历的元素归属于与小于pivot的区域。

重复以上操作.......

class Solution
{
public:
    void quickSort1(int* data, int length, int start, int end)
    {
        if (data == nullptr || length <= 0)
            return;
        //递归结束条件
        if (start == end)
            return;
        // 得到基准元素
        int pivot = partition(data, start, end);
        if (pivot > start)
            quickSort1(data, length, start, pivot - 1);
        if (pivot < end)
            quickSort1(data, length, pivot + 1, end);
    }

    int partition(int* data, int startIndex, int endIndex)
    {
        int pivotIndex = data[startIndex];
        int mark = startIndex;

        for (int i = startIndex + 1; i <= endIndex; ++i)
        {
            if (data[i] < pivotIndex)
            {
                mark++;
                swap(&data[mark], &data[i]);
            }
        }

        // 将pivot元素交换到mark指针所在的位置
        data[startIndex] = data[mark];
        data[mark] = pivotIndex;
        return mark;
    }

    // 交换left 和right指针所指向的元素
    void swap(int *a, int *b)
    {
        int t = *a;
        *a = *b;
        *b = t;
    }
};

测试案例：

void test()
{
    int data[] = { 4, 4, 6, 8, 3, 2, 8, 1 };
    int length = sizeof(data) / sizeof(int);

    Solution M;
    M.quickSort1(data, length, 0, length - 1);

    for (int i = 0; i < length; ++i)
        cout << data[i] << "  ";
    cout << endl;
}

转载于:https://www.cnblogs.com/wyr-123-wky/p/11088765.html