数据结构之——交换排序

1.交换排序算法实现

这里的交换排序指的是冒泡排序和快速排序，

其中快速排序的过程可以简单的理解为：选取序列首元素为枢轴值（pivot），然后分别从序列尾部找到第一个小于pivot的元素（A），从序列首部找到第一个大于pivot的元素（B），然后交换此A，B两元素，直至首尾遍历的两指针重合，一趟排序结束。

以下是这两算法的具体实现：

#include<iostream>
using namespace std;

//声明打印辅助函数
void printArray(int array[], int length);
//声明冒泡排序函数
void BubbleSort(int array[], int lenght);
//声明分割函数，供快速排序函数调用
int Partition(int array[], int low, int high);
//声明快速排序函数
void QuickSort(int array[], int low, int high);

int main()
{
    int array[] = { 12, 3, 6, 4, 27, 9 };
    int length = sizeof(array) / sizeof(*array);

    cout << "排序前序列为：" << endl;
    printArray(array, length);

    BubbleSort(array, length);
    cout << endl << "冒泡排序后序列为：" << endl;
    printArray(array, length);
    cout << endl;

    QuickSort(array, 0, length - 1);
    cout << endl << "快速排序后序列为：" << endl;
    printArray(array, length);
    cout << endl;

    cout <<endl;
    system("pause");
    return 0;
}

void printArray(int array[], int length)
{
    for (int i = 0; i < length; i++)
    {
        if (i == length - 1)
            cout << array[i];
        else
            cout << array[i] << ",";
    }
}

void BubbleSort(int array[], int lenght)
{
    int tmp;
    //标记是否发生了交换
    bool flag;
    for (int i = 0; i < lenght;i++)
    {
        flag = false;
        for (int j = lenght - 1; j >i; j--)
        {
            if (array[j-1]>array[j])
            {
                tmp = array[j - 1];
                array[j - 1] = array[j];
                array[j] = tmp;
                flag = true;
            }
        }
        //一趟排序未发生交换时，表示已经排序已经完成
        if (flag==false)
        {
            return;
        }
    }
}

int Partition(int array[], int low, int high)
{
    int pivot = array[low];
    while (low<high)
    {
        while (low < high && array[high] >= pivot) high--;
        array[low] = array[high];
        while (low < high && array[low] <= pivot) low++;
        array[high] = array[low];
    }
    array[low] = pivot;
    return low;
}

void QuickSort(int array[], int low, int high)
{
    if (low<high)
    {
        int pivot = Partition(array, low, high);
        QuickSort(array, low, pivot - 1);
        QuickSort(array, pivot + 1, high);
    }
}

2.关于交换排序的一些结论

（1）.为实现快速排序算法，待排序序列宜采用的存储方式为顺序存储。

（2）.就平均性能而言，快速排序是目前最好的内部排序算法，但是当要排序的数据已经基本有序时，不宜使用快速排序算法。

（3）.快速排序过程构成一棵递归树，递归深度即为递归树的深度，当枢轴值每次将序列等分时，递归树的高为log2n；当枢轴值每次都是子表的最大值或者最小值时，此时递归树退化为单链表，树高为n。