排序算法-冒泡排序-java

       只要咱们在作开发，算法对咱们来讲，意义就很重大，虽然这个年代工具包/框架层出不穷，可以协助咱们作不少事情。可是业务上的逻辑，还得咱们本身去写，到如今为止，尚未什么通用性极强的组件来帮助你实现你全部的业务。

       特别是在处理一些复杂的业务时，拥有算法的积累，可以极大的给予你分析处理需求的能力，让事务完成起来更加驾轻就熟，游刃有余。

       那今天咱们就来讲冒泡排序，冒泡排序法是一种比较简单的排序方式，理解起来也相对容易，

       它的实现是：
       1.将数组里面前一个数据同后一个进行比较，若前面的数据大于/小于后面的数据，将二者进行调换；
       2.重复以上操做，在当次循环结束后，最大/最小的那个数始终在最后的位置；

下面直接上代码：

1、排序类

/**
 * 冒泡排序
 * @author chengxp
 */
public class Bubble {

	/**
	 * 入口
	 * 
	 * @param arr
	 */
	public static void sortEntry(int[] arr) {

		// 外层循环遍历当前数组
		for (int i = 0; i < arr.length; i++) {

			// 1.内层循环从下标0开始遍历，遍历长度每次减小1(由于每次循环完成后，当前最大值已经被移动到了最后一位，故最后一位不须要参与进循环)
			// 2.这里为何要多一个"-1"呢？请往下看:
			// 2.1.现有数组如：[74,28,88,21]，长度为4是吧;
			// 2.2.外层循环开始i = 0,内层循环次数(j < arr.length - 0)仍是4;
			// 2.3.当走到下标3的时候，arr[3+1]，越界了，下标只有3；
			for (int j = 0; j < arr.length - 1 - i; j++) {

				// 比对下标相邻的两条数据，若前面的值大于后面的值，将数据进行交换
				if (arr[j] > arr[j + 1]) {

					// 知足条件，将数据进行调换
					DataProvider.changeEntry(arr, j, j + 1);
					System.out.println("changing：" + Arrays.toString(arr));
				}
			}
		}
	}

	public static void main(String[] args) {

		// 随机获取100之内数字群
		int[] arr = DataProvider.getRandomArray(5);
		System.out.println("before：" + Arrays.toString(arr));
		Bubble.sortEntry(arr);
		System.out.println("after：" + Arrays.toString(arr));
	}
}

1、数据供给类

/**
 * 数据提供入口
 * @author chengxp
 *
 */
public class DataProvider {

	/**
	 * 建立指定长度的随机数组
	 * @param length
	 */
	public static int[] getRandomArray(int length) {
		
		int[] arr = new int[length];
		DecimalFormat df = new DecimalFormat("#");
		
		for(int i = 0;i < length;i ++) {
			
			arr[i] = Integer.parseInt(df.format(Math.random() * 100));
		}
		return arr;
	}
	
	/**
	 * 交换入口
	 * @param arrTarget
	 * @param indexF
	 * @param indexS
	 */
	public static void changeEntry(int[] arrTarget,int indexF,int indexS) {
		
		int exchange = arrTarget[indexF];
		arrTarget[indexF] = arrTarget[indexS];
		arrTarget[indexS] = exchange;
	}
	
}

咱们运行一下Bubble类的代码。

随机数组生成，并给出的排序 过程/结果 以下:

before：[36, 15, 9, 98, 19]

changing：[15, 36, 9, 98, 19]

changing：[15, 9, 36, 98, 19]

changing：[15, 9, 36, 19, 98]

changing：[9, 15, 36, 19, 98]

changing：[9, 15, 19, 36, 98]

after：[9, 15, 19, 36, 98]

如上，已经获得了想要的结果。咱们来一块儿仔细分析一下，这货是怎么完成的。
这是咱们的原数组：[36, 15, 9, 98, 19];
规则1：下标j>下标j+1，只要条件知足，咱们就交换；
规则2：每完成一次循环，下一次的循环长度-1，也就是(j < arr.length - 1 - i)；

开始：
外层循环第一次循环，i = 0;内层j < arr.length - 1 - 0；j只会走到当前98的位置 j > j+1;
1.比较36>15，换：
changing：[15, 36, 9, 98, 19];
2.比较36>9,换：
changing：[15, 9, 36, 98, 19];
3.比较36>98，不换;
4.比较98>19，换：
changing：[15, 9, 36, 19, 98]；
到这里，已经找到了数组里面最大的数。

外层循环第二次循环，i = 1;内层j < arr.length - 1 - 1；j只会走到当前36的位置，看见没;
不会再找98了！！！由于当前循环体内，最大的j+1=下标3，98的位置是下标4。
1.15>9，换：
changing：[9, 15, 36, 19, 98];
2.15>36，不换;
3.36>19，换：
changing：[9, 15, 19, 36, 98];

外层循环第三次循环，i = 2;内层j < arr.length - 1 - 2；j只会走到当前15的位置;
1.9>15，不换;
2.15>19，不换;
依旧是：[9, 15, 19, 36, 98];

外层循环第四次循环，i = 3;内层j < arr.length - 1 - 3;j只会走到当前9的位置;
1.9>15,不换;

外层循环第五次循环，i = 4;内层j < arr.length - 1 - 4;退出内层循环;
退出外层循环；
结束...

修改DataProvider.getRandomArray(9)再来运行一次： before：[58, 90, 86, 17, 17, 61, 75, 27, 0] changing：[58, 86, 90, 17, 17, 61, 75, 27, 0] changing：[58, 86, 17, 90, 17, 61, 75, 27, 0] changing：[58, 86, 17, 17, 90, 61, 75, 27, 0] changing：[58, 86, 17, 17, 61, 90, 75, 27, 0] changing：[58, 86, 17, 17, 61, 75, 90, 27, 0] changing：[58, 86, 17, 17, 61, 75, 27, 90, 0] changing：[58, 86, 17, 17, 61, 75, 27, 0, 90] changing：[58, 17, 86, 17, 61, 75, 27, 0, 90] changing：[58, 17, 17, 86, 61, 75, 27, 0, 90] changing：[58, 17, 17, 61, 86, 75, 27, 0, 90] changing：[58, 17, 17, 61, 75, 86, 27, 0, 90] changing：[58, 17, 17, 61, 75, 27, 86, 0, 90] changing：[58, 17, 17, 61, 75, 27, 0, 86, 90] changing：[17, 58, 17, 61, 75, 27, 0, 86, 90] changing：[17, 17, 58, 61, 75, 27, 0, 86, 90] changing：[17, 17, 58, 61, 27, 75, 0, 86, 90] changing：[17, 17, 58, 61, 27, 0, 75, 86, 90] changing：[17, 17, 58, 27, 61, 0, 75, 86, 90] changing：[17, 17, 58, 27, 0, 61, 75, 86, 90] changing：[17, 17, 27, 58, 0, 61, 75, 86, 90] changing：[17, 17, 27, 0, 58, 61, 75, 86, 90] changing：[17, 17, 0, 27, 58, 61, 75, 86, 90] changing：[17, 0, 17, 27, 58, 61, 75, 86, 90] changing：[0, 17, 17, 27, 58, 61, 75, 86, 90] after：[0, 17, 17, 27, 58, 61, 75, 86, 90] 运行完毕，又完成了一次排序.