起泡排序/快速排序

void BubbleSort(int * obj, int n)
{   int bound;
    int exchange = n-1 ;
    while(exchange != 0 )
    {   //bound此次比较的边界
        bound = exchange;
        //exchange混乱区域下标
        exchange = 0;
        for(int j=0 ;j <bound ;++j)
        {
            if( obj[j] > obj[j+1])
            {
                int tem = obj[j];
                obj[j]=obj[j+1];
                obj[j+1]=tem;
                exchange = j;
            }
        }

    }
}

需要排序的区域，自己写的时候是每次-1，看了书才发现调换位置的下标表示不保证顺序，所以可以优化。
时间复杂度 最优是O(n）也就是数组一开始就是正序，只要遍历一次也就是n-1；
最差是O（n2） ，数组完全逆序。

快速排序

void swap(int * p ,int i , int j )
{
    int tem = p[i];
    p[i] = p[j];
    p[j]=tem;
}
int Partition(int * r ,int first, int end)
{
    int lptr =first;
    int rptr = end;
    int flag = first;
    while(flag != rptr)
    {
        while(rptr != flag)
        {
            if(r[flag]>r[rptr])
            {
                swap(r,flag,rptr);
                flag =rptr;
                continue;
            }
            rptr--;
        }
        while(lptr != flag)
        {
            if( r[lptr] >r[flag])
            {
                swap(r,lptr, flag);
                flag = lptr;
                continue;
            }
            ++lptr;
        }
    }
    return flag;

}

void QuickSort(int * r , int first , int end)
{   int pivot ;
    if(first <end)
    {
        pivot =  Partition( r , first,  end);
         QuickSort(r,first,pivot-1);
          QuickSort(r,pivot+1,end);
    }
}

快排是起泡排序的改进；