写在前言:
1、现在出去面试，面试官老是会问你一句话Java 怎么样？
不管是大数据岗位还是数据库都会问一句。 回来痛下决心，决定探索下这门语言的精髓，大数据很多框架也都是Java 写的，的确懂一门语言，比较稳妥。路也宽敞！！！不然就和吃饭没筷子，那么尴尬。把每天学习到的 Java知识分享到这里会。直到能自己写个复杂一点Dome得出来。
2、为了监督自己探索这门语言的动力与决心。特此这段话放到前面！！！
3、挑战下自己 到底是笨 还是学不会，还是不想学。

文章目录:

• 1、原理：比较两个相邻的元素，将值大的元素交换至右端。
• 2、最终代码实现效果：
• 3、你的答案：最近最火热的一首歌曲送给你。
• 【转载注明出处，还望尊重原创 】
• 【作者水平有限，如有错误欢迎指正 .】

1、原理：比较两个相邻的元素，将值大的元素交换至右端。

思路：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复第一趟步骤，直至全部排序完成。

第一趟比较完成后，最后一个数一定是数组中最大的一个数，所以第二趟比较的时候最后一个数不参与比较；

第二趟比较完成后，倒数第二个数也一定是数组中第二大的数，所以第三趟比较的时候最后两个数不参与比较；

依次类推，每一趟比较次数-1；

……

举例说明：要排序数组：int[ ] arr =new int [ ] {43,32,76,-98,0,64,66,33,-21,99};

上边是10个元素：因为是10个元素他会循环比较9次，最后一个值为最大值。

第一趟排序：43,32,76,-98,0,64,66,33,-21,99

第一次排序：43和32比较，43大于32，交换位置： 32, 43,76,-98,0,64,66,33,-21,99

第二次排序：43和76比较，43小于76，不交换位置：32, 43,76,-98,0,64,66,33,-21,99

第三次排序：76,-98比较，76大于-98，交换位置：32, 43,-98,76,0,64,66,33,-21,99

第四次排序：76,0比较，76大于0，交换位置：32, 43,-98,0,76,64,66,33,-21,99

第五次排序：76,64比较，76大于64，交换位置：32, 43,-98,0,64,76，66,33,-21,99

第五次排序：76，66比较，76大于66，交换位置：32, 43,-98,0,64,66,76,33,-21,99

第六次排序：76，33比较，76大于33，交换位置：32, 43,-98,0,64,66,33,76，-21,99

第七次排序：76，-21比较，76大于-21，交换位置：32, 43,-98,0,64,66,33,-21,76，99

第八次排序：76，99比较，76小于99，不要交换位置：32, 43,-98,0,64,66,33,-21,76,99

第一趟总共进行了8次比较， 排序结果： 32, 43,-98,0,64,66,33,-21,76,99

第二趟排序：32, 43,-98,0,64,66,33,-21,76,99

第一次排序:32和43比较，32小于43，不交换位置：32, 43,-98,0,64,66,33,-21,76,99

第二次排序：43和-98比较，-98小于43，交换位置：32, -98,43,0,64,66,33,-21,76,99

第三次排序：43和0比较，43大于0，交换位置：32, -98,0,43，64,66,33,-21,76,99

“负数的定义是：任何正数前加上负号都等于负数 -（-2）这个数本身不是属于负数概念的,只不过是（-2的相反数）, 0一定比正数小,就意味着0一定比负数大,这句话是对的 ”

第四次排序：64和66比较，64小于66，不交换位置：32, -98,0,43，64，66,33,-21,76,99

第五次排序：66和33比较，66大于33，交换位置：32, -98,43,0,64,33,66,-21,76,99

第六次排序：66和-21比较，66大于-21，交换位置：32, -98,43,0,64,33,-21,66,76,99

第七次排序：76和66比较，76大于66 不交换位置：32, -98,43,0,64,33,-21,66,76,99

第八次排序：76和99比较，99大于76 不交换位置：32, -98,43,0,64,33,-21,66,76,99

依次类推下去：
每次都会推出最大值的数。
最终结果：
-98 -21 0 32 33 43 64 66 76 99

• 由此可见：N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数，即
• for(int i =0;i<arr.length-1;i++) {
  for(int j=0;j<arr.length-1-i;j++) {

冒泡排序的优点：每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值。如上例：第一趟比较之后，排在最后的一个数一定是最大的一个数，第二趟排序的时候，只需要比较除了最后一个数以外的其他的数，同样也能找出一个最大的数排在参与第二趟比较的数后面，第三趟比较的时候，只需要比较除了最后两个数以外的其他的数，以此类推……也就是说，没进行一趟比较，每一趟少比较一次，一定程度上减少了算法的量。

用时间复杂度来说：

1.如果我们的数据正序，只需要走一趟即可完成排序。所需的比较次数C和记录移动次数M均达到最小值，即：Cmin=n-1;Mmin=0;所以，冒泡排序最好的时间复杂度为O(n)。

2.如果很不幸我们的数据是反序的，则需要进行n-1趟排序。每趟排序要进行n-i次比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：
　　

2、最终代码实现效果：

package iwork3;

	public class BubbleSort {
	public static void main(String[] args) {
		// 初始化動態數組
	int[] arr =new int[] {43,32,76,-98,0,64,66,33,-21,99};
	// 冒泡排序
		for(int i =0;i<arr.length-1;i++) {
				for(int j=0;j<arr.length-1-i;j++) {
		
		if(arr[j]>arr[j+1]) {
			int temp =arr[j];
			arr[j] =arr[j+1];
			arr[j+1]=temp;
				
		}
		}
		}
			// 遍历出数組的元素值:
			for(int i=0;i<arr.length;i++) {
			 	System.out.print(arr[i]+"\t");	

	}
	}
	}

3、你的答案：最近最火热的一首歌曲送给你。

【转载注明出处，还望尊重原创 】

【作者水平有限，如有错误欢迎指正 .】

 
 
如果我的博客对你有帮助、如果你喜欢我的博客内容，请“点赞” “评论”“收藏”一键三连哦！听说点赞的人运气不会太差，每一天都会元气满满呦！如果实在要白嫖的话，那祝你开心每一天，欢迎常来我博客看看。