算法相关——Java排序算法之冒泡排序（二）

SEU_Calvin

已于 2025-03-07 14:38:12 修改

阅读量1.4k

点赞数 3

分类专栏：算法相关文章标签： java 算法排序算法

于 2017-02-14 13:48:04 首次发布

本文链接：https://blog.youkuaiyun.com/SEU_Calvin/article/details/55097708

版权

算法相关专栏收录该内容

10 篇文章

订阅专栏

本文详细介绍冒泡排序的基本思想、代码实现及其性能特点。冒泡排序是一种简单直观的排序算法，通过相邻元素之间的比较和交换逐步将序列排序。文章还探讨了冒泡排序的时间复杂度，并给出了一种优化方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

0. 前言

本系列文章将介绍一些常用的排序算法。排序是一个非常常见的应用场景，也是开发岗位面试必问的一道面试题，有人说，如果一个企业招聘开发人员的题目中没有排序算法题，那说明这个企业不是一个“正规”的企业，哈哈，虽然有点戏谑，但是也从侧面证明了排序算法的重要性。

本文将介绍的是常见排序算法中的冒泡排序。

2. 冒泡排序

2.1 基本思想

冒泡排序也是一种简单的排序算法，基本思想就是通过相邻两个数的循环比较，将n个数中最大/小的数一点一点推向一端，再进行下一轮的比较，即将剩余的n-1个数中最大/小的数一点一点推向一端，以此类推，经过固定的n-1轮后使其有序。

2.2 代码实现

/*
*@author Calvin
*@blog http://blog.youkuaiyun.com/seu_calvin/article/details/55097708
*@date 2017/02/14
*/

public class Order {

	private int[] array; 
	public Order(int[] array){
		this.array = array;
	}
	
    public void sort() {
        for (int i = array.length - 1; i >= 1; i--) {
            for (int j = 0; j < i; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    } 
    
    public void print() {  
        for(int i = 0; i < array.length; i++)
     	        System.out.println(array[i]);
    }  
      
    public static void main(String[] args) {  
        int[] array = new int[]{3,1,5,9,6,5,0}; 
        Order order = new Order(array); 
        order.sort();
        order.print();
    }  
  
}

输出结果略去了。

2.3 性能特点

在序列本身有序的情况下冒泡排序法时间复杂度为O(n)。看起来好像比较次数没有变少啊，怎么就O(n)了。其实是要加入优化代码。

public class Order {

	private int[] array;

	public Order(int[] array) {
		this.array = array;
	}

	public void sort() {
		boolean didSwap;// 标记位
		if (array != null) {
			for (int i = 1; i <= array.length - 1; i++) {
				didSwap = false;
				for (int j = 0; j <= array.length - i - 1; j++) {
					if (array[j] > array[j + 1]) {
						int temp = array[j];
						array[j] = array[j + 1];
						array[j + 1] = temp;
						didSwap = true;
					}
				}
				if (!didSwap)
					return;
			}
		}
	}

	public void print() {
		for (int i = 0; i < array.length; i++)
			System.out.println(array[i]);
	}

	public static void main(String[] args) {
		int[] array = new int[] { 3, 1, 5, 9, 6, 5, 0 };
		Order order = new Order(array);
		order.sort();
		order.print();
	}

}

最坏的情况下时间复杂度为O(n*n)。只需要一个临时变量，因此空间复杂度为O(1)。由于进行数据交换时条件不存在等于，因此不会进行相同值数据的交换，因此冒泡排序法是稳定的。

冒泡排序法性能较差，所以很少被使用，但还是要掌握冒泡排序法的思想，如果理解了冒泡排序法的思想，那么会很容易提出一些优化它的小策略，比如增加标记位记录每趟排序中最后一次交换的位置，这个位置后面的元素已经不用交换了，以此标记位来保证部分本身有序的元素不用再重复比较。