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就留下了一个坑，然后我们来选取右边指针比这个基数小的数来填第一个坑；在第一个坑填好后，右边又留下了一个坑，然后我们再在左边选择比基数小的填右边的坑。依次这样进行，我们到左右指针相遇时，在留下的坑上补上我们的这个基数，完成一轮的排序；此时基数左边元素比基数小，右边元素比基数大，然后把左右两边来重复选基数填坑操作。

学习了，赞一个。

厉害，赞一个！

快排  不错  学习到了

赞一个！！！

我就过来看看。

快速排列学习了！赞一个！

不错！！！

三楼说的对

楼主很有钻研精神

学习了 谢谢楼主

不错。。。。

这个之前看了   倒是没看懂

YAn. 发表于 2014-12-14 23:51
这个之前看了   倒是没看懂

快排的挖坑找位置的？？

哇，真厉害啊

快排写的很好，在你指导下，对代码作了如下改进

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

复制代码

加油还可以加查找数组的

逆世界ylm 发表于 2014-12-15 10:19
快排的挖坑找位置的？？

没看懂你说的什么意思?