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

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© qiaojinhui 中级黑马   /  2013-5-13 18:10  /  1801 人查看  /  4 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 qiaojinhui 于 2013-5-13 20:44 编辑

对一组整数如何实现快速排列?请标注注视,尽量详细。谢谢。

4 个回复

倒序浏览
package com.itheima;


public class Test3 {

        public static void println(int array[], int len) {// 打印数组。。

                for (int i = 0; i < len; i++) {
                        System.out.print(array[i] + " ");
                }

                System.out.println();
        }

        public static void swap(int array[], int i, int j) {// 交换array[i],array[j]的值。
                int temp = array[i];

                array[i] = array[j];

                array[j] = temp;
        }

        public static int partition(int array[], int low, int high) {// 划分过程的方法,low为最低端下标,high为最高端下标
                // 基准点,即把这个数放到它应该在的位置。
                // 什么是应该在的问题?即把它左边的数都小于等于它,右边的数都大于等于它。
                int pv = array[low];// 用最低端的元素初始化基准。

                while (low < high) {// 结束条件为low 和 high 交汇的时候。
                        while ((low < high) && (array[high] >= pv)) {// 如果array[high]比基准点大high--,否则不满足退出循环。
                                high--;// 为什么high--呢,因为该数大于等于基准点,的确应该在基准点左边。没错,所以可以high--,查看上一个数,是否也同样满足。
                        }

                        swap(array, low, high);// 不满足,即array[high]位置的数小于基准点的数,则交换两元素位置。
                        // 为什么交换呢,因为基准点的右边只允许放比它大的数,比它小的数,当然放基准点的左边了。
                        while ((low < high) && (array[low] <= pv)) {// 如果array[low]比基准点小high++,否则不满足退出循环。
                                low++;// 为什么high++呢,因为该数小于等于基准点,应该在基准点左边,没错。所以可以high++,查看上一个数,是否也同样满足。
                        }

                        swap(array, low, high);// 否则交换array[low],array[high]的值。
                        // 为什么交换呢,因为基准点的左边只允许放比它小的数,比它大的数,当然放基准点的右边了。
                }

                return low;// 返回划分好的位置,即它的左边的数都比它小,右边都比它大。
        }

        public static void QSort(int array[], int low, int high) {
                if (low < high) {
                        int pivot = partition(array, low, high);// 划分array数组的low~high范围,划分后,基准点pivot左边数的都比array[len]小,基准点pivot右边的数都比大。此时array[pivot]在它应该在位置.
                        QSort(array, low, pivot - 1);// 递归快排pivot左边的数。
                        QSort(array, pivot + 1, high);// 递归快排pivot右边的数。
                }
        }

        public static void QuickSort(int array[], int len) {
                QSort(array, 0, len - 1);
        }

        public static void main(String[] args) {
                int array[] = { 1, 5, 100, 22, 21, 25, 49, 25, 16, 8 };// 定义并初始化,数组。
                int len = 10;// 数组长度.

                println(array, len);// 打印排序前的数组。
                QuickSort(array, len);// 快排
                println(array, len);// 打印快排后的数组。
        }
}
以前写的。看能不能帮到楼主。
回复 使用道具 举报
嗯,谢谢你!
回复 使用道具 举报
快速排序思路:
1,任意选择一个元素作为"枢轴"(我选的第1个元素)。
2,将小于枢轴的元素移动到枢轴之前, 大于枢轴的元素移动到枢轴之后。将数组分成以枢轴为中心的两个部分。
3,将第2步分成的两个部分,进行递归分区。当每个分区只剩一个元素的时候,排序完成。
  1. public class Test1 {         
  2.        
  3.         //置换数组中两个元素的值
  4.         public static void swap(int[] arr,int a,int b)
  5.         {
  6.                 int temp = arr[a];
  7.                 arr[a] = arr[b];
  8.                 arr[b] = temp;
  9.         }
  10.        
  11.         //对数组进行快速排序
  12.         public static void quickSort(int[] arr)
  13.         {
  14.                 quickSort(arr, 0, arr.length-1);
  15.         }
  16.        
  17.         //对数组中的子序列arr[low..high]进行快速排序
  18.         public static void quickSort(int[] arr,int low,int high)
  19.         {
  20.                 //用于记录枢轴位置
  21.                 int pivotLoc;
  22.                 if(low<high)
  23.                 {
  24.                         //将arr[low..high]按元素大小一分为二,pivotLoc是枢轴位置。
  25.                         pivotLoc = partition(arr,low,high);
  26.                         //对小于枢轴的低子序列进行递归排序。
  27.                         quickSort(arr, low, pivotLoc-1);
  28.                         //对大于枢轴的高子序列递归排序。
  29.                         quickSort(arr, pivotLoc+1, high);
  30.                 }
  31.         }
  32.        
  33.         //交换数组中子序列arr[low..high]的数值,使枢轴记录到位,并返回枢轴所在位置。此时在它之前的元素均小于它,在它之后的元素均大于它。
  34.         public static int partition(int[] arr,int low,int high)
  35.         {
  36.                 //用第1个元素作为枢轴初始值。
  37.                 int pivotKey = arr[low];
  38.                 //从子序列的两端交替的向中间扫描。
  39.                 while(low<high)
  40.                 {
  41.                         //子序列高端元素值大于枢轴
  42.                         while(low<high && arr[high]>=pivotKey)
  43.                                 //高端向低移,继续比较
  44.                                 high--;
  45.                         //将比枢轴小的元素交换到低端
  46.                         swap(arr,low,high);
  47.                        
  48.                         //子序列低端元素值小于枢轴
  49.                         while(low<high && arr[low]<=pivotKey)
  50.                                 //低端向高移,继续比较
  51.                                 low++;
  52.                         //将比枢轴大的元素交换到高端
  53.                         swap(arr,low,high);       
  54.                 }
  55.                 //返回枢轴所在位置
  56.                 return low;
  57.         }
  58.        
  59.         //打印数组
  60.         public static void printArray(int[] arr)
  61.         {
  62.                 System.out.print("[");
  63.                 for(int i=0;i<arr.length;i++)
  64.                 {
  65.                         if(i != arr.length-1)
  66.                                 //不是最后一个元素用", "分隔
  67.                                 System.out.print(arr[i]+", ");
  68.                         else
  69.                                 //最后一个元素,用"]"结束,并换行
  70.                                 System.out.println(arr[i]+"]");
  71.                 }
  72.                
  73.         }
  74.        
  75.         public static void main(String[] args) {
  76.                 int[] arr = {5,8,4,7,9,3,1,6,2};
  77.                 System.out.print("排序前的数组:");
  78.                 //打印数组
  79.                 printArray(arr);
  80.                
  81.                 //快速排序
  82.                 quickSort(arr);
  83.                
  84.                 System.out.print("排序后的数组:");
  85.                 //打印数组
  86.                 printArray(arr);
  87.         }

  88. }
复制代码
回复 使用道具 举报
Arrays.sort();java自带的排序方法,用它最快速。
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马