交换排序

冒泡基本思想：

  在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

void exchangesort(int a[],int n)//改进版的冒泡
{
    int i=n-1;
    while(i>0)
    {
        int k=0;
        for(int j=0; j<i; j++)
        {
            if(a[j]>a[j+1])
            {
                k=j;
                int temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
            }
        }
        i=k;
    }
}

 传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。

void exchangesort2(int a[],int n)
{
    int low=0;
    int high=n-1;
    while(low<high)
    {
        for(int i=low; i<high; i++)
        {
            if(a[i]>a[i+1])
            {
                int temp=a[i];
                a[i]=a[i+1];
                a[i+1]=temp;
            }
        }
        --high;
        for(int i=high; i>low; i--)
        {
            if(a[i]<a[i-1])
            {
                int tmep=a[i];
                a[i]=a[i-1];
                a[i-1]=a[i];
            }
        }
        ++low;
    }
}

快速排序基本思想
1）选择一个基准元素,通常选择第一个元素或者最后一个元素,

2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。

3）此时基准元素在其排好序后的正确位置

4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。

void swap(int *a,int *b)
{
    int temp=*a;
    *a=*b;
    *b=temp;
}
int partition(int a[],int low,int high)
{
    int sortkey=a[low];//基准元素
    while(low<high)
    {
        while(low<high&&sortkey<=a[high]) --high;//从两端交替像中间扫描，从high像前直至low+1，将比基准元素大的放到高端，小的放到低端
        swap(&a[low],&a[high]);
        while(low<high&&sortkey>=a[low]) ++low;
        swap(&a[low],&a[high]);
    }
    return low;
}
void quicksort(int a[],int low,int high)
{
    if(low<high)
    {
        int sortnum=partition(a,low,high);//将表一分为二
        quicksort(a,low,sortnum-1);//递归操作
        quicksort(a,sortnum+1,high);
    }
}