冒泡排序及其代码改进

其他 2018-12-14 19:57:47 阅读次数: 0

冒泡排序及其代码改进

什么是冒泡排序

冒泡排序的英文Bubble Sort，是一种最基础的交换排序。

大家一定都喝过汽水，汽水中常常有许多小小的气泡，哗啦哗啦飘到上面来。这是因为组成小气泡的二氧化碳比水要轻，所以小气泡可以一点一点向上浮动。
在这里插入图片描述
而我们的冒泡排序之所以叫做冒泡排序，正是因为这种排序算法的每一个元素都可以像小气泡一样，根据自身大小，一点一点向着数组的一侧移动。
具体如何来移动呢？让我们来看一个栗子：
在这里插入图片描述
有8个数组成一个无序数列：5，8，6，3，9，2，1，7，希望从小到大排序。
按照冒泡排序的思想，我们要把相邻的元素两两比较，根据大小来交换元素的位置，过程如下：
首先让5和8比较，发现5比8要小，因此元素位置不变。
接下来让8和6比较，发现8比6要大，所以8和6交换位置。
在这里插入图片描述
在这里插入图片描述
继续让8和3比较，发现8比3要大，所以8和3交换位置。
在这里插入图片描述
在这里插入图片描述
继续让8和9比较，发现8比9要小，所以元素位置不变
接下来让9和2比较，发现9比2要大，所以9和2交换位置。
在这里插入图片描述
在这里插入图片描述
接下来让9和1比较，发现9比1要大，所以9和1交换位置。
在这里插入图片描述
在这里插入图片描述
最后让9和7比较，发现9比7要大，所以9和7交换位置。
在这里插入图片描述
在这里插入图片描述
这样一来，元素9作为数列的最大元素，就像是汽水里的小气泡一样漂啊漂，漂到了最右侧。
这时候，我们的冒泡排序的第一轮结束了。数列最右侧的元素9可以认为是一个有序区域，有序区域目前只有一个元素。
下面，让我们来进行第二轮排序：
首先让5和6比较，发现5比6要小，因此元素位置不变。
接下来让6和3比较，发现6比3要大，所以6和3交换位置。
在这里插入图片描述
在这里插入图片描述
继续让6和8比较，发现6比8要小，因此元素位置不变。
接下来让8和2比较，发现8比2要大，所以8和2交换位置。
在这里插入图片描述
在这里插入图片描述
接下来让8和1比较，发现8比1要大，所以8和1交换位置
在这里插入图片描述
在这里插入图片描述
继续让8和7比较，发现8比7要大，所以8和7交换位置。
在这里插入图片描述
在这里插入图片描述
第二轮排序结束后，我们数列右侧的有序区有了两个元素，顺序如下：
在这里插入图片描述
至于后续的交换细节，我们这里就不详细描述了，第三轮过后的状态如下：
在这里插入图片描述
第四轮过后状态如下：
在这里插入图片描述
第五轮过后状态如下：
在这里插入图片描述
第六轮过后状态如下：
在这里插入图片描述
第七轮过后状态如下（已经是有序了，所以没有改变）：
在这里插入图片描述
第八轮过后状态如下（同样没有改变）：
在这里插入图片描述
到此为止，所有元素都是有序的了，这就是冒泡排序的整体思路
原始的冒泡排序是稳定排序。由于该排序算法的每一轮要遍历所有元素，轮转的次数和元素数量相当，所以时间复杂度是 O （ N 2 ） O（N^2） 。

