黑马程序员技术交流社区

标题: 自学数组排序总结 [打印本页]

作者: 逆世界ylm    时间: 2014-12-14 14:01
标题: 自学数组排序总结
1.冒泡排序:

  1. //冒泡排序:相邻的两个元素进行比较,如果符合条件换位。
  2.         public static void sort_2(){
  3.                 int[] arr = {2,5,8,7,4,3};
  4.                 for(int i = 0; i < arr.length-1; i++)
  5.                 {
  6.                         for(int j = 0; j < arr.length-i-1;j++)
  7.                         {
  8.                                 if(arr[j] > arr[j+1])
  9.                                 {
  10.                                         int temp = arr[j];
  11.                                         arr[j] = arr[j+1];
  12.                                         arr[j+1] = temp;
  13.                                 }
  14.                         }
  15.                 }
  16.                 System.out.println(Arrays.toString(arr));
  17.         }
复制代码
冒泡排序是相邻的两个元素比较,这样一轮下来,就可以把最大的确定下来在最后一个位置,然后依次循环。
2.选择排序:

  1. //选择排序,选定一个值和其余的比较,再选择一个值和其余的比较。
  2.         public static void sort_1(){
  3.                 int[] arr = {2,5,8,7,4,3};
  4.                 for(int i = 0;i < arr.length-1;i++){
  5.                         for(int j = i+1;j < arr.length;j++){
  6.                                 if(arr[i] > arr[j]){
  7.                                         int temp = arr[i];
  8.                                         arr[i] = arr[j];
  9.                                         arr[j] = temp;
  10.                                 }
  11.                         }
  12.                 }
  13.                 System.out.println(Arrays.toString(arr));
  14.         }
复制代码
一轮下来可以把第一个位置的元素确立下来。也就是上面代码的最小值。循环依次确立下标位置的值。
3.快速排序;

  1. public static void quick_sort(int[] arr,int l,int r)
  2.         {
  3.                 if(l < r)
  4.                 {
  5.                         int i = l,j = r,x = arr[l];
  6.                         while(i < j)
  7.                                
  8.                         {
  9.                                 while(i < j && arr[j] >= x)
  10.                                         j--;
  11.                                 if(i < j)
  12.                                 {
  13.                                         arr[i++] = arr[j];
  14.                                 }
  15.                                 while(i < j && arr[i] < x)
  16.                                         i++;
  17.                                 if(i < j)
  18.                                 {
  19.                                         arr[j--] = arr[i];
  20.                                 }
  21.                         }
  22.                         arr[i] = x;
  23.                         quick_sort(arr,l,i-1);
  24.                         quick_sort(arr,i+1,r);
  25.                 }
  26.         }
复制代码
快速排序是冒泡的升级版本,他可以提高效率的原因在于减少排序次数,不用每个元素之间都来比较,采用分治的思想,楼主个人比较好记的认为是:先选取一个基数,一般选择第一个数为基数,然后确立这个基数的下标位置。步骤如下:
在下标左右各定两个指针来移动,首先我们拿了第一个数,然后第一个数的坐标0就留下了一个坑,然后我们来选取右边指针比这个基数小的数来填第一个坑;在第一个坑填好后,右边又留下了一个坑,然后我们再在左边选择比基数小的填右边的坑。依次这样进行,我们到左右指针相遇时,在留下的坑上补上我们的这个基数,完成一轮的排序;此时基数左边元素比基数小,右边元素比基数大,然后把左右两边来重复选基数填坑操作。




作者: Honelyboy    时间: 2014-12-14 20:14
学习了,赞一个。
作者: Bali    时间: 2014-12-14 21:07
厉害,赞一个!
作者: relice    时间: 2014-12-14 21:24
快排  不错  学习到了
作者: 吻痕朋    时间: 2014-12-14 21:45
赞一个!!!
作者: 史云龙    时间: 2014-12-14 21:55
我就过来看看。
作者: 7788665544    时间: 2014-12-14 22:11
快速排列学习了!赞一个!
作者: SuperBoy    时间: 2014-12-14 22:26
不错!!!
作者: wzl963358694    时间: 2014-12-14 22:40
三楼说的对
作者: jamsjun    时间: 2014-12-14 23:15
楼主很有钻研精神
作者: 找寻小龙猫    时间: 2014-12-14 23:38
学习了 谢谢楼主
作者: 西风烈123    时间: 2014-12-14 23:49
不错。。。。

作者: YAn.    时间: 2014-12-14 23:51
这个之前看了   倒是没看懂
作者: 逆世界ylm    时间: 2014-12-15 10:19
YAn. 发表于 2014-12-14 23:51
这个之前看了   倒是没看懂

快排的挖坑找位置的??
作者: 南柯一梦境    时间: 2014-12-15 10:38
哇,真厉害啊
作者: as604049322    时间: 2014-12-15 13:47
快排写的很好,在你指导下,对代码作了如下改进
  1.     public static void quickSort(int[] arr,int start,int end){
  2.         if(end-start>1 || (end-start==1 && arr[start]>arr[end])){
  3.             int leftPos=start,rightPos=end,base=arr[start];
  4.             while(leftPos<rightPos){
  5.                 while(leftPos<rightPos && arr[rightPos]>=base) rightPos--;
  6.                 if(leftPos<rightPos) arr[leftPos++]=arr[rightPos];

  7.                 while(leftPos<rightPos && arr[leftPos]<base) leftPos++;
  8.                 if(leftPos<rightPos) arr[rightPos--]=arr[leftPos];
  9.             }
  10.             arr[leftPos]=base;
  11.             //printArr(arr);
  12.             //System.out.println("start:"+start+",end:"+end);
  13.             quick_sort(arr,start,leftPos-1);
  14.             quick_sort(arr,rightPos+1,end);
  15.         }
  16.     }
复制代码

作者: 我只是一只菜鸟    时间: 2014-12-15 14:01
加油还可以加查找数组的
作者: YAn.    时间: 2014-12-15 22:50
逆世界ylm 发表于 2014-12-15 10:19
快排的挖坑找位置的??

没看懂你说的什么意思?




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2