数据结构算法之 三 快速排序

今儿来聊一聊 快速排序， 面试中最常提到的就是 冒泡和快排了 ，  冒泡还不了解的同学 可以先去补一下冒泡排序的知识。 可能有其他的文章说 快排的时间复杂度是O(N^2)，我个人觉得并不完全对 。因为0-100之间取随机数不可能永远取的是100吧！ 记住这句话，最后你会明白是啥意思了。

快排有三种方式：

一、快排1 ： 

        原理：取集合的第一个元素为中节点，将集合剩下的所有元素跟中节点对比，小的放左边 比之大的 放右边，然后把分配好的 左右两个集合再分别取第一个元素为中节点，再进行比较放到各自集合的左右两侧。

原集合：

我们取第一个元素 7 为中节点： 

 如上图，第一次左右节点分配完成了，注意 跟中节点相等的元素可以放右边也可以放左边。

老规矩，上码吧！

#include <stdio.h>
#include <windows.h>

void process(int arr[], int start, int end)
{
    //开始索引大于或者等于直接返回
    if (start >= end)
        return;
    //比较元素等于两个时直接比较替换
    if (end - start == 1)
    {
        if (arr[start] > arr[end])
        {
            arr[start] = arr[start] ^ arr[end];
            arr[end] = arr[start] ^ arr[end];
            arr[start] = arr[start] ^ arr[end];
        }
        return;
    }
    //取中间节点
    int centernode = arr[start];
    int startindex = 0;
    int endindex = end - start;
    int newarrcount = end - start + 1;
    int newarr[newarrcount];
    //左右两侧 比较
    for (int i = start + 1; i <= end; i++)
    {
        if (centernode > arr[i])
        {
            newarr[startindex] = arr[i];
            startindex++;
        }
        else
        {
            newarr[endindex] = arr[i];
            endindex--;
        }
    }
    newarr[startindex] = centernode;
    // 替换原数组
    for (int i = start; i <= end; i++)
    {

        arr[i] = newarr[(i - start)];
    }
    printf("start-%d,end-%d ------------------------ \n", start, end);
    for (int i = 0; i < 14; i++)
    {
        printf("%d,", arr[i]);
    }
    printf("\n");
    //递归左侧
    process(arr, start, start + startindex - 1);
    //递归右侧
    process(arr, start + startindex + 1, end);
}

int main()
{
    int arr[] = {8, 21, 563, 63, 456, 5, 70, 2, 4, 76, 54, 2, 1, 3};
    int len = sizeof(arr) / sizeof(arr[0]);
    printf("快速排序 -->前的数组：");
    for (int i = 0; i < len; i++)
    {
        printf("%d,", arr[i]);
    }
    printf("\n");
    printf("长度--->%d \n", len);

    process(arr, 0, len - 1);
    printf("我是快速排序");
    for (int i = 0; i < len; i++)
    {
        printf("%d,", arr[i]);
    }
    system("pause");
    return 0;
}

运行结果：

 老铁们直接看代码及注释理解吧 ，不懂的call 我。

二、快排2

        跟快排1的唯一区别就是 当其他元素跟中间节点相等时，不会放到左右侧，而是等左右侧都比较好之后，再一起放到最后的位置，例如 中间节点是8   整个对比数组里面有3个8，这三个8不会分配到下次对比的左右数组里面。

三、快排3

        这也是快排最高效的排序 ，跟排序2的区别在于 中间节点的选取规则，  上文说过 0-100之间取随机数不可能永远取的是100吧！ 快排3就是通过随机来选择中间节点的 ，也就说 给定一个元素，有可能选择理想的，也有可能选择最次的元素。

来 上码!

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>

void process(int arr[], int start, int end)
{
    //开始索引大于或者等于直接返回
    if (start >= end)
        return;
    //比较元素等于两个时直接比较替换
    if (end - start == 1)
    {
        if (arr[start] > arr[end])
        {
            arr[start] = arr[start] ^ arr[end];
            arr[end] = arr[start] ^ arr[end];
            arr[start] = arr[start] ^ arr[end];
        }
        return;
    }
    //取中间节点

    int startindex = 0;
    int endindex = end - start;
    int newarrcount = end - start + 1;
    int newarr[newarrcount];
    //取随机数
    srand((unsigned)time(NULL)); //C 语言连续生成需要加这句
    int centernodeindex = rand() % newarrcount;
    int centernode = arr[start + centernodeindex];
    int centernodecount = 0; //中间节点 相同元素的个数

    printf("随机数：%d  %d\n",centernodeindex,newarrcount);
    //左右两侧 比较
    for (int i = start; i <= end; i++)
    {
        if (centernode == arr[i])
        {
            centernodecount++;
        }
        else
        {
            if (centernode > arr[i])
            {
                newarr[startindex] = arr[i];
                startindex++;
            }
            else
            {
                newarr[endindex] = arr[i];
                endindex--;
            }
        }
    }
    //将相同的节点数放到数组中
    for (int i = 0; i < centernodecount; i++)
    {
        newarr[(startindex + i)] = centernode;
    }

    // 替换原数组
    for (int i = start; i <= end; i++)
    {

        arr[i] = newarr[(i - start)];
    }
    printf("start-%d,end-%d ------------------------ \n", start, end);
    for (int i = 0; i < 14; i++)
    {
        printf("%d,", arr[i]);
    }
    printf("\n");
    //递归左侧
    process(arr, start, start + startindex - 1);
    //递归右侧
    process(arr, start + startindex + centernodecount, end);
}

int main()
{
    int arr[] = {8, 21, 563, 63, 456, 5, 70, 2, 4, 76, 54, 2, 1, 3};
    int len = sizeof(arr) / sizeof(arr[0]);
    printf("快速排序3 -->前的数组：");
    for (int i = 0; i < len; i++)
    {
        printf("%d,", arr[i]);
    }
    printf("\n");
    printf("长度--->%d \n", len);

    process(arr, 0, len - 1);
    printf("我是快速排序3");
    for (int i = 0; i < len; i++)
    {
        printf("%d,", arr[i]);
    }
    system("pause");
    return 0;
}

我们来运行看下结果：

1.

 递归比较了8次

2.

 5次

3.

6次

我们看到每次执行的比较次数都是不一样的 ，也就是在统计学上面，快排3的的复杂度是比前面两种底的。后面我会介绍所有排序的复杂度和优势。

今儿就聊到这了 ，喜欢的老铁点个赞，欢迎各位老铁留言评论 交流意见！！