Java基本排序算法汇总之（1）冒泡排序

冒泡排序

冒泡排序是一种交换排序。也就是说：两两比较待排序的关键字，并交换不满足次序要求的那一对数，直到整个表都满足次序要求为止。

下面演示一下冒泡排序的实际流程：

• 假设有一个无序序列 { 4. 3. 1. 2. 5 }
• 如果从前往后排，就会逐步把每一轮比较出来最大的数放在最后面
• 第一趟排序：结果为{ 3. 1. 2. 4. 5 }，通过两两比较，找到该轮比较出来最大的数值 4 ，将其放在序列的第4位。
• 第二趟排序：结果为{ 1. 2. 3. 4. 5 }，通过两两比较，找到该轮比较出来最大的数值 3 ，将其放在序列的第3位。
• 如果从后往前排，就会逐步把每一轮比较出来最小的数放在最前面
• 第一趟排序：结果为{ 1. 4. 3. 2. 5 }，通过两两比较，找到第一小的数值 1 ，将其放在序列的第一位。
• 第二趟排序：结果为{ 1. 2. 4. 3. 5 }，通过两两比较，找到第二小的数值 2 ，将其放在序列的第二位。
• 第三趟排序：结果为{ 1. 2. 3. 4. 5 }，通过两两比较，找到第三小的数值 3 ，将其放在序列的第三位。
  至此，所有元素已经有序，排序结束。

简单代码如下

//冒泡排序
	// 重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
	// 走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。时间复杂度 O（n²），为稳定算法。
	// 将数依次进行比较，并将大（或小）的，往后放，如下：
	public static void bubbleSort(int []arr) {
		// 要遍历的次数
        for(int i =0;i<arr.length-1;i++) {
        	// 从后往前依次的比较相邻两个数的大小，遍历一次后，把数组中最小的数放在最前位置上（这是从后往前排）
        	//for (int j = list.length - 1; j > i; j--) 

        	// 从前往后依次的比较相邻两个数的大小，遍历一次后，把数组中最大的数放在最后位置上（这是从前往后排）
            for(int j=0;j<arr.length-i-1;j++) {  //-1为了防止溢出
                if(arr[j]>arr[j+1]) {  //把大的数放在后面
                    int temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
            }
            }    
        }
    }

性能分析

排序方法	时间复杂度	空间复杂度	稳定性	复杂性
冒泡排序	O(n2)	O(1)	稳定	简单

循环一遍的时间复杂度为O(n)，所以在数组有序的情况下，冒泡排序最好时间复杂度为O(n)。
若初始文件是反序的，需要进行 N -1 趟排序循环。每趟排序要进行 N - i 次关键字的比较(1 ≤ i ≤ N - 1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：
Cmax = N(N-1)/2 = O(N2)
Mmax = 3N(N-1)/2 = O(N2)
冒泡排序的最坏时间复杂度为O(N2)。

因此，冒泡排序的平均时间复杂度为O(N2)。
总结：当数据越接近正序时，冒泡排序性能越好。

冒泡排序算法代码优化

对冒泡排序常见的改进方法是加入标志性变量change，用于标志某一趟排序过程中是否有数据交换。

如果进行某一趟排序时并没有进行数据交换，则说明所有数据已经有序，可立即结束排序，避免不必要的比较过程。

// 冒泡排序
	// 重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
	// 走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。时间复杂度 O（n²），为稳定算法。
	// 将数依次进行比较，并将大（或小）的，往后放，如下：
	public static void bubbleSort(int[] arr) {
		// 要遍历的次数
		for (int i = 0; i < arr.length - 1; i++) {
			boolean change = false; // 交换标志
			// 从后往前依次的比较相邻两个数的大小，遍历一次后，把数组中最小的数放在最前位置上（这是从后往前排）
			// for (int j = list.length - 1; j > i; j--)
			// 从前往后依次的比较相邻两个数的大小，遍历一次后，把数组中最大的数放在最后位置上（这是从前往后排）
			for (int j = 0; j < arr.length - i - 1; j++) { // -1为了防止溢出
				if (arr[j] > arr[j + 1]) { // 把大的数放在后面
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
					change = true;
				}
			}
			// 如果标志为false，说明本轮遍历没有交换，已经是有序数列，可以结束排序
			if (false == change) {
				break;
			}
		}
	}

全部代码（复制粘贴可运行）

/**
 * * @program: JavaSpecialityDeep
 * 
 * @author: Mr.Taikooa
 * @create: 2019-07-25 9:52
 * @description: 冒泡排序 冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求。
 *               如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复n 次， 就完成了 n 个数据的排序工作。
 **/
public class BubbleSort {
	public void bubbleSort(Integer[] arr, int n) {
		if (n <= 1)
			return; // 如果只有一个元素就不用排序了
		for (int i = 0; i < n; ++i) { // 提前退出冒泡循环的标志位,即一次比较中没有交换任何元素，这个数组就已经是有序的了
			boolean flag = false;
			for (int j = 0; j < n - i - 1; ++j) { // 此处你可能会疑问的j<n-i-1，因为冒泡是把每轮循环中较大的数飘到后面， //
													// 数组下标又是从0开始的，i下标后面已经排序的个数就得多减1，总结就是i增多少，j的循环位置减多少
				if (arr[j] > arr[j + 1]) { // 即这两个相邻的数是逆序的，交换
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
					flag = true;
				}
			}
			if (!flag)
				break;// 没有数据交换，数组已经有序，退出排序
		}
	}

//	long startTime = System.currentTimeMillis(); // 获取开始时间
//	// doThing(); // 测试的代码
//	long endTime = System.currentTimeMillis(); // 获取结束时间
//	System.out.println("程序运行时间： " + (endTime - startTime) + “ms”);
	
	public static void BubbleSort1(int[] arr) {
		int temp;// 临时变量
		boolean flag;// 是否交换的标志
		for (int i = 0; i < arr.length - 1; i++) { // 表示趟数，一共arr.length-1次。

			flag = false;
			for (int j = arr.length - 1; j > i; j--) {

				if (arr[j] < arr[j - 1]) {
					temp = arr[j];
					arr[j] = arr[j - 1];
					arr[j - 1] = temp;
					flag = true;
				}
			}
			if (!flag)
				break;
		}
	}

	public static void main(String[] args) {
		Integer arr[] = { 2, 4, 7, 6, 8, 5, 9 };
		SortUtil.show(arr);
		BubbleSort bubbleSort = new BubbleSort();
		bubbleSort.bubbleSort(arr, arr.length);
		SortUtil.show(arr);
	}

}

分享开发经验同时难免会有错误，文章有不对的地方希望各路大神指出，谢谢！