传统的冒泡排序实现

 /**
     *@description 传统的冒泡排序
     *@author SongHongWei
     *@params
     *@time 2018/9/26-17:40
     **/
    public List<Integer> bubbleSort(List<Integer> sort)
    {
            int count = 0;
        int size = sort.size();
        for (int i = 0; i < sort.size(); i++)
        {
            for (int j = 0; j < size - 1; j++)
            {
                int pre = sort.get(j);
                int next = sort.get(j + 1);
                if (pre > next)
                {
                    sort.set(j, next);
                    sort.set(j + 1, pre);
                }
                count++;
            }
            System.out.println("第" + i + "轮排序结果" + sort.toString());
        }
        System.out.println(count);
        return sort;
    }

  /**
     *@description 稍微改进后的, 循环次数降低了一半
     *@author SongHongWei
     *@params
     *@time 2018/9/27-14:51
     **/
    public List<Integer> bubbleSortHalf(List<Integer> sort)
    {
            int count = 0;
        int size = sort.size();
        for (int i = 0; i < sort.size(); i++)
        {
            for (int j = 0; j < size - i - 1; j++)
            {
                int pre = sort.get(j);
                int next = sort.get(j + 1);
                if (pre > next)
                {
                    sort.set(j, next);
                    sort.set(j + 1, pre);
                }
                count++;
            }
            System.out.println("第" + i + "轮排序结果" + sort.toString());
        }
        System.out.println(count);
        return sort;
    }

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

冒泡排序的优化

原始的冒泡排序有哪些优化点呢？
让我们回顾一下刚才描述的排序细节，仍然以5，8，6，3，9，2，1，7这个数列为例，当排序算法分别执行到第六、第七、第八轮的时候，数列状态如下：
在这里插入图片描述
很明显可以看出，自从经过第六轮排序，整个数列已然是有序的了。可是我们的排序算法仍然“兢兢业业”地继续执行第七轮、第八轮。
这种情况下，如果我们能判断出数列已经有序，并且做出标记，剩下的几轮排序就可以不必执行，提早结束工作。
优化后的代码

/**
     *@description 这一版代码做了小小的改动，利用布尔变量isSorted作为标记。如果在本轮排序中，元素有交换，则说明数列无序；如果没有元素交换，说明数列已然有序，直接跳出大循环。
     *@author SongHongWei
     *@params
     *@time 2018/9/27-14:51
     **/
    public List<Integer> bubbleSortOptimize(List<Integer> sort)
    {
          int count = 0;
        int size = sort.size();
        for (int i = 0; i < sort.size(); i++)
        {
            //有序标记，每一轮的初始是true
            boolean isSorted = true;
            for (int j = 0; j < size - 1; j++)
            {
                int pre = sort.get(j);
                int next = sort.get(j + 1);
                if (pre > next)
                {
                    sort.set(j, next);
                    sort.set(j + 1, pre);
                    isSorted = false;
                }
                count++;
            }
            if (isSorted)
            {
                break;
            }
            size--;
            System.out.println("第" + i + "轮排序结果" + sort.toString());

        }
        System.out.println(count);
        return sort;
    }

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

冒泡排序的性能提升

为了说明问题，咱们这次找一个新的数列：
在这里插入图片描述
这个数列的特点是前半部分（3，4，2，1）无序，后半部分（5，6，7，8）升序，并且后半部分的元素已经是数列最大值。
让我们按照冒泡排序的思路来进行排序，看一看具体效果：
第一轮
元素3和4比较，发现3小于4，所以位置不变。
元素4和2比较，发现4大于2，所以4和2交换。
在这里插入图片描述
在这里插入图片描述
元素4和1比较，发现4大于1，所以4和1交换
在这里插入图片描述
在这里插入图片描述
元素4和5比较，发现4小于5，所以位置不变。
元素5和6比较，发现5小于6，所以位置不变。
元素6和7比较，发现6小于7，所以位置不变。
元素7和8比较，发现7小于8，所以位置不变。
第一轮结束，数列有序区包含一个元素：
在这里插入图片描述
第二轮
元素3和2比较，发现3大于2，所以3和2交换
在这里插入图片描述
在这里插入图片描述
元素3和1比较，发现3大于1，所以3和1交换。
在这里插入图片描述

在这里插入图片描述

元素3和4比较，发现3小于4，所以位置不变。
元素4和5比较，发现4小于5，所以位置不变。
元素5和6比较，发现5小于6，所以位置不变。
元素6和7比较，发现6小于7，所以位置不变。
元素7和8比较，发现7小于8，所以位置不变。
第二轮结束，数列有序区包含一个元素：
在这里插入图片描述

这个问题的关键点在哪里呢？关键在于对数列有序区的界定。

按照现有的逻辑，有序区的长度和排序的轮数是相等的。比如第一轮排序过后的有序区长度是1，第二轮排序过后的有序区长度是2 …

