内部排序（2）——交换类排序

交换类排序

一、冒泡排序

void BubbleSort(int a[], int len)//冒泡排序 {    int i = 0, j = 0;    bool flag = 0;    for(i = 1; i<= len; i++)  //趟数秩序冒泡len-1趟就可全部排完     {        for(j = 0; j<= len-i; j++)   //每排一趟就有一个数放到正确的位置不需在参与排序         {            if(a[j] > a[j+1])            {                flag = 1;                a[0] = a[j];                a[j] = a[j+1];                a[j+1] = a[0];            }        }        if(!flag)   //若经过一趟排序，没有元素交换位置则不必在进行排序         {            return;        }    }}

算法分析：


　　时间：O(n2)
　　通常认为冒泡是比较差的，可以加些改进，比如在一趟中无数据的交换，则结束等措施。因此此处我采用了标志法改进了冒泡算法，假如在一趟交换中没有任何元素位置发生交换，则排序结束。

---

二、快速排序

void QuickSort(int a[], int left, int right)//快速排序 {    if(right <= left)    {        return;    }    int i = left;    int j = right;    a[0] = a[left];    while(i<j)    {        while(a[j] >= a[0] && i<j)         /*一定要j先走，因为我们在j=i时将表的第一个数与地i个数交换，故要先找到比隔板小的而不是先找到比隔板（支点）大的； */        {            j--;        }        while(a[i] <= a[0] && i<j)         {            i++;        }        if(i < j)        {            int tmp = a[i];            a[i] = a[j];            a[j] = tmp;        }        else        {                   a[left] = a[i];            a[i] = a[0];        }     }    if(i-1 > left)    {        QuickSort(a,left,i-1);      //若隔板左边小于等于一个元素则不必在排     }    if(i+1 < right)    {        QuickSort(a,i+1,right);    //若隔板左边小于等于一个元素则不必在排     }} 

算法分析：
核心思想：取数组的首元素作为支点（有的书上从中间取，效率要高，核心思想都是一样的，在这里我就为了方便起见取首元素作为支点。），然后在其余元素组成的数组中设置两个指针ｌ，ｒ；分别位于数组最左边和最右边。

让右边指针先走 （很重要，原因看代码中的注释），找到一个小于支点的元素。再让左边走，找到一个大于支点的元素。判断ｌ，ｒ是否重合。若重合则交换该位置与数组首位置的值；若不重合，交换ｌ，ｒ位置的值。并且以该位置为分界点，分别递归处理支点左右两侧的数组，最后完成整个排序。

*A)时间复杂度

最好情况（每次支点总是在中间）T(n)=O(nlog2n)
平均 T(n)=O(nlog2n)
最坏情况（数据已是递增或递减）T(n)=O(n²)

*B)空间复杂度：需栈空间以实现递归

最坏情况：S(n)=O(n)
一般情况：S(n)=O(log2n)

---

三、整体实现

#include<iostream>using namespace std;void BubbleSort(int a[], int len)//冒泡排序 {    int i = 0, j = 0;    bool flag = 0;    for(i = 1; i<= len; i++)  //趟数秩序冒泡len-1趟就可全部排完     {        for(j = 0; j<= len-i; j++)   //每排一趟就有一个数放到正确的位置不需在参与排序         {            if(a[j] > a[j+1])            {                flag = 1;                a[0] = a[j];                a[j] = a[j+1];                a[j+1] = a[0];            }        }        if(!flag)   //若经过一趟排序，没有元素交换位置则不必在进行排序         {            return;        }    }}void QuickSort(int a[], int left, int right)//快速排序 {    if(right <= left)    {        return;    }    int i = left;    int j = right;    a[0] = a[left];    while(i<j)    {        while(a[j] >= a[0] && i<j) //一定要j先走，因为我们在j=i时将表的第一个数与地i个数交换，故要先找到比隔板小的而不是先找到比隔板（支点）大的；         {            j--;        }        while(a[i] <= a[0] && i<j)         {            i++;        }        if(i < j)        {            int tmp = a[i];            a[i] = a[j];            a[j] = tmp;        }        else        {                   a[left] = a[i];            a[i] = a[0];        }     }    if(i-1 > left)    {        QuickSort(a,left,i-1);      //若隔板左边元素个数小于等于一则不必在排     }    if(i+1 < right)    {        QuickSort(a,i+1,right);    ////若隔板右边元素个数小于等于一则不必在排     }} void PrintArry(int a[],int len) //打印数组0号位置设为监视哨 {    int i = 0;    for(i = 1; i<=len; ++i)    {        cout<<a[i]<<"  ";    }    cout<<endl;}int main(){    int a[] = {0,17,21,31,31,58,45,96,83,69};    //BubbleSort(a,9);    PrintArry(a,9);    QuickSort(a,1,9);    PrintArry(a,9);    return 0;}

---

总结：

以上就是内部排序家族中交换类排序的两种典型算法。