Day1——冒泡排序

冒泡排序

学会冒泡排序算法

文章参考：https://stackabuse.com/bubble-sort-in-python/

作业：写出冒泡的代码，并上传到知识星球里，详见下面介绍。

冒泡排序（Bubble Sort）是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

算法步骤

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

例子

有5个数组成一个无序数列：5，3，2，1，7，希望从小到大排序。按照冒泡排序的思想，我们要把相邻的元素两两比较，根据大小来交换元素的位置，过程如下：

（第一轮）

首先比较5和3，——>3，5，2，1，7

比较5和2，——>3，2，5，1，7

比较5和1，——>3，2，1，5，7

比较5和7，——>3，2，1，5，7

（第二轮）

比较3和2，——>2，3，1，5，7

比较3和1，——>2，1，3，5，7

比较3和5，——>2，1，3，5，7

（第三轮）

比较2和1，——>1，2，3，5，7

比较2和3，——>1，2，3，5，7

（第四轮）

比较1和2，——>1，2，3，5，7

（第五轮）

1，2，3，5，7

原始的冒泡排序是稳定排序。由于该排序算法的每一轮要遍历所有元素，轮转的次数和元素数量相当，所以时间复杂度是O（N^2） 。

代码

void sort(int array[])
{
    int tmp = 0;
    for(int i = 0; i < array.length; i++)
    {
        for(int j = 0; j < array.length-i-1; j++)
        {
            if(array[j] > array[j+1])
            {
                tem = array[j];
                array[j] = array[j+1];
                array[j+1] = tem;
            }
        }
    }
}

（1）优化一——设置早停标志

我们仔细观察一下上面的例子，当排序到第三轮结束时，数组已经是有序的了。这种情况下，如果我们能判断出数组已经有序了，做个标记，那么剩下的就不必再执行了，岂不快哉。

void sort(int array[])
{
    int tmp = 0;
    for(int i = 0; i < array.length; i++)
    {
        bool isSorted = true; // 标记，每一轮初始都是true
        for(int j = 0; j < array.length-i-1; j++)
        {
            
            if(array[j] > array[j+1])
            {
                tem = array[j];
                array[j] = array[j+1];
                array[j+1] = tem;
                isSorted = false; // 有元素交换，就置为false
            }
        }
        if(isSorted)
        {
            break; // 有序，就停止排序
        }
    }
}

（2）优化二——对数列有序区的界定

例如序列[3，1，6，2，5，7，8，9]，后半部分已经是有序的，可我们的算法每一轮还是对它们进行比较，白比较了许多次，那么我们就需做一个有序区的界定来进行优化。

如何避免这种情况呢？我们可以在每一轮排序的最后，记录下最后一次元素交换的位置，那个位置也就是无序数列的边界，再往后就是有序区了。

void sort(int array[])
{
    int tmp = 0;
    int lastIndex = 0; // 最后一次实行交换的位置
    int border = array.length-1; // 无序序列的边界
    for(int i = 0; i < array.length; i++)
    {
        bool isSorted = true; // 标记，每一轮初始都是true
        for(int j = 0; j < border; j++)
        {            
            if(array[j] > array[j+1])
            {
                tem = array[j];
                array[j] = array[j+1];
                array[j+1] = tem;
                isSorted = false; // 有元素交换，就置为false
                lastIndex = j;
            }
        }
        border = lastIndex;
        if(isSorted)
        {
            break; // 有序，就停止排序
        }
    }
}