JAVA数组的排序方法实例
java稳定的排序方法
java稳定的排序方法
Java是一种广泛使用的编程语言，其中排序是常见的操作。
在排序中，稳定性是一个重要的概念。
稳定的排序算法可以保留相等元素的原始顺序，而不稳定的排序算法不保证这一点。
下面介绍几种Java中稳定的排序方法：
1. 冒泡排序：该算法的基本思想是通过交换相邻的元素来将较大的元素逐步“冒泡”到数组的末尾。
冒泡排序是一种简单但效率较低的排序算法，时间复杂度为O(n^2)。
2. 插入排序：该算法的基本思想是将数组分为有序和无序两部分，从无序部分依次取出一个元素插入到有序部分的适当位置。
插入排序的时间复杂度也是O(n^2)，但在实际应用中，它比冒泡排序更常用。
3. 归并排序：该算法的基本思想是将待排序数组分成两个子数组，并将每个子数组递归地进行排序，然后再将它们合并成一个有序数组。
归并排序的时间复杂度为O(nlogn)，但它需要额外的空间来存储子数组。
4. 堆排序：该算法的基本思想是将待排序数组构建为一个最大堆（或最小堆），然后不断取出堆顶元素并重新调整堆，直到所有元素都被取出。
堆排序的时间复杂度为O(nlogn)，但也需要额外的空间来存储堆。
总的来说，以上排序方法都是稳定的。
在实际应用中，我们需要根据数据规模、数据类型和性能需求等因素来选择适当的排序算法。
java arrays.sort 原理
java arrays.sort 原理Java中的Arrays.sort()方法用于对数组进行排序。
该方法使用了一种称为快速排序的算法，其基本原理是分治法。
快速排序的基本步骤如下：1. 选择一个基准元素。
通常选择数组的第一个元素作为基准元素。
2. 将数组分为两个子数组：小于基准元素的子数组和大于基准元素的子数组。
3. 对这两个子数组分别进行快速排序。
4. 将排好序的子数组进行合并，得到最终的排序结果。
在具体实现上，Java中的Arrays.sort()方法使用了双指针技术。
首先，将数组分为左右两个部分，左边的部分都小于基准元素，右边的部分都大于基准元素。
然后，递归地对左右两个部分进行快速排序，直到整个数组都被排好序。
具体来说，以下是Java中Arrays.sort()方法的伪代码实现：'''javapublic static void sort(int[] arr) {quicksort(arr, 0, arr.length - 1);}private static void quicksort(int[] arr, int low, int high) {if low < high {int pivot = partition(arr, low, high);quicksort(arr, low, pivot - 1);quicksort(arr, pivot + 1, high);}}private static int partition(int[] arr, int low, int high) {int pivot = arr[high]; // 选择基准元素为数组的最后一个元素int i = low - 1; // 左指针指向第一个元素的前一个位置for (int j = low; j < high; j++) {if (arr[j] < pivot) {i++; // 左指针右移swap(arr, i, j); // 交换元素}}swap(arr, i + 1, high); // 将基准元素放到正确的位置上return i + 1; // 返回基准元素的索引}private static void swap(int[] arr, int i, int j) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}'''在上述伪代码中，'quicksort()'方法实现了快速排序的基本逻辑，'partition()'方法用于将数组分为左右两个部分，'swap()'方法用于交换两个元素的值。
java倒序排序方法
java倒序排序方法java语言是一种面向对象的编程语言，具有强大的排序功能。
在java中，倒序排序是非常常见的操作，有多种实现方法。
一、使用Collections.reverseOrder()方法java中的Collections类提供了reverseOrder()方法，可以用于倒序排序，该方法返回一个比较器，可以将一个对象列表按照指定的顺序进行排序。
示例代码如下所示：```javaimport java.util.ArrayList;import java.util.Collections;import java.util.List;public class ReverseSortExample {public static void main(String[] args) {List<Integer> numbers = new ArrayList<>();numbers.add(5);numbers.add(2);numbers.add(9);numbers.add(1);numbers.add(7);System.out.println("排序前：" + numbers); Collections.sort(numbers, Collections.reverseOrder()); System.out.println("排序后：" + numbers);}}```输出结果如下所示：```排序前：[5, 2, 9, 1, 7]排序后：[9, 7, 5, 2, 1]```在这个示例中，我们创建了一个包含一些整数的列表，并使用Collections类的sort()方法对其进行排序。
通过传递`Collections.reverseOrder()`作为比较器参数，可以实现倒序排序。
值得注意的是，reverseOrder()方法返回的是一个比较器，它会根据元素的自然顺序进行排序。
java中对List进行分组和排序
java中对List进⾏分组和排序排序对List进⾏排序，有两种办法第⼀个是⽤java提供的⼯具类Collections提供的sort⽅法进⾏排序废话不多说，上代码⾸先定义⼀个Studentpublic class Student {private int age;private String name;public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getName() {return name;}public void setName(String name) { = name;}public Student(int age, String name) {super();this.age = age; = name;}}下⾯是进⾏排序的代码public static void main(String[] args) {List<Student> list= new ArrayList<Student>();list.add(new Student(5, "aa"));list.add(new Student(7, "bb"));list.add(new Student(6, "cc"));Collections.sort(list,new Comparator<Student>(){@Overridepublic int compare(Student o1, Student o2) { //会把集合⾥⾯的对象两两传进⽅法⾥⾯⽐较，这⾥⽐较age，降序就O2-O1，升序就O1-O2 return o2.getAge()-o1.getAge();}});//打印list每⼀项的agelist.forEach(a -> System.out.println(a.getAge()));}}第⼆种⽅法：List集合提供了sort⽅法，依然⽤Student做集合，进⾏排序public static void main(String[] args) {List<Student> list= new ArrayList<Student>();list.add(new Student(5, "aa"));list.add(new Student(7, "bb"));list.add(new Student(6, "cc")); //差别在这⾥，这⾥直接⽤list的sort⽅法，不需要吧list作为参数，其他的和Comparable排序是⼀样的list.sort(new Comparator<Student>(){@Overridepublic int compare(Studento1, Studento2) { //会把集合⾥⾯的对象两两传进⽅法⾥⾯⽐较，这⾥⽐较age，降序就O2-O1，升序就O1-O2 return o2.getAge()-o1.getAge();}});//打印list每⼀项的agelist.forEach(a -> System.out.println(a.getAge()));}}对list进⾏分组：同样的，⽤Student的集合作为⽰例，代码如下public class test2 {/*** 创建⽐较器*/public static <T> List<List<T>> dividerList(List<T> list,Comparator<? super T> comparator) {List<List<T>> lists = new ArrayList<>();for (int i = 0; i < list.size(); i++) {boolean isContain = false;for (int j = 0; j < lists.size(); j++) {if (lists.get(j).size() == 0||pare(lists.get(j).get(0),list.get(i)) == 0) {lists.get(j).add(list.get(i));isContain = true;break;}}if (!isContain) {List<T> newList = new ArrayList<>();newList.add(list.get(i));lists.add(newList);}}return lists;}public static void main(String[] args) {List<Student> list = new ArrayList<Student>(); //实在不会起名字，⽤字母代替吧list.add(new Student(17,"aa"));list.add(new Student(15,"bb"));list.add(new Student(16,"cc"));list.add(new Student(15,"dd"));list.add(new Student(16,"ee"));list.add(new Student(17,"ff"));List<List<Student>> list2 = dividerList(list, new Comparator<Student>() {@Overridepublic int compare(Student o1, Student o2) {// 按年龄分组,这⾥注意⼀点，返回的值为0，就会认为这两个Studeng是⼀组的，返回其他值，则认为不是，所以下⾯的-1可以替换为任意⾮0数字return o1.getAge == o2.getAge ? 0:-1;//也可以按照姓名分组，返回结果如下，因为是⽐较两个值是否相等，所以先后是没有区别的//return o1.getName().compareTo(o1.getName())}});for(List<Student> stList: list2){ stList.forEach(a -> System.out.printIn(a.getName+":"+a.getAge)); System.out.printIn("========================================="); }}}。
java快速排序简单代码
java快速排序简单代码快速排序是一种非常高效的排序算法，它利用了分治的思想，可以在O(n log n)的时间复杂度内完成排序，比其他排序算法的速度要快得多。
在Java中，快速排序的实现并不复杂，下面就来详细介绍。
1. 选取基准点快速排序的第一步是选取基准点，在我们的代码中，我们选取数组的第一个元素为基准点，可以根据需要进行修改。
2. 分区接下来，我们需要将数组中的元素按照基准点进行分区，将比基准点小的元素放置到基准点的左边，比基准点大的元素放置到基准点的右边。
我们可以用两个指针 i 和 j 分别从左边和右边扫描数组，比较大小并交换元素，直到 i >= j。
3. 递归排序分区完成后，我们需要对左右两个分区再次进行快速排序。
我们可以使用递归的方式来实现这一过程，对左分区和右分区分别调用快速排序函数，直到所有分区都变得有序。
下面是快速排序的Java实现代码：public static void quickSort(int[] arr, int left, int right) {if (left >= right) {return;}int pivot = arr[left];int i = left, j = right;while (i < j) {while (i < j && arr[j] >= pivot) {j--;}arr[i] = arr[j];while (i < j && arr[i] <= pivot) {i++;}arr[j] = arr[i];}arr[i] = pivot;quickSort(arr, left, i - 1);quickSort(arr, i + 1, right);}在代码中，我们首先判断了左右指针是否相遇，防止出现越界的情况。
接着，我们选取了左边第一个元素作为基准点，并使用指针 i 和 j 进行分区操作，最后对左右两个分区进行递归排序。
java arraylist排序方法
java arraylist排序方法Java中的ArrayList是一种动态数组，它可以根据需要自动调整大小。
有时，我们需要对ArrayList中的元素进行排序，以便更好地进行数据处理。
在本文中，我们将介绍几种Java中ArrayList排序的方法。
1. 使用Collections.sort()方法Collections.sort()方法可用于对ArrayList进行排序。
该方法使用默认排序顺序对列表中的元素进行排序。
示例代码：```import java.util.ArrayList;import java.util.Collections;public class ArrayListSortingExample {public static void main(String[] args) {ArrayList<String> fruitsList = new ArrayList<String>(); fruitsList.add('Apple');fruitsList.add('Orange');fruitsList.add('Banana');fruitsList.add('Pineapple');fruitsList.add('Kiwi');// Sort the ArrayListCollections.sort(fruitsList);// Print the sorted ArrayListSystem.out.println('Sorted ArrayList: ');for (String fruit : fruitsList) {System.out.println(fruit);}}}```输出结果：```Sorted ArrayList:AppleBananaKiwiOrangePineapple```2. 使用自定义比较器进行排序如果我们需要使用自定义排序顺序对ArrayList中的元素进行排序，我们可以使用Comparator接口和Collections.sort()方法的重载版本。
javaCollections排序--多条件排序实例
javaCollections排序--多条件排序实例我就废话不多说了，⼤家还是直接看代码吧~// 告警排序Collections.sort(domesticAirport, comparator);// 告警排序Comparator<AirportRtWeatherWarningBeanForTable> comparator = new Comparator<AirportRtWeatherWarningBeanForTable>() { @Overridepublic int compare(AirportRtWeatherWarningBeanForTable a1, AirportRtWeatherWarningBeanForTable a2) {// ⾸先根据是否过期排序if(a1.isMetarExpired() && !a2.isMetarExpired()){return 1;}else if (!a1.isMetarExpired() && a2.isMetarExpired()) {return -1;} else if ((a1.isMetarExpired() && a2.isMetarExpired()) || (!a1.isMetarExpired() && !a2.isMetarExpired())) {//同时过期，或者都不过期，则按告警类型排序if (a1.getWarningColor() != a2.getWarningColor()) {return compareColor(a1.getWarningColor(), a2.getWarningColor());}}//告警类型相同，按字母排序return a1.getCode4().compareTo(a2.getCode4());}};// 告警类型⽐较排序public int compareColor(Color color1, Color color2) {int i = 0;int j = 0;if (color1.equals(MeteoWeatherWarningPanel.RED)) {i = 3;} else if (color1.equals(MeteoWeatherWarningPanel.YELLOW)) {i = 2;} else if (color1.equals(MeteoWeatherWarningPanel.GREEN)) {i = 1;}if (color2.equals(MeteoWeatherWarningPanel.RED)) {j = 3;} else if (color2.equals(MeteoWeatherWarningPanel.YELLOW)) {j = 2;} else if (color2.equals(MeteoWeatherWarningPanel.GREEN)) {j = 1;}int k = i - j;if (k > 0) {return -1;} else if (k < 0) {return 1;} elsereturn 0;}补充知识：Collections.sort多字段排序-指定排序⽅式-指定排序字段看代码吧~1、创建需要排序的字段数组String [] sortNameArr = {“one”, “tow”,“startDate”};2、为每个字段执⾏排序规则boolean[] isAs = {false, false, false};3、重写sort⽅法进⾏排序ListUtils.sort(list, sortNameArr, isAs);public static <E> void sort(List<E> list, final String[] sortnameArr, final boolean[] typeArr) {if (sortnameArr.length != typeArr.length) {throw new RuntimeException("属性数组元素个数和升降序数组元素个数不相等");}Collections.sort(list, new Comparator<E>() {public int compare(E a, E b) {int ret = 0;try {for (int i = 0; i < sortnameArr.length; i++) {ret = pareObject(sortnameArr[i], typeArr[i], a, b);if (0 != ret) {break;}}} catch (Exception e) {e.printStackTrace();}return ret;}});}private static <E> int compareObject(final String sortname, final boolean isAsc, E a, E b) throws Exception { int ret;Object value1 = ListUtils.forceGetFieldValue(a, sortname);Object value2 = ListUtils.forceGetFieldValue(b, sortname);// 两个字段都不为空进⾏排序if (null != value1 && null != value2) {String str1 = value1.toString();String str2 = value2.toString();if (value1 instanceof Number && value2 instanceof Number) {int maxlen = Math.max(str1.length(), str2.length());str1 = ListUtils.addZero2Str((Number) value1, maxlen);str2 = ListUtils.addZero2Str((Number) value2, maxlen);} else if (value1 instanceof Date && value2 instanceof Date) {// ⽇期排序long time1 = ((Date) value1).getTime();long time2 = ((Date) value2).getTime();int maxlen = Long.toString(Math.max(time1, time2)).length();str1 = ListUtils.addZero2Str(time1, maxlen);str2 = ListUtils.addZero2Str(time2, maxlen);}if (isAsc) {ret = pareTo(str2);} else {ret = pareTo(str1);}return ret;} else if (null == value1 && null != value2) {// ⽐值为空被⽐值⼤ret = 1;} else {// 被⽐值为空⽐值打ret = -1;}return ret;}public static String addZero2Str(Number numObj, int length) {NumberFormat nf = NumberFormat.getInstance();// 设置是否使⽤分组nf.setGroupingUsed(false);// 设置最⼤整数位数nf.setMaximumIntegerDigits(length);// 设置最⼩整数位数nf.setMinimumIntegerDigits(length);return nf.format(numObj);}public static Object forceGetFieldValue(Object obj, String fieldName) throws Exception {Field field = obj.getClass().getDeclaredField(fieldName);Object object = null;boolean accessible = field.isAccessible();if (!accessible) {// 如果是private,protected修饰的属性，需要修改为可以访问的field.setAccessible(true);object = field.get(obj);// 还原private,protected属性的访问性质field.setAccessible(accessible);return object;}object = field.get(obj);return object;}以上这篇java Collections 排序--多条件排序实例就是⼩编分享给⼤家的全部内容了，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。
java 中lambda排序用法
java 中lambda排序用法在Java中，Lambda表达式可以非常方便地用于排序操作。
在使用Lambda表达式进行排序时，通常会结合使用Java中的函数式接口和Stream API。
下面我将从多个角度来介绍Java中Lambda排序的用法。
首先，Lambda表达式可以用于对集合进行排序。
例如，如果我们有一个包含整数的List，我们可以使用`Collections.sort`方法结合Lambda表达式来对其进行排序。
示例代码如下：java.List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5);Collections.sort(numbers, (a, b) -> pareTo(b));System.out.println(numbers);在这个例子中，`(a, b) -> pareTo(b)`就是一个Lambda表达式，它表示对两个整数进行比较。
在这里，我们使用了`Collections.sort`方法来对numbers进行排序，其中第二个参数就是一个Lambda表达式，它定义了排序的规则。
除了使用`Collections.sort`方法，我们还可以使用Stream API中的`sorted`方法来对集合进行排序。
示例代码如下：java.List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");List<String> sortedNames = names.stream()。
.sorted((a, b) ->pareTo(b))。
.collect(Collectors.toL ist());System.out.println(sortedNames);在这个例子中，我们使用了Stream API的`sorted`方法，它接受一个Comparator作为参数，我们可以使用Lambda表达式来定义这个Comparator，从而实现对字符串列表的排序操作。
java list string排序方法
java list string排序方法Java List String排序方法本文将详细介绍Java中对List进行排序的各种方法。
方法一：使用()方法使用Collections类中的sort()方法，可以很方便地对List 进行排序。
List<String> list = new ArrayList<>();// 添加元素到List中(list);方法二：使用Comparator接口如果需要根据特定的规则对List进行排序，可以使用Comparator接口。
List<String> list = new ArrayList<>();// 添加元素到List中(new Comparator<String>() {@Overridepublic int compare(String s1, String s2) {// 按照自定义规则比较s1和s2的大小return (s2);}});方法三：使用Lambda表达式使用Lambda表达式可以更加简洁地实现List的排序。
List<String> list = new ArrayList<>();// 添加元素到List中((s1, s2) -> (s2));方法四：使用Stream API使用Java 8引入的Stream API，也可以对List进行排序。
List<String> list = new ArrayList<>();// 添加元素到List中list = ().sorted().collect(());方法五：使用自定义排序规则可以根据业务需求自定义排序规则，例如按照字符串长度进行排序。
List<String> list = new ArrayList<>();// 添加元素到List中((String::length));注意事项•使用以上方法时，需要确保List中的元素实现了Comparable接口，或者在使用Comparator时传入自定义的比较器。
java8集合自定义排序方法
java8集合自定义排序方法Java 8新增了一些功能，使得在集合中进行自定义排序变得更加简单和灵活。
在Java 8中，可以使用lambda表达式和函数式接口来实现自定义排序方法。
在Java 8中，集合类（如List、Set、Map）都新加了一个sort方法，该方法接收一个Comparator接口的实现作为参数，用于定义自定义排序规则。
Comparator接口是一个函数式接口，只有一个抽象方法compare(Object obj1, Object obj2)。
该方法接收两个对象作为参数，返回一个int类型的值，用于比较两个对象的大小。
其中，返回值为负数表示obj1应排在obj2之前，返回值为正数表示obj1应排在obj2之后，返回值为0表示两个对象相等。
下面是一个例子，展示如何使用lambda表达式和Comparator接口来实现自定义排序：List<String> names = Arrays.asList("Bob", "Alice", "Charlie", "David");使用lambda表达式和Comparator接口排序names.sort((String name1, String name2) -> name1pareTo(name2));打印排序后的结果names.forEach(System.out::println);在上面的例子中，首先创建了一个包含四个字符串的List对象names。
然后使用sort方法和lambda表达式来定义自定义排序规则。
在lambda表达式中，调用了String类的compareTo方法来比较两个字符串的大小。
最后使用forEach方法遍历并打印排序后的结果。
除了使用lambda表达式，还可以使用方法引用来实现自定义排序。
方法引用是一种简化lambda表达式的语法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
冒泡排序法1.public class SortArray_01 {2. public static void main(String args[]) {3. int[] array = { 14, 5, 86, 4, 12, 3, 21, 13, 11, 2, 55}; // 创建一个初始化的一维数组array4. System.out.println("未排序的数组:");5. for (int i = 0; i < array.length; i++) {// 遍历array数组中的元素6. System.out.print(" " + array[i]);// 输出数组元素7. if ((i + 1) % 5 == 0) //每5个元素一行8. System.out.println();9. }10. int mid; // 定义一个中间变量，起到临时存储数据的作用11. for (int i = 0; i < array.length; i++) { // 执行冒泡排序法12. for (int j = i; j < array.length; j++) {13. if (array[j] < array[i]) {14. mid = array[i];15. array[i] = array[j];16. array[j] = mid;17. }18. }19. }20. System.out.println("\n使用冒泡法排序后的数组:");21. for (int i = 0; i < array.length; i++) { //遍历排好序的array数组中的元素22. System.out.print(" " + array[i]); //输出数组元素23. if ((i + 1) % 5 == 0)24. System.out.println(); // 每5个元素一行25. }26. }27.}数组递增排序1.import java.util.Arrays;2.import java.util.Random;3.4.public class SortArray_02 {5. public static void main(String[] args) {6. Random rd = new Random();7. int[] array = new int[15]; // 声明数组8. System.out.println("没有使用sort方法前的数组：");9. for (int i = 0; i < array.length; i++) { // 利用随机数随意产生15个0～20之间的随机数10. array[i] = rd.nextInt(20); // 给array数组赋值11. System.out.print(" " + array[i]);12. if ((i + 1) % 5 == 0)13. System.out.println();14. }15. Arrays.sort(array); // 对array数组进行升序排序16. System.out.println("\n使用sort方法后的数组：");17. for (int i = 0; i < array.length; i++) { // 将array数组中的数据输出18. System.out.print(" " + array[i]);19. if ((i + 1) % 5 == 0)20. System.out.println();21. }22. }23.}部分数组递增排序1.import java.util.Arrays;2.import java.util.Random;3.4.public class SortArray_03 {5. public static void main(String[] args) {6. Random rd = new Random();7. int[] array = new int[15]; // 声明数组8. System.out.println("没有使用sort方法前的数组：");9. for (int i = 0; i < array.length; i++) { // 利用随机数随意产生15个0～20之间的随机数10. array[i] = rd.nextInt(20); // 给array数组赋值11. System.out.print(" " + array[i]);12. if ((i + 1) % 5 == 0)13. System.out.println();14. }15. Arrays.sort(array,5,14); // 对array数组中的第5个元素～第13个元素之间进行升序排序16. System.out.println("\n使用sort方法后的数组：");17. for (int i = 0; i < array.length; i++) { // 将array数组中的数据输出18. System.out.print(" " + array[i]);19. if ((i + 1) % 5 == 0)20. System.out.println();21. }22. }23.}选择排序法1.public class SortArray_04 {2. public static void main(String args[]) {3. int[] array = { 14, 5, 86, 4, 12, 3, 51, 13, 11, 2, 32,6 }; // 创建一个初始化的一维数组array4. int keyValue; // 表示最小的元素值5. int index; // 表示最小的元素值的下标6. int temp; // 中间变量7. System.out.println("未排序的数组:");8. for (int i = 0; i < array.length; i++) { // 遍历array数组中的元素9. System.out.print(" " + array[i]); // 输出数组元素10. if ((i + 1) % 5 == 0) // 每5个元素一行11. System.out.println();12. }13. for (int i = 0; i < array.length; i++) { // 使用选择排序法的核心14. index = i;15. keyValue = array[i];16. for (int j = i; j < array.length; j++)17. if (array[j] < keyValue) {18. index = j;19. keyValue = array[j];20. }21. temp = array[i];22. array[i] = array[index];23. array[index] = temp;24. }25. System.out.println("\n使用选择排序法后的数组:");26. for (int i = 0; i < array.length; i++) { // 遍历排好序的array数组中的元素27. System.out.print(" " + array[i]); // 输出数组元素28. if ((i + 1) % 5 == 0)29. System.out.println(); // 每5个元素一行30. }31. }32.}快速排序法0.public class SortArray_05 {1. public static void main(String args[]) {2. int[] intArray = { 12, 11, 45, 6, 8, 43, 40, 57, 3, 20,15 };3. System.out.println("排序前的数组:");4. for (int i = 0; i < intArray.length; i++) {5. System.out.print(" " + intArray[i]); //输出数组元素6. if ((i + 1) % 5 == 0) // 每5个元素一行7. System.out.println();8. }9. System.out.println();10. int[] b = quickSort(intArray, 0, intArray.length - 1);// 调用quickSort11. System.out.println("使用快迅排序法后的数组:");12. for (int i = 0; i < b.length; i++) {13. System.out.print(" " + b[i]);14. if ((i + 1) % 5 == 0) // 每5个元素一行15. System.out.println();16. }17. }18. public static int getMiddle(int[] array, int left, int right) {19. int temp;20. // 进行一趟快速排序,返回中心点位置21. int mid = array[left]; // 把中心置于a[0]22. while (left < right) {23. while (left < right && array[right] >= mid)24. right--;25. temp = array[right]; // 将比中心点小的数据移动到左边26. array[right] = array[left];27. array[left] = temp;28. while (left < right && array[left] <= mid)29. left++;30. temp = array[right]; // 将比中心点大的数据移动到右边31. array[right] = array[left];32. array[left] = temp;33. }34. array[left] = mid; // 中心移到正确位置35. return left; // 返回中心点36. }37. public static int[] quickSort(int[] array, int left, int right) {// 快速排序法38. if (left < right - 1) { // 如果开始点和结点没有重叠的时候，也就是指针没有执行到结尾39. int mid = getMiddle(array, left, right); //重新获取中间点40. quickSort(array, left, mid - 1);41. quickSort(array, mid + 1, right);42. }43. return array;44. }45.}。