冒泡排序

冒泡排序，就是你水泡一样，往上冒，直接上图解释吧！

这里排的是从小到大，当然，也可以从大到小。

也就是说，第一次排序，一定是把最大值找到了最右边，第二次排序，把剩下的元素里，找出最大值排到右边。因此每排序一次，就少比较一次。

代码实现如下：

1. <font color="rgb(85, 85, 85)">public class Demo{
   
2.         public static void main(String[] args){
   
3.                
   
4.                 //搞个数组
   
5.                 int[] arrays = new int[]{23,11,9,89,120,230};
   
6.                
   
7.                 //排序前输出
   
8.                 printArrays(arrays);
   
9.                
   
10.                 //冒泡排序
    
11.                 maopaoSort(arrays);
    
12.                
    
13.                 //排序后输出
    
14.                 System.out.println("最后结果：");
    
15.                 printArrays(arrays);
    
16.         }
    
17.         public static void maopaoSort(int[] arrays){
    
18.                 for(int i = 0;i<arrays.length;i++){
    
19.                         System.out.println("第"+i+"次排序");
    
20.                         printArrays(arrays);
    
21.                         for(int j = 0;j<arrays.length-i-1;j++){                                
    
22.                                 if(arrays[j]>arrays[j+1]){//从小到大
    
23.                                         int temp = arrays[j];
    
24.                                         arrays[j] = arrays[j+1];
    
25.                                         arrays[j+1] = temp;
    
26.                                 }
    
27.                         }
    
28.                 }
    
29.         }
    
30.         //数组输出方法
    
31.         public static void printArrays(int[] arrays){
    
32.                 System.out.print("[");
    
33.                 for(int i = 0;i<arrays.length;i++){
    
34.                         if(i!=arrays.length-1){
    
35.                                 System.out.print(arrays[i]+",");
    
36.                         }else{
    
37.                                 System.out.println(arrays[i]+"]");
    
38.                         }
    
39.                 }
    
40.         }
    
41. }</font>

复制代码

结果如下：

[23,11,9,89,120,230]
第0次排序
[23,11,9,89,120,230]
第1次排序
[11,9,23,89,120,230]
第2次排序
[9,11,23,89,120,230]
第3次排序
[9,11,23,89,120,230]
第4次排序
[9,11,23,89,120,230]
第5次排序
[9,11,23,89,120,230]
最后结果：
[9,11,23,89,120,230]

相信到这里，你已经懂得了什么 是冒泡排序，赶快动手写写吧，你一定可以做到的！

选择排序

选择排序，是选择出一个元素，然后跟所有的元素逐个比较，根据条件进行切换。

代码体现（这里排列从小到大）

1. <font color="rgb(85, 85, 85)">public class Demo{
   
2.         public static void main(String[] args){
   
3.                
   
4.                 //弄一个数组
   
5.                 int[] arrays = new int[]{12,34,89,10,8};
   
6.                
   
7.                 //排序前先输出一次
   
8.                 printArrays(arrays);
   
9.                
   
10.                 //进行排序
    
11.                 chooseSort(arrays);//我不知道选择是不是这样写的，嘻嘻！我只会说，不会写英语。
    
12.                
    
13.                 //排序前先输出一次
    
14.                 System.out.println("排序后的结果：");
    
15.                 printArrays(arrays);
    
16.                
    
17.         }
    
18.         //选择排序
    
19.         public static void chooseSort(int[] arrays){
    
20.                 for(int i = 0;i<arrays.length;i++){
    
21.                         System.out.println("第"+i+"次排序结果：");
    
22.                         printArrays(arrays);
    
23.                         for(int j = i;j<arrays.length-1;j++){
    
24.                                 if(arrays[i]>arrays[j+1]){
    
25.                                         int temp = arrays[i];
    
26.                                         arrays[i] = arrays[j+1];
    
27.                                         arrays[j+1] = temp;
    
28.                                 }
    
29.                         }
    
30.                 }
    
31.         }
    
32.         //打印数组的函数
    
33.         public static void printArrays(int[] arrays){
    
34.                 System.out.print("[");
    
35.                 for(int i = 0;i<arrays.length;i++){
    
36.                         if(i!=arrays.length-1){
    
37.                                 System.out.print(arrays[i]+",");
    
38.                         }else{
    
39.                                 System.out.println(arrays[i]+"]");
    
40.                         }
    
41.                 }
    
42.         }
    
43. }</font>

复制代码

把结果和图片对象一下吧，我画得很辛苦的，一个字，累呀！只希望大家理解了冒泡和选择排序！

运行结果：

[12,34,89,10,8]
第0次排序结果：
[12,34,89,10,8]
第1次排序结果：
[8,34,89,12,10]
第2次排序结果：
[8,10,89,34,12]
第3次排序结果：
[8,10,12,89,34]
第4次排序结果：
[8,10,12,34,89]
排序后的结果：
[8,10,12,34,89]

好啦，排序就讲到这里啦，另外扯淡一个东西，就是交换元素的方法。

交换元素

在上面的代码中，交换元素主要用了第三方的变量来暂时存放一下。那么有不有不借助第三方变量来交换两个元素的呢？答案是有的哈！

1、通过加减法来交换，但是这种交换有弊端，什么弊端呢，就是这个要是数太大了，超出int的范围了，那就不可以了。

1. <font color="rgb(85, 85, 85)">public class Demo{
   
2.         public static void main(String[] args){
   
3.                
   
4.                 //交换两个数
   
5.                 int x = 8,y = 10;
   
6.                
   
7.                 //方法一：
   
8.                 x = x + y;
   
9.                 y = x - y;
   
10.                 x = x -y;
    
11.                
    
12.                 System.out.println("x = "+x+","+"y="+y);
    
13.         }
    
14. }</font>

复制代码

2、通过位操作来交换两个数

1. <font color="rgb(85, 85, 85)">
   
2. 4
   
3. 5
   
4. 6
   
5. 7
   
6. 8
   
7. 9
   
8. 10
   
9. 11
   
10. 12
    
11. 13
    
12. 14
    
13. public class Demo{
    
14.         public static void main(String[] args){
    
15.                
    
16.                 //交换两个数
    
17.                 int a = 8,b = 10;
    
18.                
    
19.                 //方法二：
    
20.                 a = a^b;
    
21.                 b = a^b;
    
22.                 a = a^b;               
    
23.                
    
24.                 System.out.println("a = "+a+","+"b="+b);
    
25.         }
    
26. }</font>

复制代码

3、通过第三方变量来交换（略），嘻嘻！

好啦，这个排序到此结束，当然还有比较多的排序方法，比如说，插入排序，归并排序，希尔排序，堆排序，恶心多了！

请各路英雄指教！

666666666666666666666666666666666666666666666666666

妈妈再也不用担心我的学习啦，哈哈！

写的不错啊

总统 发表于 2015-9-16 23:23
妈妈再也不用担心我的学习啦，哈哈！

谢谢，还请多多指教。

ddddk 发表于 2015-9-16 23:24
写的不错啊

谢谢，请多多指教

好牛的说额

K_LONG 发表于 2015-9-16 23:30
好牛的说额

自己弄了好久，谢谢支持。

太详细了感谢楼主哈！

楼主这个不错，赞个

妈妈再也不用担心我的学习啦，哈哈！

这总结的够详细!

简直给力。。。

66666666不错 很简单

66666666666666

这个不错

很好，很强大。。。比老毕画的图强。。