交换排序 / 快速排序

1. 冒泡排序

---

时间复杂度： 最好 $O(n)$，最坏和平均都是 $O(n^2)$，注意平均时间复杂度的理解。
空间复杂度： $O(1)$
稳定性： 稳定的
时间复杂度的理解可借鉴：
http://www.cnblogs.com/jiqingwu/p/bubble_sort_analysis.html
改进后算法的平均时间复杂度：$O(n^2)$
外层循环最多执行$(n-1)$次，最少执行1次，平均$n/2$次；内层循环也是最多执行$(n-1)$次，最少执行1次，平均$n/2$次；因此，整个算法的平均时间复杂度为$(n/2\ast n/2)$，即$O(n^2)$.

代码：

#include <iostream>
#include <stdio.h>
using namespace std;

int main()
{
    int n=6;
    int a[n];
    bool change=false;
    for(int i=0;i<n;i++)
        scanf("%d",&a[i]);
    for(int i=n-1;i>0;i--)
    {
        change=false;
        for(int j=0;j+1<=i;j++)
        {
            if(a[j]>a[j+1])
            {
                int b=a[j];
                a[j]=a[j+1];
                a[j+1]=b;
                change=true;
            }
        }
        if(!change)
            break;
    }
    for(int i=0;i<n;i++)
        printf("%d ",a[i]);
    printf("\n");
    return 0;
}

2. 快速排序

---

时间复杂度： 最好：$O(nlogn)$；最坏：$O(n^2)$—有序或基本有序，退化为冒泡排序；平均：$knlnn$，k为某个常数，在所有同数量级的排序方法中，快速排序的常数因子k最小，平均性能最好。
空间复杂度： 最好：$O(logn)$；最坏：$O(n)$
稳定性： 不稳定
Note： 快速排序在最好每次划分能得到2个长度相等的子文件时最易发挥其特长。

代码：

#include <iostream>
#include <stdio.h>
using namespace std;

int oneSort(int s[],int low,int high)
{
    s[0]=s[low]; //low位置作为支点
    while(low<high)
    {
        while(low<high&&s[0]<=s[high])
            high--;
        s[low]=s[high];
        while(low<high&&s[0]>=s[low])
            low++;
        s[high]=s[low];
    }
    s[low]=s[0];
    return low;
}
void QuickSort(int s[],int low,int high)
{
    if(low<high)
    {
        int middle=oneSort(s,low,high);
        QuickSort(s,low,middle-1);
        QuickSort(s,middle+1,high);
    }
}
int main()
{
    int high=6;
    int mS[high+1];
    for(int i=1;i<=high;i++)
        scanf("%d",&mS[i]);
    QuickSort(mS,1,high);
    for(int i=1;i<=high;i++)
        printf("%d ",mS[i]);
    printf("\n");
    return 0;
}