快速排序（quicksort)

    快排一种非常常用的算法，采用分治思想，不需要辅助空间。

思路：
1. 随意找一个元素，一般选择首元素，以其为基准。
2. 从序列两头遍历这个序列，将比基准小的元素排在左侧，大的排右侧。
3. 对基准左侧和右侧的两个子序列，重复前两步，直到将序列分割成一个元素。

代码：

void quicksort(int *num,int low,int hi)
{
    int i = low,j = hi;
    int key = num[i];//挖坑

    if(low>=hi)
        return;
    while(i<j)
    {
        while(i<j&&num[j]>=key)
        {
            j--;
        }
        if(j>i)
        {
          num[i] = num[j];
          i++;
        }
        else
            break;
        while(i<j&&num[i]<key)
        {
            i++;
        }
        if(i<j)
        {
            num[j] = num[i];
            j--;
        }
        else
            break;
    }
    num[i] = key;
    quicksort(num,low,i-1);
    quicksort(num,i+1,hi);
}

快排的缺点是缺乏稳定性。unstable

之后又写了一下快排，上面那一个写的我浑身不自在，其实可以很自然地理解一下，快排是分治的思想，不断找基准，然后通过循环，而且循环遍历时（若基准默认为最左边元素）一定是先从右边，再从左边开始的，之所以想到快排，是因为在冒泡中必须要两两比较，两两对换，这确实很白痴，做了许多无用的判断，浪费不少。
代码：

void quicksort(int left,int right)
{
    if(right<=left)
    {
        return;
    }
    int i,j;
    i = left;
    j = right;

    int temp = num[left];

    while(i!=j)
    {
        while(num[j]>=temp&&i<j)
        {
            j--;
        }
        while(num[i]<=temp&&i<j)
        {
            i++;
        }
        if(i!=j)
        {
            int t = num[i];
            num[i] = num[j];
            num[j] = t;
        }
    }
    num[left] = num[i];
    num[i] = temp;

    quicksort(left,i-1);
    quicksort(i+1,right);
}

而在交换中，可以发现两元素之间发生交换的条件是有可能影响相同元素之间的排序的。it’s unstable