冒泡排序

基本思想

• 是一种两两比较、交换的交换排序算法
• 对于长度为 n 的序列，第 i 趟操作流程为：从序列最左边开始，比较第1个和第2个，如果不满足排序要求，则进行交换，交换后，再比较第2和第3个，如果不满足排序要求，则进行交换，一直如此比较下去，直到比较完第 n - i 和 n - i +1个数据，则该趟全部比较完成。

实例分析

• 以序列{12，34，20，15，9，25，27，13}为例，第1趟和第2趟交换过程如下
  
• 根据以上过程，可得到以下推论
  

代码实现（c语言）

//冒泡排序---非递减 
void Bubble_Sort(DataType arr[], int len)
{
    DataType temp;
    for (int i = 1; i < len; i++)
    {
        for (int j = 0; j < len - i; j++)
        {
            //若希望序列排序后为递减，则修改为arr[j] < arr[j + 1]
            if (arr[j] > arr[j + 1])
            {
                temp = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

性能分析

代码测试（c语言）

#include <stdio.h>

typedef char DataType;

//冒泡排序---非递减 
void Bubble_Sort(DataType arr[], int len)
{
    DataType temp;
    for (int i = 1; i < len; i++)
    {
        for (int j = 0; j < len - i; j++)
        {
            //若希望序列排序后为递减，则修改为arr[j] < arr[j + 1]
            if (arr[j] > arr[j + 1])
            {
                temp = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

int main()
{
    //序列
	DataType arr[] = {'c', 'a', 'd', 'b', 'f', 's',
                      'h', 'u', 'q', 'w', 'e', 'r',
                      't', 'y', 'i', 'o', 'p', 'g',
                      'j', 'k', 'l', 'z', 'x', 'v',
                      'n', 'm'};
    //序列长度
    int len = sizeof(arr) / sizeof(DataType);
    //冒泡排序
    Bubble_Sort(arr, len);
    //遍历排序后的序列
    for (int i = 0; i < len; i++)
    {
        printf("%c\n", arr[i]);
    }

	return 0;
}

算法改进

• 优化背景：假如某个序列初始时最后面若干个记录已符合排序规则，例如，{23,15,14,25,28,30}序列，若按常规的冒泡排序，后边有序部分{25,28,30}每一趟都需进行比较，增加了排序时间。

• 算法分析

  1. 设置一个标志位LastExchangeIndex，默认为 1，用于标志上一次交换的位置；设置一个指针 i ，用于标识序列的最后一个位置，初始为序列长度；设置一个指针 j ，用于标识交换的位置，默认从1开始
  2. 对序列相邻的两个元素进行判断，若符合排序要求，交换并修改标志位，指针 j 后移，若不符合，指针 j 后移。
  3. 当 j 移动序列最后一位或上一次交换的位置时，该趟比较交换完成并将指针 i 置为上一次交换的位置，用于表示序列的新长度
  4. 重复1、2、3步骤，直到 i 为 1 时，序列排序完成

• 实例分析

  • {23,15,14,25,28,30}序列排序过程如下
    

• 代码实现（c语言）

void Bubble_Modified_Sort(int arr[], int len)
{
    int LastExchangeIndex;
    int i = len;
    int temp;

    while (i > 1)
    {
        LastExchangeIndex = 1;
		//从数组下标1开始
        for (int j = 1; j < i; j++)
        {
            if (arr[j] < arr[j - 1])
            {
                temp = arr[j - 1];
                arr[j - 1] = arr[j];
                arr[j] = temp;
                LastExchangeIndex = j;
            }
        }

        i = LastExchangeIndex;
    }
}

• 代码测试（c语言）

#include <stdio.h>

void Bubble_Modified_Sort(int arr[], int len)
{
    int LastExchangeIndex;
    int i = len;
    int temp;

    while (i > 1)
    {
        LastExchangeIndex = 1;

        for (int j = 1; j < i; j++)
        {
            if (arr[j] < arr[j - 1])
            {
                temp = arr[j - 1];
                arr[j - 1] = arr[j];
                arr[j] = temp;
                LastExchangeIndex = j;
            }
        }

        i = LastExchangeIndex;
    }
}

int main()
{
    int arr[] = {23,15,14,25,28,30}; 
	
	int len = sizeof(arr) / sizeof(int);
	
    Bubble_Modified_Sort(arr, len);
   
    for (int i = 0; i < 6; i++)
    {
        printf("%d\n", arr[i]);
    }

	return 0;
}

资料参考

1. 《数据结构与算法》北京大学出版社 2018年版 林劼 刘震 陈端兵 戴波 著