A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

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

7 个回复

倒序浏览
我这就不写代码了,就说下思路,
回复 使用道具 举报
给你推荐个视频,舞动的排序算法,用舞蹈诠释各种排序,保证过目不忘。
回复 使用道具 举报
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
回复 使用道具 举报
说的挺清楚的
回复 使用道具 举报
估计没有比毕老师讲的更详细的了
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马