实际上，数列真正的有序区可能会大于这个长度，比如例子中仅仅第二轮，后面5个元素实际都已经属于有序区。因此后面的许多次元素比较是没有意义的。

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

 /**
     *@description 这一版代码中，sortBorder就是无序数列的边界。每一轮排序过程中，
     sortBorder之后的元素就完全不需要比较了，肯定是有序的。
     *@author SongHongWei
     *@params
     *@time 2018/9/27-15:07
     **/
    public List<Integer> bubbleSortOrder(List<Integer> sort)
    {
        List<Integer> reuslt = new LinkedList<Integer>();
        int count = 0;
        int size = sort.size() - 1;
        int lastExchangeIndex = 0;
        for (int i = 0; i < sort.size(); i++)
        {
            //有序标记，每一轮的初始是true
            boolean isSorted = true;
            for (int j = 0; j < size; j++)
            {
                int pre = sort.get(j);
                int next = sort.get(j + 1);
                if (pre > next)
                {
                    sort.set(j, next);
                    sort.set(j + 1, pre);
                    isSorted = false;
                    lastExchangeIndex = j;
                }
                count++;
            }
            if (isSorted)
            {
                break;
            }
            //缩短排序长度
            size = lastExchangeIndex;
            System.out.println("第" + i + "轮排序结果" + sort.toString());

        }
        System.out.println(count);
        return sort;
    }

这一版代码中，sortBorder就是无序数列的边界。每一轮排序过程中，sortBorder之后的元素就完全不需要比较了，肯定是有序的。
全部代码,及git地址 https://gitee.com/BruceWayen/algorithm.git :

package com.git.algorithm.bubbling;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;

/**
 * @                           _ooOoo_
 *                            o8888888o
 *                            88" . "88
 *                            (| -_- |)
 *                            O\  =  /O
 *                         ____/`---'\____
 *                       .'  \\|     |//  `.
 *                      /  \\|||  :  |||//  \
 *                     /  _||||| -:- |||||-  \
 *                     |   | \\\  -  /// |   |
 *                     | \_|  ''\---/''  |   |
 *                     \  .-\__  `-`  ___/-. /
 *                   ___`. .'  /--.--\  `. . __
 *                ."" '<  `.___\_<|>_/___.'  >'"".
 *               | | :  `- \`.;`\ _ /`;.`/ - ` : | |
 *               \  \ `-.   \_ __\ /__ _/   .-` /  /
 *          ======`-.____`-.___\_____/___.-`____.-'======
 *                             `=---='
 *          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 *                     佛祖保佑        永无BUG
 *@DESCRIPTION 冒泡排序
 *@AUTHOR SongHongWei
 *@TIME 2018/9/26-17:19
 *@PACKAGE_NAME com.git.algorithm.bubbling
 **/
public class BubbleSort
{
    public static void main(String[] args)
    {
        BubbleSort bubbleSort = new BubbleSort();
        List<Integer> randomArray = bubbleSort.getRandomArray(15);
        System.out.println(bubbleSort.bubbleSort(new ArrayList<Integer>(randomArray)));
        System.out.println(bubbleSort.bubbleSortHalf(new ArrayList<Integer>(randomArray)));
        System.out.println(bubbleSort.bubbleSortOptimize(new ArrayList<Integer>(randomArray)));
        System.out.println(bubbleSort.bubbleSortOrder(new ArrayList<Integer>(randomArray)));
    }

    /**
     *@description 获取指定长度的随机数组
     *@author SongHongWei
     *@params
     *@time 2018/9/26-17:35
     **/
    public List<Integer> getRandomArray(int length)
    {
        List<Integer> result = new ArrayList<Integer>();
        Random random = new Random();
        for (int i = 0; i < length; i++)
        {
            result.add(random.nextInt(length));
        }
        System.out.println(result.toString());
        return result;
    }

