详解冒泡排序（Java）

小梦^_^不学习
已于 2023-09-17 15:28:17 修改
阅读量39
点赞数
文章标签： java 排序算法算法程序人生
于 2023-09-17 15:24:19 首次发布
本文链接：https://blog.csdn.net/weixin_62578531/article/details/132943577
版权
冒泡排序

Java代码：冒泡排序

public class BubbleSort{
	public static void main(String[] args){


		/*
			数组 arr[9，545，64，7，67，86，8，-1，0]

			第一轮排序：将数组中最大的数放在倒数第一的位置
			第1次比较：arr[9，545，64，  7，     67，    86，     8，    -1，       0]
			//第1次比较时，9与544比较  结果满足后一个大于前一个  不发生交换
			第2次比较：arr[9，64，  545，7，     67，    86，     8，    -1，       0]
			//第2次比较时，545与64交换
			第3次比较：arr[9，64，   7，   545， 67，    86，     8，    -1，       0]
			//第3次比较时，545与7交换
			第4次比较：arr[9，64，   7，   67，   545，  86，     8，    -1，       0]
			//第4次比较时，545与67交换
			第5次比较：arr[9，64，   7，   67，   86，    545，   8，    -1，       0]
			//第5次比较时，545与86交换
			第6次比较：arr[9，64，   7，   67，   86，    8，       545，-1，       0]
			//第6次比较时，545与8交换
			第7次比较：arr[9，64，   7，   67，   86，    8，       -1，   545，     0]
			//第7次比较时，545与-1交换
			第8次比较：arr[9，64，   7，   67，   86，    8，       -1，    0，    545]
			//第8次比较时，545与0交换     至此第一轮交换完成 将数组中最大的排到最后

		*/

		int [] arr  ={9, 545, 64, 7, 67, 86, 8, -1, 0};
		int temp = 0;
		for(int i = 0;i < arr.length - 1; i++){
			if(arr[i + 1] < arr[i]){
				temp = arr[i + 1];  
				arr[i + 1] = arr[i];
				arr[i] = temp;
			}
		}

		System.out.println("\n=====数组第一次排序结果如下：=====\n");
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + " ");
		}



		/*
			数组 arr[9，64，   7，   67，   86，    8，       -1，    0，    545]

			第二轮排序：在第一轮排序的基础上   将数组中第二大的数放在倒数第二的位置
			第1次比较：arr[9，64，   7，   67，   86，    8，       -1，    0，    545]
			//第1次比较时，9与64比较  结果满足后一个大于前一个  不发生交换
			第2次比较：arr[9，7，   64，   67，   86，    8，       -1，    0，    545]
			//第2次比较时，64与7交换
			第3次比较：arr[9，7，   64，   67，   86，    8，       -1，    0，    545]
			//第3次比较时，64与67比较   结果满足后一个大于前一个  不发生交换
			第4次比较：arr[9，7，   64，   67，   86，    8，       -1，    0，    545]
			//第4次比较时，67与86比较   结果满足后一个大于前一个  不发生交换
			第5次比较：arr[9，7，   64，   67，   8，      86，     -1，    0，    545]
			//第5次比较时，86与8交换
			第6次比较：arr[9，7，   64，   67，   8，      -1，     86，    0，    545]
			//第6次比较时，86与-1交换
			第7次比较：arr[9，7，   64，   67，   8，      -1，      0，    86，    545]
			//第7次比较时，86与0交换     至此第一轮交换完成 将数组中最大的排到最后
		*/
		for(int i = 0;i < arr.length - 1; i++){
			if(arr[i + 1] < arr[i]){
				temp = arr[i + 1];  
				arr[i + 1] = arr[i];
				arr[i] = temp;
			}
		}

		System.out.println("\n=====数组第二次排序结果如下：=====\n");
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + " ");
		}



		/*
			数组 arr[9，7，   64，   67，   8，      -1，      0，    86，    545]

			第三轮排序：在第二轮排序的基础上   将数组中第三大的数放在倒数第三的位置
			第1次比较：arr[7，9，   64，   67，   8，      -1，      0，    86，    545]
			//第1次比较时，9与7交换
			第2次比较：arr[7，9，   64，   67，   8，      -1，      0，    86，    545]
			//第2次比较时，9与64比较   结果满足后一个大于前一个  不发生交换
			第3次比较：arr[7，9，   64，   67，   8，      -1，      0，    86，    545]
			//第3次比较时，64与67比较   结果满足后一个大于前一个  不发生交换
			第4次比较：arr[7，9，   64，   8，   67，      -1，      0，    86，    545]
			//第4次比较时，67与8交换
			第5次比较：arr[7，9，   64，   8，   -1，      67，      0，    86，    545]
			//第5次比较时，67与-1交换
			第6次比较：arr[7，9，   64，   8，   -1，      0，      67，    86，    545]
			//第6次比较时，67与0交换   至此第三轮交换完成 将数组中第三大的数放在倒数第三的位置
		*/
		for(int i = 0;i < arr.length - 1; i++){
			if(arr[i + 1] < arr[i]){
				temp = arr[i + 1];  
				arr[i + 1] = arr[i];
				arr[i] = temp;
			}
		}

		System.out.println("\n=====数组第三次排序结果如下：=====\n");
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + " ");
		}



		/*
			数组 arr[7，9，   64，   8，   -1，      0，      67，    86，    545]

			第四轮排序：在第三轮排序的基础上   将数组中第四大的数放在倒数第四的位置
			第1次比较：arr[7，9，   64，   8，   -1，      0，      67，    86，    545]
			//第1次比较时，7与9比较   结果满足后一个大于前一个  不发生交换
			第2次比较：arr[7，9，   64，   8，   -1，      0，      67，    86，    545]
			//第2次比较时，9与64比较   结果满足后一个大于前一个  不发生交换
			第3次比较：arr[7，9，   8，   64，   -1，      0，      67，    86，    545]
			//第3次比较时，64与8交换
			第4次比较：arr[7，9，   8，   -1，   64，      0，      67，    86，    545]
			//第4次比较时，64与-1交换
			第5次比较：arr[7，9，   8，   -1，   0，      64，      67，    86，    545]
			//第5次比较时，64与0交换  至此第四轮交换完成 将数组中第四大的数放在倒数第四的位置

		*/
		for(int i = 0;i < arr.length - 1; i++){
			if(arr[i + 1] < arr[i]){
				temp = arr[i + 1];  
				arr[i + 1] = arr[i];
				arr[i] = temp;
			}
		}

		System.out.println("\n=====数组第四次排序结果如下：=====\n");
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + " ");
		}

		/*
			数组 arr[7，9，   8，   -1，   0，      64，      67，    86，    545]

			第五轮排序：在第四轮排序的基础上   将数组中第五大的数放在倒数第五的位置
			第1次比较：arr[7，9，   8，   -1，   0，      64，      67，    86，    545]
			//第1次比较时，7与9比较   结果满足后一个大于前一个  不发生交换
			第2次比较：arr[7，8，   9，   -1，   0，      64，      67，    86，    545]
			//第2次比较时，9与8交换
			第3次比较：arr[7，8，   -1，   9，   0，      64，      67，    86，    545]
			//第3次比较时，9与-1交换
			第4次比较：arr[7，8，   -1，   0，   9，      64，      67，    86，    545]
			//第4次比较时，9与0交换   至此第五轮交换完成 将数组中第五大的数放在倒数第五的位置

		*/


		for(int i = 0;i < arr.length - 1; i++){
			if(arr[i + 1] < arr[i]){
				temp = arr[i + 1];  
				arr[i + 1] = arr[i];
				arr[i] = temp;
			}
		}

		System.out.println("\n=====数组第五次排序结果如下：=====\n");
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + " ");
		}
		/*
			数组 arr[7，8，   -1，   0，   9，      64，      67，    86，    545]

			第六轮排序：在第五轮排序的基础上   将数组中第六大的数放在倒数第六的位置
			第1次比较：arr[7，8，   -1，   0，   9，      64，      67，    86，    545]
			//第1次比较时，7与8比较   结果满足后一个大于前一个  不发生交换
			第2次比较：arr[7，-1，   8，   0，   9，      64，      67，    86，    545]
			//第2次比较时，8与-1交换
			第3次比较：arr[7，-1，   0，   8，   9，      64，      67，    86，    545]
			//第3次比较时，8与0交换   至此第六轮交换完成  将数组中第六大的数放在倒数第六的位置
		*/


		for(int i = 0;i < arr.length - 1; i++){
			if(arr[i + 1] < arr[i]){
				temp = arr[i + 1];  
				arr[i + 1] = arr[i];
				arr[i] = temp;
			}
		}

		System.out.println("\n=====数组第六次排序结果如下：=====\n");
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + " ");
		}

		/*
			数组 arr[7，-1，   0，   8，   9，      64，      67，    86，    545]

			第七轮排序：在第六轮排序的基础上   将数组中第七大的数放在倒数第七的位置
			第1次比较：arr[-1，7，   0，   8，   9，      64，      67，    86，    545]
			//第1次比较时，7与-1比较   结果满足后一个大于前一个  不发生交换
			第2次比较：arr[-1，0，   7，   8，   9，      64，      67，    86，    545]
			//第2次比较时，7与0交换  至此第七轮交换完成 将数组中第七大的数放在倒数第七的位置

		*/

		for(int i = 0;i < arr.length - 1; i++){
			if(arr[i + 1] < arr[i]){
				temp = arr[i + 1];  
				arr[i + 1] = arr[i];
				arr[i] = temp;
			}
		}

		System.out.println("\n=====数组第七次排序结果如下：=====\n");
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + " ");
		}

		/*
			数组 arr[-1，0，   7，   8，   9，      64，      67，    86，    545]

			第八轮排序：在第七轮排序的基础上   将数组中第八大的数放在倒数第八的位置
			第1次比较：arr[-1，0，   7，   8，   9，      64，      67，    86，    545]
			//第1次比较时，-1与0比较   结果满足后一个大于前一个  不发生交换

			至此冒泡排序完成
		*/



		for(int i = 0;i < arr.length - 1; i++){
			if(arr[i + 1] < arr[i]){
				temp = arr[i + 1];  
				arr[i + 1] = arr[i];
				arr[i] = temp;
			}
		}

		System.out.println("\n=====数组第八次排序结果如下：=====\n");
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + " ");
		}




		//由上述的总结  可以发现很多的代码是重复的，由此不难将代码简化

		int [] arr1  ={9, 545, 64, 7, 67, 86, 8, -1, 0};
		for(int j = 0; j < arr1.length - 1;j++){
			for(int i = 0;i < arr.length - 1 -j; i++){
				if(arr[i + 1] < arr[i]){
					temp = arr[i + 1];  
					arr[i + 1] = arr[i];
					arr[i] = temp;
				}
			}
			System.out.println("\n=====数组第" + j + "次排序结果如下：=====\n");
			for(int i = 0;i < arr.length;i++){
				System.out.print(arr[i] + " ");
			}
		}
	}
}