我希望把思路写的特别清晰，告诉我怎么实现数组的排序，把思路写完整，对代码要求不高，最主要是思路

我这就不写代码了，就说下思路，

给你推荐个视频，舞动的排序算法，用舞蹈诠释各种排序，保证过目不忘。

l939 发表于 2014-5-30 08:21
我这就不写代码了，就说下思路，

对于数组的操作，其实就是在操作它的角标，那么，我们就可以用相邻的角标来进行比较，
： arr[0] 比 arr[1]
    arr[1] 比 arr[2]
    arr[2] 比 arr[3]
....比的过程中，我们需要拿一个变量来存储每次比较的值，存储较大的数，然后让较大的数靠后，这样比完后，最大的数就已经得到了，然后开始第二次比较

注意：比到最后一个角标的时候，比如，arr[]  长度是5，那么当比到arr[4]的时候，就没比要在比了，因为arr[4]只能和arr[5]比较，而现在的数组没有角标arr[5]，所以，你循环遍历的时候，外循环里，不必要循环到最后一个角标，也就是  for(int x = 0; x<arr.length-1; x++)，
当然，还有内循环，for(int y=x+1;y<arr.length-x-1;y++)这里减 (x和1) 的原因，是因为，每次循环的最大值就已经在后面了，所以没必要再去比较后面的的角标，也就是
[img]D:\javaEE\Java\day04\冒泡排序.bmp[/img]
让最大的角标每次循环后就往左移动一位

这样的效果就是：
          25 12  3   22   7  6
第一次 12 3    22 7     6  25
第二次 3   12  7   6     22 25
第三次 3   7    6   12   22 25
第四次 3   6    7   12   22 25
.....看，排序已经完成了，每次都必然得到一个最大的值

我来试试吧，结合代码说，说的不清楚请见谅。
所谓冒泡排序就是将相邻的两个元素进行比较，每进行一次内循环比较后最大值或者最小值都会排到数组的最后。
数组排序常见的会使用到循环嵌套，最常用的是for循环嵌套。
冒泡排序法的外for循环变量的增加是为了控制内循环的循环次数，通过内循环的x<arr.length-x-1来控制，同时这句的（-1）是为了防止数组角标越界

1. static void maoPaoSort(int[] array)
   
2.         {
   
3.                 for(int x=0;x<array.length-1;x++)//外循环每运行一次
   
4.                 {
   
5.                         for(int y=0;y<array.length-x-1;y++)//内循环就减少一次循环次数
   
6.                         {
   
7.                                 if(array[y]>array[y+1])//比较相邻元素
   
8.                                 {
   
9.                                         swap(array,y,y+1);//满足条件交换值
   
10.                                 }
    
11.                         }
    
12.                 }
    
13.         }

复制代码

1. private static void swap(int[] array,int a,int b)//元素值交换位置的功能
   
2.         {
   
3.                 int temp=array[a];
   
4.                 array[a]=array[b];
   
5.                 array[b]=temp;
   
6.         }

复制代码

个人愚见，说得不清晰请见谅，，，，

1. class ArrayTest2
   
2. {
   
3.         public static void bubbleSort(int[] arr)//定义函数功能，实现对数组的冒泡排序
   
4.         {/**冒泡排序的原理在于，从第一个角标的元素开始，与相邻的右边的数组元素比较，若相邻右边的元素小         于第一个角标的元素，则两个元素位置互换，角标值加一，进行下一个比较运算，最终得到的数组中最大角标的元素为该数组中的最大值，此时回到左边第一个角标元素，开始第二次比较，且最右边的最大角标元素不需要再参与比较，即每一次比较的元素减少。*/
   
5.                 for(int x=0;x<arr.length-1;x++)//
   
6.                 {
   
7.                         for(int y=0;y<arr.length-x-1;y++)//让每一次比较的元素减少，-x。避免角标越界。
   
8.                         {
   
9.                                 if(arr[y]>arr[y+1])//相邻的两个元素比较。若条件表达式成立，则互换位置。
   
10.                                 {
    
11.                                         int temp=arr[y];
    
12.                                         arr[y]=arr[y+1];
    
13.                                         arr[y+1]=temp;
    
14.                                 }       
    
15.                         }
    
16.                 }
    
17.         }
    
18.         public static void main(String[] args)
    
19.         {
    
20.                 int[] arr={12,5,17,30,4,7};
    
21.                 bubbleSort(arr);//调用函数功能，对数组元素进行排序。
    
22.                 printArray(arr);//打印排序后的数组元素。
    
23.                
    
24.         }
    
25.         public static void printArray(int[] arr)//定义功能，打印数组元素
    
26.         {
    
27.                 System.out.print("[");
    
28.                 for(int a=0;a<arr.length;a++)
    
29.                 {
    
30.                         if(a!=arr.length-1)
    
31.                                 System.out.print(arr[a]+",");
    
32.                         else
    
33.                                 System.out.print(arr[a]);
    
34.                 }
    
35.                 System.out.print("]");
    
36.         }
    
37. }

复制代码

以上代码中，冒泡排序的函数中有个嵌套循环，外循环代表冒泡排序每执行一圈，x的值加一，为内循环控制每一圈比较的元素个数铺垫，以y<arr.length-x-1来使每次比较的元素减少一个。内循环则执行一圈的完整的比较过程。
但愿我的解释对你有帮助。有不明白的再问我。多交流。:P

说的挺清楚的

估计没有比毕老师讲的更详细的了