    /**
     *@description 传统的冒泡排序
     *@author SongHongWei
     *@params
     *@time 2018/9/26-17:40
     **/
    public List<Integer> bubbleSort(List<Integer> sort)
    {
        List<Integer> reuslt = new LinkedList<Integer>();
        int count = 0;
        int size = sort.size();
        for (int i = 0; i < sort.size(); i++)
        {
            for (int j = 0; j < size - 1; j++)
            {
                int pre = sort.get(j);
                int next = sort.get(j + 1);
                if (pre > next)
                {
                    sort.set(j, next);
                    sort.set(j + 1, pre);
                }
                count++;
            }
            System.out.println("第" + i + "轮排序结果" + sort.toString());
        }
        System.out.println(count);
        return sort;
    }

    /**
     *@description 稍微改进后的, 循环次数降低了一半
     *@author SongHongWei
     *@params
     *@time 2018/9/27-14:51
     **/
    public List<Integer> bubbleSortHalf(List<Integer> sort)
    {
        List<Integer> reuslt = new LinkedList<Integer>();
        int count = 0;
        int size = sort.size();
        for (int i = 0; i < sort.size(); i++)
        {
            for (int j = 0; j < size - i - 1; j++)
            {
                int pre = sort.get(j);
                int next = sort.get(j + 1);
                if (pre > next)
                {
                    sort.set(j, next);
                    sort.set(j + 1, pre);
                }
                count++;
            }
            System.out.println("第" + i + "轮排序结果" + sort.toString());
        }
        System.out.println(count);
        return sort;
    }

    /**
     *@description 这一版代码做了小小的改动，利用布尔变量isSorted作为标记。如果在本轮排序中，元素有交换，则说明数列无序；如果没有元素交换，说明数列已然有序，直接跳出大循环。
     *@author SongHongWei
     *@params
     *@time 2018/9/27-14:51
     **/
    public List<Integer> bubbleSortOptimize(List<Integer> sort)
    {
        List<Integer> reuslt = new LinkedList<Integer>();
        int count = 0;
        int size = sort.size();
        for (int i = 0; i < sort.size(); i++)
        {
            //有序标记，每一轮的初始是true
            boolean isSorted = true;
            for (int j = 0; j < size - 1; j++)
            {
                int pre = sort.get(j);
                int next = sort.get(j + 1);
                if (pre > next)
                {
                    sort.set(j, next);
                    sort.set(j + 1, pre);
                    isSorted = false;
                }
                count++;
            }
            if (isSorted)
            {
                break;
            }
            size--;
            System.out.println("第" + i + "轮排序结果" + sort.toString());

        }
        System.out.println(count);
        return sort;
    }

    /**
     *@description 这一版代码中，sortBorder就是无序数列的边界。每一轮排序过程中，
     sortBorder之后的元素就完全不需要比较了，肯定是有序的。
     *@author SongHongWei
     *@params
     *@time 2018/9/27-15:07
     **/
    public List<Integer> bubbleSortOrder(List<Integer> sort)
    {
        List<Integer> reuslt = new LinkedList<Integer>();
        int count = 0;
        int size = sort.size() - 1;
        int lastExchangeIndex = 0;
        for (int i = 0; i < sort.size(); i++)
        {
            //有序标记，每一轮的初始是true
            boolean isSorted = true;
            for (int j = 0; j < size; j++)
            {
                int pre = sort.get(j);
                int next = sort.get(j + 1);
                if (pre > next)
                {
                    sort.set(j, next);
                    sort.set(j + 1, pre);
                    isSorted = false;
                    lastExchangeIndex = j;
                }
                count++;
            }
            if (isSorted)
            {
                break;
            }
            //缩短排序长度
            size = lastExchangeIndex;
            System.out.println("第" + i + "轮排序结果" + sort.toString());
        }
        System.out.println(count);
        return sort;
    }

}

猜你喜欢

转载自blog.csdn.net/u010859650/article/details/82870098
今日推荐
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
周排行
计算机组成与设计（七）—— 除法器
Integer Approximation(分治+枚举)
大话数据库索引
windows10系统JDK的配置及下载地址
mysql实现秒值转换中原六仔平台搭建
Codeforces Round #556 (Div. 1)
百练1064 网线主管
Codeforces 995F Cowmpany Cowmpensation
子集生成之增量构造法，位向量法，二进制法
ERROR: cmd.exe failed with args /c "/APK\gradle\rungradle.bat...
每日归档
更多
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022