冒泡排序和冒泡的优化

冒泡排序

冒泡排序是一种基础的交换排序算法。就好像水里的有小气泡一样，小气泡一点点的向上浮动，在浮动的过程中气泡越来越大，到达水面时事他最大的时候，然后就砰地一声没了。

冒泡也是如此，元素有数组一侧一点点的向另一侧移动。

现在来

数组

int[] sort={10，3，6，2，8}

我们希望能够从小到大排序，冒泡的思想就是相邻两个数进行大小比较，来交换元素位置

首先我们先让 sort[0]10 &sort[1] 3 比较，sort[0] 10 

互换后数组

3，10，6，2，8

然后让sort[1]10 & sort[2]6比较，sort[1]10 > sort[2]6。前后互换

互换后数组

3，6，10，2，8

接下来是sort[2] & sort[3]比较

互换后数组

2，6，2，10，8

接下来是sort[3] & sort[4]比较

互换后数组

3，6，2，8，10

就这样最大数10被排到了来最后

下面来进行第二回比较

sort[0]和sort[1]比较

3，6，2，8，10

sort[1]和sort[2]比较

3，2，6，8，10

sort[2]和sort[3]比较

3，2，6，8，10

因为第一轮sort[4]10已被选出最大所以不于sort[4]10比较

如此第二轮sort[3]8被选出了为除sort[4]10以外的最大值所以

第三回比较

sort[0]和sort[1]比较

2，3，6，8，10

sort[1]和sort[2]比较

2，3，6，8，10

sort[2]6被选出

第四回比较

sort[0]和sort[1]比较

2，3，6，8，10

到此冒泡以排好，这就是冒泡的整体思路

下面来看一下代码

第一版代码

public class BubbleSort
{
    private static void sort(int array[])
    {
        int tmp = 0;


        for (int i = 0; i < array.length-1; i++)
        {

            for
            (int j = 0; j < array.length - i - 1; j++)
            {

                if (array[j] > array[j + 1])
                {
                    tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                }
            }
        }
    }

    public static void main()
    {
        int[] array = new int[]{10,3,6,2,8};
        sort(array);

        System.out.println(Arrays.toString(array));
    }
}

使用双循环来进行排序。外部循环控制所有的回合，内部循环代表每一轮的冒泡处理，先进行元素比较，再进行元素交换。

这就是一个标准的冒泡排序

冒泡优化一

但我们可以看到在第三回比较时代码已经有序

第三回比较

sort[0]和sort[1]比较

2，3，6，8，10

sort[1]和sort[2]比较

2，3，6，8，10

sort[2]6被选出

第四回比较

sort[0]和sort[1]比较

2，3，6，8，10

可是代码还是继续执行，无效比较了三次，其实可以在代码已经有序时让其结束排序。

第二版代码

class BubbleSort
{
    private static void sort(int array[])
    {
        int tmp = 0;

        for (int i = 0; i < array.length-1; i++)
        {
            //有序标记，每一轮的初始是true
            boolean isSorted = true;
            for
            (int j = 0
             ; j < array.length - i - 1; j++)
            {
                if (array[j] > array[j + 1])
                {
                    tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;

//有元素交换，所以不是有序，标记变为false
                    isSorted = false;
                }
            }
            if
            (isSorted)
            {
                break;
            }
        }
    }

    public static void main(String[] args)
    {
        int[] array = new int[]{10,3,6,2,8};
        sort(array);
        System.out.println(Arrays.toString(array));
    }
}

这一版代码做了小小的改动，利用布尔变量isSorted作为标记。如果在本轮排序中，元素有交换，则说明数列无序；如果没有元素交换，说明数列已然有序，直接跳出大循环。

这样可以避免数据有序后在进行无效循环操作

本文章转自https://mp.weixin.qq.com/s/05TUWmBcq4ZoX3o0EEk38w

ps次文章中还有一种优化方法但感觉限制太多就不写了有兴趣的自己看吧！