冒泡排序以及优化

　　最近需要用到冒泡排序，所以翻出来研究一下。冒泡排序的基础其实就是元素交换，是一种极其简单的排序算法。

　　话不多说，直接上代码：

#include <stdio.h>
void bubble_sort(int arr[], int len)
{
    int i, j, temp;
    for(i = 0; i < len - 1; i++)
    {
        for(j = 0; j < len - 1; j++)
        {
            if(arr[j] > arr[j + 1])
            {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}
    
int main () 
{
    int arr[] = {22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70};
    int len = (int)sizeof(arr)/sizeof(arr[0]);
    int i;
    bubble_sort(arr, len);
    for(i = 0; i < len; i++)
    {
        printf("%d ",arr[i]);
    }
    return 0;
}

以上是基础版，下面来讲一下原理。

　　首先初始化一个数组 arr[] = {22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70}  我们需要从小到大对数组元素进行排序，运用最简单的元素交换步骤，比较相邻两个元素的大小，比较后，数值较大的往后移动。由此，两两比较多次后（这是一趟排序），数值最大的元素移动到数组尾部。经过多趟排序之后，数组元素将从小到大排列。

　　但是这样的排序并不是最优选择。因为按照以上的算法，即使后面的数据已经排序完成，还是每一趟都要遍历。以下是优化的算法：

#include <stdio.h>
void bubble_sort(int arr[], int len)
{
    int i, j, temp;
    int swapped = 1;                       //设置交换的标志位
    for(i = 0; i < len - 1; i++)
    {
        swapped = 0;                       
        for(j = 0; j < len - 1 - i; j++)   //减少了需要遍历的次数
        {
            if(arr[j] > arr[j + 1])
            {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = 1;                //如果有数据交换，表示序列还没有完成排序，继续进行循环
            }
        }
        if(swapped == 0)                    //如果没有元素交换，表示序列是顺序状态，退出循环
        {
            j = len - 1;
        }
    }
}
int main () 
{
    int arr[] = {22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70};
    int len = (int)sizeof(arr)/sizeof(*arr);
    int i;
    bubble_sort(arr, len);
    for(i = 0; i < len; i++)
    {
        printf("%d ",arr[i]);
    }
    return 0;
}

 

当然，冒泡排序还有更优化的方法：鸡尾酒排序，这种方法特点是在排序的过程中是双向进行的。程序如下：

#include <stdio.h>

void CockTailSort(int arr[], int len);
void swap(int *a, int *b);

int main () 
{
    int arr[] = {22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70};
    int len = (int)sizeof(arr)/sizeof(*arr);
    int i;
    CockTailSort(arr, len);
    for(i = 0; i < len - 1; i++)
    {
        printf("%d ",arr[i]);
    }
    return 0;
}

void swap(int *a, int *b)   //交换两元素的值  
{  
    int t;  
    t=*a;  
    *a=*b;  
    *b=t;  
}  
  
void CockTailSort(int arr[], int len)
{
    int i, left = 0, right = len - 1;
    int swapped = 1;
    while(swapped)
    {
        swapped = 0;
        for(i = left; i < right; i++)       //向右排序，确认最大元素
        {
            if(arr[i] > arr[i+1])
            {
                swap(&arr[i], &arr[i+1]);
                swapped = 1;
            }
        }
        right--;                            
        for(i = right; i > left; i--)       //向左排序，确认最小元素
        {
            if(arr[i] < arr[i-1])
            {
                swap(&arr[i], &arr[i-1]);
                swapped = 1;
            }
        }
        left++;
    }
}

下图是排序的模式，更直观一点：

 

 冒泡排序，最好的情况是序列已经是正序，时间复杂度为O(n)，最坏的当然是逆序，时间复杂度为O(n^2)，另外冒泡排序需要一个空间作为数据交换的临时存储单元，因此空间复杂度为O(1)。