交换排序算法

数据结构课程中的两种简单的交换排序算法（冒泡排序，快速排序）。

交换排序算法的思想：两两比较待排序的关键字，并交换不满足次序要求的偶对，直到全部满足为止。（结合实践理解思想，思想不是用来记忆的）

1、冒泡排序

思想：对于给定的一个关键字序列a[0,1,2...n]，从第一个位置的元素a[0]开始，一路遍历一路两两比较，把不满足次序要求的偶对交换过来，这样一趟下来便会将最大值定位于最后位置a[n-1]；相同的思路，定位a[n-2];以此类推，最后将元素全部归位，排序结束。

算法：对一个数组进行排序的冒泡排序算法如下：

<span style="font-size:14px;">//冒泡排序
void BubbleSort(int a[],int n)
{
        int i,j,temp,tag;
        for(i=1;i<n;i++)//比较n-1次
        {
                tag=0;
                for(j=0;j<n-i;j++)
                        if(a[j]>a[j+1])
                        {
                                temp=a[j];
                                a[j]=a[j+1];
                                a[j+1]=temp;
                                tag=1;
                        }
                if(tag==0)   break;
        }
}
</span>

总结：冒泡排序相关性能如下表，当初始数据序列为正序时，效率最高；反序时效率最低。

2、快速排序

思想：对于给定的一个关键字序列，一般取第一个元素为基准（也可以去中间元素为基准），然后将其他元素中大于基准的元素全部排在基准右侧，而小于基准的元素排在基准左侧，这样将基准元素归位；用同样的方法递归处理基准左侧和右侧元素，最后排序结束。具体做法结合算法理解，将算法读懂之后理解思想。

算法：对一个一维数组进行快速排序：

<span style="font-size:14px;">//快速排序
void QuickSort(int a[],int low,int high)
{
        int i=low,j=high,temp;
        if(low<high)
        {
                temp=a[low];//以第一个元素作为基准
                while(i!=j)//左右两个指示器（先右后左）
                {
                        while(j>i&&a[j]>temp)
                                j--;
                        a[i]=a[j];
                        while(i<j&&a[i]<temp)
                                i++;
                        a[j]=a[i];

                }
                a[i]=temp;//归位一个元素
                QuickSort(a,low,i-1);//递归处理左侧元素
                QuickSort(a,i+1,high);//递归处理右侧元素
        }

}</span>

总结：当数据越是随机分布时，快速排序算法的性能越好；当数据越接近有序时，快速排序算法的性能最差。

最后关于算法的测试：

/*交换排序算法*/
#include <iostream>
using namespace std;

//冒泡排序
void BubbleSort(int a[],int n)
{
        int i,j,temp,tag;
        for(i=1;i<n;i++)//比较n-1次
        {
                tag=0;
                for(j=0;j<n-i;j++)
                        if(a[j]>a[j+1])
                        {
                                temp=a[j];
                                a[j]=a[j+1];
                                a[j+1]=temp;
                                tag=1;
                        }
                if(tag==0)   break;
        }
}

//快速排序
void QuickSort(int a[],int low,int high)
{
        int i=low,j=high,temp;
        if(low<high)
        {
                temp=a[low];//以第一个元素作为基准
                while(i!=j)//左右两个指示器（先右后左）
                {
                        while(j>i&&a[j]>temp)
                                j--;
                        a[i]=a[j];
                        while(i<j&&a[i]<temp)
                                i++;
                        a[j]=a[i];

                }
                a[i]=temp;//归位一个元素
                QuickSort(a,low,i-1);//递归处理左侧元素
                QuickSort(a,i+1,high);//递归处理右侧元素
        }

}

//测试函数
int main()
{
        int a[10]={144,232,111,678,329,834,123,230,567,431};
        cout<<"排序之前的数组元素为：";
        for(int i=0;i<10;i++)
                cout<<a[i]<<"  ";
        cout<<endl;

        //BubbleSort(a,10);
        QuickSort(a,0,9);

        cout<<"排序之后的数组元素为：";
        for(int i=0;i<10;i++)
                cout<<a[i]<<"  ";
        cout<<endl;

}

运行结果为：