内部排序（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;
}

---

总结：

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