基本算法：冒泡排序算法

基本算法：冒泡排序算法

冒泡算法简介

冒泡算法（Bubble Sort)，是一种比较简单的排序算法。其排序逻辑是：重复访问需要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小首字母从A到Z）有误，就会对元素进行位置交换，重复该过程直到没有相邻的元素需要进行交换。
算法的名称是因为经过该算法排序后，越小的元素会经过交换会像泡泡一样慢慢浮动到数列的顶端，故此得名冒泡算法。

算法排序详解

假设有数组【1，6，3，5，2】，我们使用从小到大进行的方式进行冒泡排序。

第一趟排序：

1. 1与6相比，1小于6，位置不变。【1，6，3，5，2】
2. 6与3相比，6大于3，交换位置。【1，3，6，5，2】
3. 6与5相比，6大于5，交换位置。【1，3，5，6，2】
4. 6与2相比，6大于2，交换位置。【1，3，5，2，6】

第二趟排序：

1. 1与3相比，1小于3，位置不变。【1，3，5，2，6】
2. 3与5相比，3小于5，位置不变。【1，3，5，2，6】
3. 5与2相比，5大于2，交换位置。【1，3，2，5，6】

第三趟排序：

1. 1与3相比，1小于3，位置不变。【1，3，2，5，6】
2. 3与2相比，3大于2，交换位置。【1，2，3，5，6】

分析

• 冒泡排序每排序一趟，就会少比较一个数据。因为每一次排序都会将较大值进行下标后移，第一趟排排序，找出最大值，第二趟排序找出次大值。比较到最后，需要比较的数据越来越少。N个长度的数据要进行冒泡排序，要进行N-1趟排序，第i趟的排除次数为N-i-1次（因为每一趟就会少比较一个数据）。

复杂度分析

下面我们来分析下冒泡排序的时间复杂度和空间复杂度。

时间复杂度：

• 最好的情况：数据本身已经排序完毕，那就不用元素交换。仅需n-1次即可完成排序，时间复杂度是O(n)。
• 最坏情况:数据是逆序排列，所以我们要全部重新排序一次。对于n位的数列则有比较次数为 (n-1) + (n-2) + ... + 1 = n * (n - 1) / 2=O(n^2)。
• 平均复杂度：O(n^2)

空间复杂度：该算法的所消耗的存储空间。

• 最好情况：数据本身有序，不会用到临时变量，则复杂度为0。
• 最差情况：数据逆序排序，每次都会使用到临时变量。复杂度为O(n)。
• 平均复杂度：O(1)。

Java代码实现

package top.enjoyitlife.bubble;

import java.util.Arrays;

/***
* @ClassName: BubbleAlgorithm 
* @Description: 冒泡排序算法
* @author MegaSlark 
 */
public class BubbleAlgorithm {
	public static void main(String[] args) {
		int[] nums=new int[] {1,2,3,6,7};
		BubbleAlgorithm ba = new BubbleAlgorithm();
		ba.bubbleSort(nums);
		System.out.println(Arrays.toString(nums));
	}

	/****
	 * 冒泡排序 正序 有小到大
	 * @param nums
	 */
	public void bubbleSort(int[] nums) {
		if(null==nums||nums.length<1) {
			return;
		}
		int length=nums.length;
		//数组下标从0开始，比较趟数为数组长度减1
		for(int i=0;i<length-1;i++) {
			//是否需要全部循环标识
			boolean flag=true;
			//length-1的原因同上，多减i是因为不需要比较的数据为i个。每次冒泡都会找出一个不许要再次比较的数。
			for( int j=0;j<length-1-i;j++) {
				// 控制冒泡方向 倒序还是正序
				int temp=0;
				if(nums[j]  >  nums[j+1]) {
					temp=nums[j];
					nums[j]=nums[j+1];
					nums[j+1]=temp;
					flag=false;
				}
			}
			if(flag) {
				break;
			}
			
		}
	}
}

以上就是冒泡排序的接受及代码示例，希望对你有所帮助。