数据结构的故事之交换排序

　　交换排序，顾名思义，肯定是通过两个数或者几个数之间的比较和交换来达到排序的目的。基于交换的排序主要有冒泡排序和快速排序。

1、冒泡排序

通过两两之间的比较和交换，每次冒出一个最大的记录（升序）或者最小的记录（降序）。

void bubbleSort(int arr[],int n){
    int outer,inner;
    for(outer=1;outer<=n;outer++){
        for(inner=1;inner<=n-outer;inner++){
            if(arr[inner+1]<arr[inner]){
                arr[0] = arr[inner];
                arr[inner] = arr[inner+1];
                arr[inner+1] = arr[0];
            }
        }
    }
}

上述为常规的冒泡排序，但是如果最后面若干记录未发生交换，也就是后面的几个记录已经有序了，对于常规的冒泡排序，无论怎样都会进行冒泡，自然就增加了排序的时间。所以可对上述常规冒泡排序进行改进。如下：我们用一个exchangeIndex来记录每次交换的最后位置。

void bubbleSortModified(int arr[],int n){
    int outer,inner;
    int exchangeIndex = n;
    int exchange;
    while(exchangeIndex>1){
        exchange = 1;
        for(inner=1;inner<=exchangeIndex;inner++){
            if(arr[inner+1]<arr[inner]){
                arr[0] = arr[inner];
                arr[inner] = arr[inner+1];
                arr[inner+1] = arr[0];
                exchange = inner;
            }
        }
        exchangeIndex = exchange;
    }
}

2、快速排序

　　快速排序:以序列中的某个记录为基准，把整个序列分成左右两组，左边序列小于基准，右边序列大于基准。然后对左右序列又选一个基准划分，依次下去直到左右序列的记录数为0。

int _quickSort(int arr[],int begin,int end){
    arr[0] = arr[begin];
    while(begin < end){
        while(begin<end && arr[end]>arr[0])
          end --;
        if(begin<end)
          arr[begin] = arr[end],arr[end] = arr[0],begin ++;
        else
          return begin;
        while(begin<end && arr[begin]<arr[0])
          begin ++;
        if(begin<end)
          arr[end] = arr[begin],arr[begin] = arr[0],end --;
        else
          return end;
    }
}

void quickSort(int arr[],int begin,int end){
    int middle;
    if(begin < end){
        middle = _quickSort(arr,begin,end);
        quickSort(arr,begin,middle-1);
        quickSort(arr,middle+1,end);
    }
}

3、总结

冒泡排序：时间复杂度o(n²)，是稳定的排序算法。

快速排序：时间复杂度o(nlog₂n)，是不稳定的排序算法，所有排序算法中平均性能最好。

但是如果待排序序列本来就有序或者基本有序了，快速排序的性能会变得很差，它就退化成了冒泡排序，时间复杂度为o(n²)。所以快速排序适合那些随机序列的排序。