算法分析：基于划分算法的快速排序C语言实现

 因为快速算法的时间复杂度，快速排序的速度也比大部分排序的速度要快。在最坏的情况下，算法QUICKSORT 的运行时间是0(n²)，然而如果总是选择中项作为主元，它的时间复杂性是O( nlog n)，这样，就需要spilt算法来帮忙寻找。多余的也不多说了，书上都有，接下来直接上代码！

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

/*
将5设为比较元素，每次比较都需要这个元素，再用j做寻找元素，j每找到一个比5小的数,则i++,并且交换比较过的元素。最后跳出循环，将比较元素与最后i的位置进行交换

1.   5   7   1   6   4   8   3   2          7>5;
     i
         j
     5   7   1   6   4   8   3   2          j++;
     i
             j

2.   5   7   1   6   4   8   3   2          1<5;
     i
             j
     5   7   1   6   4   8   3   2          i++;
         i
             j
     5   1   7   6   4   8   3   2          交换A[i]和A[j];7   1 -> 1  7
         i
             j
     5   1   7   6   4   8   3   2          j++;
         i
                 j

3.   5   1   7   6   4   8   3   2          6>5;
         i
                 j
     5   1   7   6   4   8   3   2          j++;
         i
                     j

4.   5   1   7   6   4   8   3   2          4<5;
         i
                     j
     5   1   7   6   4   8   3   2          i++;
             i
                     j
     5   1   4   6   7   8   3   2          交换元素A[i]和A[j];7    4 -> 4    7
             i
                     j
     5   1   4   6   7   8   3   2          j++;
             i
                         j

5.   5   1   4   6   7   8   3   2          8>5;
             i
                         j
     5   1   4   6   7   8   3   2          j++;
             i
                             j

6.   5   1   4   6   7   8   3   2          3<5;
             i
                             j
     5   1   4   6   7   8   3   2          i++;
                 i
                             j
     5   1   4   3   7   8   6   2          交换元素A[i]和A[j];6     3 -> 3      6
                 i
                             j
     5   1   4   3   7   8   6   2          j++;
                 i
                                 j

7.   5   1   4   3   7   8   6   2          2<5;
                 i
                                 j
     5   1   4   3   7   8   6   2          i++;
                     i
                                 j
     5   1   4   3   7   8   6   2          交换元素A[i]和A[j];7     2 -> 2      7
                     i
                                 j
     5   1   4   3   2   8   6   7          j==high;
                     i
                                 j

8.   2   1   4   3   5   8   6   7          j==high;此时跳出循环，交换A[low]和A[i]5     2 -> 2      5,此时即可得出i,返回的i为主元。
                     i
                                 j
*/

int split(int A[],int low,int high)
{
    int i = low , temp;
    int x = A[low];
    for(int j=low+1;j<=high;j++){
        if(A[j]<=x){
            i++;
            if(i!=j){
                temp = A[i];
                A[i] = A[j];
                A[j] = temp;
            }
        }
    }
    temp = A[low];
    A[low] = A[i];
    A[i] = temp;
    return i;
}
void quicksort(int A[],int low,int high)
{
    int w;
    if(low<high){
        w = split(A,low,high);
        quicksort(A,low,w-1);
        quicksort(A,w+1,high);
    }
}
int main()
{
    int A[10];
    for(int i=0;i<10;i++) scanf("%d",&A[i]);
    quicksort(A,0,9);
    for(int i=0;i<10;i++) printf("%d ",A[i]);
    return 0;
}

注释那一段是为了更好的理解划分算法 ，当年第一次接触的时候也有点懵，所以现在总结一下，把每一步划分的过程都写出来了，供大家学习。

程序实现：

可以改变主函数，实现元素个数的输入

int main()
{
    int n;
    printf("输入多少个元素：");
    scanf("%d",&n);
    int A[n];
    for(int i=0;i<n;i++) scanf("%d",&A[i]);
    quicksort(A,0,n-1);
    for(int i=0;i<n;i++) printf("%d ",A[i]);
    return 0;
}

 程序实现：

感谢你能看到这里，希望这篇文章能帮到你！