冒泡排序（一）：
假设有 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;
}
}版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
