java冒泡排序从大到小数组（java单例模式代码）

冒泡排序（一）：

假设有 5 个数字 35，56，34，22，16 在一个 int 数组中，要求按从小到大排序输出如何采用冒泡排序算法呢？

1、基本思想

首先从数组的最左边开始，取出第 0 号位置（左边）的数据和第1号位置（右边）的数据，如果左边的数据大于右边的数据，则进行交换，否而不进行交换。接下来右移一个位置，取出第 1 个位置的数据和第 2 个位置的数据，进行比较，如果左边的数据大于右边的数据，则进行交换，否则不进行交换。沿着这个算法一直排序下去，最大的数就会冒出水面，这就是冒泡排序.

2、排序过程。下面我们来模拟一下冒泡排序假设有数组{35,56,34,22,16}

第一轮排序：

第一次排序：35和56比较，56更大这里我们什么都别管 顺序为：35,56,34,22,16

第二次排序：56和34比较，56更大我们让56和34交换 顺序：35,34,56,22,16

第三次排序: 56和22比较，56更大，交换位置 顺序：35,34,22,56,16

第四次排序: 56比16比较，56更大，交换位置 顺序: 35,34,22,16,56

第一轮比较了四次

第二轮排序：

第一次排序：35和34比较，35更大，交换位置 顺序：34,35,22,16,56

第二次排序：35和22比较，35更大，交换位置 顺序：34,22,35,16,56

第三次排序：35和16比较，35更大，交换位置 顺序：34,22,16,35,56

第二轮比较了三次

第三轮排序:

第一次排序：34和22比较，34更大，交换位置 顺序：22,34,16,35,56

第二次排序：34和16比较，34更大，交换位置 顺序：22,16,34,35,56

第三轮比较了两次

第四轮排序：

第一次排序：22和16比较，22更大，交换位置 顺序：16,22,34,35,56

第四轮比较了一次

最终顺序：16,22,34,35,56

从上面我们看到了比较了 N-1 次，那么第二遍就为 N-2 次比较了，如此类推，比较次数的公式如下：

(N-1) + (N-2)+…+1=((N-1)*N)/2

所以以上总共比较次数为((5-1)*5)/2=10

代码实现如下：

/** * ClassName:BubbleSort <br/> * * Function: TODO ADD FUNCTION. <br/> * Reason: TODO ADD REASON. <br/> * Date: 2021年11月4日 上午11:23:32 <br/> *  * @author Administrator * @version * @since JDK 1.8 * @see */public class BubbleSort {public static void main(String[] args) {int[] data = { 35, 56, 34, 22, 16 };for (int i = 0; i < data.length; i++) {int min = i;// 选择出最小值的下标for (int j = i + 1; j < data.length; j++) {if (data[j] < data[min]) {min = j;}}// 将最小值放到未排序记录的第一个位置if (min != i) {// min>iint temp = data[i];data[i] = data[min];data[min] = temp;}}// 循环输出数组中的元素for (int i = 0; i < data.length; i++) {System.out.println(data[i]);}}}

冒泡排序（二）：

1、基本思想

两两比较待排序数据元素的大小，发现两个数据元素的次序相反时即进行交换，直到没有反序的数据元素为止。

2、排序过程

设想被排序的数组R［1..N］垂直竖立，将每个数据元素看作有重量的气泡，根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R，凡扫描到违反本原则的轻气泡，就使其向上”漂浮”，如此反复进行，直至最后任何两个气泡都是轻者在上，重者在下为止。

【示例】：

49 13 13 13 13 13 13 13

38 49 27 27 27 27 27 27

65 38 49 38 38 38 38 38

97 65 38 49 49 49 49 49

76 97 65 49 49 49 49 49

13 76 97 65 65 65 65 65

27 27 76 97 76 76 76 76

49 49 49 76 97 97 97 97

代码实现：

/** * ClassName:BubbleSort <br/> * * Function: 冒泡排序：执行完一次内for循环后，最小的一个数放到了数组的最前面（跟那一个排序算法* 不一样）。相邻位置之间交换 * Reason: TODO ADD REASON. <br/> * Date: 2021年11月4日 上午11:23:32 <br/> *  * @author Administrator * @version * @since JDK 8 * @see */public class BubbleSort {/** * 排序算法的实现，对数组中指定的元素进行排序 *  * @param array 待排序的数组 * @param from  从哪里开始排序 11 * @param end 排到哪里 11 * @param c 比较器 11 */public void bubble(Integer[] array, int from, int end) {// 需array.length - 1轮比较for (int k = 1; k < end - from + 1; k++) {// 每轮循环中从最后一个元素开始向前起泡，直到i=k止，即i等于轮次止for (int i = end - from; i >= k; i--) {// 按照一种规则（后面元素不能小于前面元素）排序if ((array[i].compareTo(array[i - 1])) < 0) {// 如果后面元素小于了（当然是大于还是小于要看比较器实现了）前面的元素，则前后交换swap(array, i, i - 1);}}}}/** * 交换数组中的两个元素的位置 *  * @param array 待交换的数组 * @param i     第一个元素 * @param j     第二个元素 */public void swap(Integer[] array, int i, int j) {if (i != j) {// 只有不是同一位置时才需交换Integer tmp = array[i];array[i] = array[j];array[j] = tmp;}}public static void main(String[] args) {Integer[] intgArr = { 35, 56, 34, 22, 16 };BubbleSort bubblesort = new BubbleSort();bubblesort.bubble(intgArr, 0, intgArr.length - 1);for (Integer intObj : intgArr) {System.out.print(intObj + " ");}}}

另外一种实现方式：

/** * ClassName:BubbleSort <br/> * * Function: 冒泡排序：执行完一次内for循环后，最大的一个数放到了数组的最后面。相邻位置之间交换 Reason: TODO ADD REASON. * <br/> * Date: 2021年11月4日 上午11:23:32 <br/> *  * @author Administrator * @version * @since JDK 8 * @see */public class BubbleSort {public static void main(String[] args) {int[] a = { 35, 56, 34, 22, 16 };bubble(a);for (int num : a) {System.out.print(num + " ");}}public static void bubble(int[] a) {for (int i = a.length - 1; i > 0; i--) {for (int j = 0; j < i; j++) {if (new Integer(a[j]).compareTo(new Integer(a[j + 1])) > 0) {swap(a, j, j + 1);}}}}public static void swap(int[] a, int x, int y) {int temp;temp = a[x];a[x] = a[y];a[y] = temp;}}