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>i
				int 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;
	}
}