谁能帮我讲讲关于快速排序的思路？感谢

http://www.java-cn.com/club/forum.php?mod=viewthread&tid=5370
或者
http://www.java-cn.com/club/forum.php?mod=viewthread&tid=4482

我从网上找的 希望能帮助到你

这个我也不会，不过一般开发中一般不会去写排序函数。会直接调用Arrays.sort();

似水像火 发表于 2013-3-31 15:31
这个我也不会，不过一般开发中一般不会去写排序函数。会直接调用Arrays.sort(); ...

这是基础测试的一道题，所以得会

快速排序？毕老师视频里有快速排序   我记得好像就冒泡很选择吧

快速排序和冒泡排序一样，都属于交换类排序。其排序核心的思想是：设置参照，比参照小的放置在该参照左边，比参照大的放置在右边，这样一趟下来，参照的左边区间都是比其小的元素，右边区间都是比其大的元素，接着，将区间缩小，递归调用，最终得到一个有序的递增序列。额...快速排序很重要的说，学习的时候老考。这里是一个我写过的程序，里面有注解，希望能帮到你哦。。。

1. public class QuickSort {
   
2. 
   
3.         public static void main(String[] args){
   
4.                 //给定数组
   
5.                 int[] arr = {2,14,3,6,5,10,1,2};
   
6.                
   
7.                 //将数组快速排序
   
8.                 Sort(arr);
   
9.                
   
10.                 //打印排序结果
    
11.                 printArr(arr);
    
12.         }
    
13.         public static void Sort(int[] arr){
    
14.                
    
15.                 int start = 0;
    
16.                 int end = arr.length-1;//数组的最大索引位置
    
17.                 quickSort(arr,start,end);//调用关键函数
    
18.                
    
19.         }
    
20.                
    
21.         public static void quickSort(int[] arr,int left,int right){
    
22.                 int i = left;//记录区间起始位置
    
23.                 int j = right;//记录区间末尾位置
    
24.                
    
25.                 //排序出口是left==right
    
26.                 if (left < right) {
    
27.                         int temp = arr[left];//设置临时变量，记录参照点
    
28.                         while(i!=j){
    
29.                                
    
30.                                 //固定i，从右开始寻找小于参照的元素
    
31.                                 while(i<j && arr[j]>temp){
    
32.                                         j--;
    
33.                                 }
    
34.                                 //找到后将其放在i的位置
    
35.                                 if (i<j) {
    
36.                                         arr[i] = arr[j];
    
37.                                         i++;
    
38.                                 }
    
39.                                 //此时j固定，从做开始寻找大于参照的的元素
    
40.                                 while(i<j && arr[i]<temp){
    
41.                                         i++;
    
42.                                 }
    
43.                                
    
44.                                 //找到后将其放在j的位置
    
45.                                 if (i<j) {
    
46.                                         arr[j] = arr[i];
    
47.                                         j--;
    
48.                                 }                       
    
49.                         }
    
50.                        
    
51.                         //当i==j时说明该区间的分配结束，将参照放置在其最终位置，i或j
    
52.                         arr[i] = temp;
    
53.                        
    
54.                         //递归调用排序左区间
    
55.                         quickSort(arr,left,i-1);
    
56.                        
    
57.                         //递归调用排序右区间
    
58.                         quickSort(arr,i+1,right);
    
59.                 }
    
60.         }
    
61.        
    
62.         //打印数组
    
63.         public static void printArr(int[] arr){
    
64.                 for (int i = 0; i < arr.length; i++)
    
65.                         System.out.println(arr[i]);
    
66.         }
    
67. }

复制代码

如果仍有问题，请继续追问，如果问题已解决，请将分类改为已解决，谢谢

//基本思想是：通过一躺排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一不部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
/**
* 快速排序
* date : 2012/11/9
*/

package com.ccsu.arithmetic.sort;

public class QuickSort {
        /**
         * @param array
         * @param p
         * @param q
         * @return 划分位置
         */
        public static int partition(int array[], int p, int q) {
                int x = array[p];

                int i = p;
                for (int j = p + 1; j <= q; j++) {
                        if (array[j] < x) {
                                i += 1;
                                swap(array, i, j);
                        }
                       

                }
                swap(array, p, i);
                return i;
        }

        // 交换数据
        public static void swap(int[] array, int m, int n) {
                int temp = array[m];
                array[m] = array[n];
                array[n] = temp;
        }

        public static void quickSort(int array[], int p, int q) {
                if (p < q) {
                        int r = partition(array, p, q);
                        quickSort(array, p, r - 1);
                        quickSort(array, r + 1, q);
                }
        }

        public static void main(String[] args) {
                int[] array = new int[] { 2, 1, 3, 4, 5, 9, 7, 6 };
                quickSort(array, 0, array.length - 1);
                for (int i : array) {
                        System.out.print(i + "  ");
                }
        }

}