一些排序算法JAVA实现

合集下载

java 经典笔试算法题

java 经典笔试算法题一、排序算法1. 实现一个基于Java的快速排序算法。

答：快速排序是一种常用的排序算法，其核心思想是分治法。

首先选择一个基准元素，将数组分成两部分，一部分小于基准元素，一部分大于基准元素。

然后递归地对这两部分继续进行快速排序，直到整个数组有序。

2. 实现一个稳定的冒泡排序算法。

答：冒泡排序是一种简单的排序算法，通过重复地遍历待排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。

稳定的冒泡排序算法是指在排序过程中，相同元素的相对位置不会改变。

3. 实现一个选择排序算法。

答：选择排序是一种简单直观的排序算法。

其工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

二、字符串操作算法1. 实现一个函数，将一个字符串反转。

答：可以使用StringBuilder类的reverse()方法来实现字符串的反转。

2. 实现一个函数，将一个字符串中的所有大写字母转换为小写字母，其余字符保持不变。

答：可以使用String类的replaceAll()方法和toLowerCase()方法来实现。

3. 实现一个函数，将一个字符串按空格分割成单词数组，并删除空字符串和null字符串。

答：可以使用split()方法和Java 8的流来处理。

三、数据结构算法1. 实现一个单向链表，并实现插入、删除、查找和打印链表的功能。

答：单向链表是一种常见的数据结构，可以通过定义节点类和链表类来实现。

插入、删除、查找和打印链表的功能可以通过相应的方法来实现。

2. 实现一个二叉搜索树（BST），并实现插入、查找、删除节点的功能。

答：二叉搜索树是一种常见的数据结构，它具有唯一的高度特性。

插入、查找和删除节点的功能可以通过相应的方法来实现，如左旋、右旋、递归等。

3. 实现一个哈希表（HashMap），并实现插入、查找和删除键值对的功能。

答：HashMap是一种基于哈希表的映射数据结构，它通过哈希码的方式将键映射到对应的值上。

java倒序排序方法 -回复

java倒序排序方法-回复Java倒序排序方法Java是一种常用的编程语言，在开发过程中，经常需要对数据进行排序。

排序是一种将数据按照特定规则进行排列的过程。

除了普通的升序排序，有时候我们也需要对数据进行倒序排序。

在Java中，倒序排序可以通过多种方式实现。

本文将一步一步回答你关于Java倒序排序方法的问题，帮助你更好地理解和运用。

第一步：了解排序方法在进行倒序排序之前，我们需要首先了解正常的排序方法。

Java提供了常用的排序算法，例如冒泡排序、选择排序、插入排序、快速排序等。

这些排序方法都是按照不同的规则对数据进行排列。

冒泡排序是一种简单但效率较低的排序算法。

它重复地将相邻的两个元素进行比较和交换，从而将最大或最小的元素逐渐“浮动”到数组的顶部或底部。

选择排序是一种比较直观的排序算法。

它将数组分为已排序和未排序两部分，每次从未排序部分中选择最小（或最大）的元素，放入已排序部分的末尾。

插入排序是一种简单但高效的排序算法。

它通过构建有序序列，对于未排序的数据，在已排序的序列中从后向前扫描，找到相应位置并插入。

快速排序是一种常用的排序算法，它通过递归地将数组分为较小和较大的两个子数组，并对这两个子数组进行排序。

快速排序的核心是选择一个主元（pivot），将小于主元的元素放在左侧，大于主元的元素放在右侧，然后分别对这两个子数组进行递归排序。

第二步：将排序方法应用到倒序排序现在我们已经了解了常用的排序方法，接下来将这些方法应用到倒序排序中。

倒序排序就是将按照特定规则排列好的数据，在排列的基础上进行颠倒。

对于冒泡排序，我们可以改变两个元素比较时的规则，将“大于”改为“小于”，从而达到倒序排序的效果。

对于选择排序，我们可以一开始就选择未排序部分中的最大（或最小）的元素，放入已排序部分的开头，这样就实现了倒序排序。

对于插入排序，我们可以从原代码中不做改动，但在将未排序的数据插入已排序序列时，调整插入位置的规定。

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中的按字典排序方法

java中的按字典排序方法在Java中，可以使用不同的方法对字符串进行字典排序。

下面将介绍几种用于字典排序的常见方法。

1. 字符串数组排序如果有一个字符串数组需要进行字典排序，可以使用Arrays类中的sort()方法进行排序。

这个方法使用的是快速排序算法，可以对字符串数组按字典顺序进行排序。

例如：javaimport java.util.Arrays;public class DictionarySort {public static void main(String[] args) {String[] words = {"java", "c++", "python", "ruby"};字典排序Arrays.sort(words);输出排序结果for (String word : words) {System.out.println(word);}}}输出结果为：c++javapythonruby2. 字符串列表排序如果有一个字符串列表需要进行字典排序，也可以使用Collections类中的sort()方法进行排序。

这个方法使用的是归并排序算法，可以对字符串列表按字典顺序进行排序。

例如：javaimport java.util.ArrayList;import java.util.Collections;public class DictionarySort {public static void main(String[] args) {ArrayList<String> words = new ArrayList<>();words.add("java");words.add("c++");words.add("python");words.add("ruby");字典排序Collections.sort(words);输出排序结果for (String word : words) {System.out.println(word);}}}输出结果为：c++javapythonruby3. 自定义比较器排序如果想要根据自定义规则进行字典排序，可以实现Comparator接口并重写compare()方法。

实现排列组合算法的java代码

实现排列组合算法的java代码在Java中，我们可以使用递归或迭代的方法来实现排列和组合。

以下是使用递归方法实现的示例：javaimport java.util.ArrayList;import java.util.List;public class PermutationsCombinations {// 计算排列public static void permute(List<Integer> list, int k) {if (k == list.size()) {System.out.println(list);} else {for (int i = k; i < list.size(); i++) {swap(list, i, k);permute(list, k + 1);swap(list, i, k); // backtrack}}}// 计算组合public static void combine(List<Integer> list, int k) {if (k == 1) {System.out.println(list);} else {for (int i = 0; i < list.size(); i++) {swap(list, 0, i);combine(list, k - 1);swap(list, 0, i); // backtrack}}}// 交换元素的方法private static void swap(List<Integer> list, int i, int j) { int temp = list.get(i);list.set(i, list.get(j));list.set(j, temp);}public static void main(String[] args) {List<Integer> list = new ArrayList<>();list.add(1);list.add(2);list.add(3);permute(list, 0); // 计算排列System.out.println();combine(list, 2); // 计算组合}}在这个代码中，permute函数是用来计算给定列表的排列的，而combine函数是用来计算给定列表的组合的。

哈希排序算法java实现

哈希排序算法java实现哈希排序算法的Java实现哈希排序算法是一种基于哈希表的排序算法，它利用哈希函数将元素映射到桶中，并通过对桶中的元素进行排序，最终得到有序的结果。

在本文中，我们将介绍哈希排序算法的原理，并给出其Java实现。

一、算法原理哈希排序算法的核心思想是利用哈希函数将元素映射到桶中，然后对桶中的元素进行排序。

具体步骤如下：1. 创建一个哈希表，用于存储桶。

2. 根据哈希函数将待排序的元素分配到相应的桶中。

3. 对每个桶中的元素进行排序，可以使用插入排序或其他排序算法。

4. 将每个桶中的元素按顺序合并到一个有序数组中，即为最终的排序结果。

二、Java实现下面是哈希排序算法的Java实现代码：```javaimport java.util.ArrayList;import java.util.Collections;public class HashSort {public static void hashSort(int[] arr) {// 创建一个哈希表，用于存储桶ArrayList<ArrayList<Integer>> buckets = new ArrayList<>();int max = arr[0], min = arr[0];int bucketNum;// 找出待排序数组中的最大值和最小值for (int i = 1; i < arr.length; i++) {if (arr[i] > max) {max = arr[i];}if (arr[i] < min) {min = arr[i];}}// 计算桶的数量bucketNum = (max - min) / arr.length + 1;// 初始化桶for (int i = 0; i < bucketNum; i++) {buckets.add(new ArrayList<>());}// 根据哈希函数将元素分配到相应的桶中for (int i = 0; i < arr.length; i++) {int index = (arr[i] - min) / arr.length;buckets.get(index).add(arr[i]);}// 对每个桶中的元素进行排序for (ArrayList<Integer> bucket : buckets) {Collections.sort(bucket);}// 将每个桶中的元素按顺序合并到一个有序数组中 int index = 0;for (ArrayList<Integer> bucket : buckets) {for (int num : bucket) {arr[index++] = num;}}}public static void main(String[] args) {int[] arr = {9, 5, 7, 3, 1, 6, 8, 2, 4};hashSort(arr);for (int num : arr) {System.out.print(num + " ");}}}```在上述代码中，我们首先找出待排序数组中的最大值和最小值，然后根据哈希函数将元素分配到相应的桶中。

用Java实现常见的8种内部排序算法

⽤Java实现常见的8种内部排序算法⼀、插⼊类排序插⼊类排序就是在⼀个有序的序列中，插⼊⼀个新的关键字。

从⽽达到新的有序序列。

插⼊排序⼀般有直接插⼊排序、折半插⼊排序和希尔排序。

1. 插⼊排序1.1 直接插⼊排序/*** 直接⽐较，将⼤元素向后移来移动数组*/public static void InsertSort(int[] A) {for(int i = 1; i < A.length; i++) {int temp = A[i]; //temp ⽤于存储元素，防⽌后⾯移动数组被前⼀个元素覆盖int j;for(j = i; j > 0 && temp < A[j-1]; j--) { //如果 temp ⽐前⼀个元素⼩，则移动数组A[j] = A[j-1];}A[j] = temp; //如果 temp ⽐前⼀个元素⼤，遍历下⼀个元素}}/*** 这⾥是通过类似于冒泡交换的⽅式来找到插⼊元素的最佳位置。

⽽传统的是直接⽐较，移动数组元素并最后找到合适的位置*/public static void InsertSort2(int[] A) { //A[] 是给定的待排数组for(int i = 0; i < A.length - 1; i++) { //遍历数组for(int j = i + 1; j > 0; j--) { //在有序的序列中插⼊新的关键字if(A[j] < A[j-1]) { //这⾥直接使⽤交换来移动元素int temp = A[j];A[j] = A[j-1];A[j-1] = temp;}}}}/*** 时间复杂度：两个 for 循环 O(n^2)* 空间复杂度：占⽤⼀个数组⼤⼩，属于常量，所以是 O(1)*/1.2 折半插⼊排序/** 从直接插⼊排序的主要流程是：1.遍历数组确定新关键字 2.在有序序列中寻找插⼊关键字的位置* 考虑到数组线性表的特性，采⽤⼆分法可以快速寻找到插⼊关键字的位置，提⾼整体排序时间*/public static void BInsertSort(int[] A) {for(int i = 1; i < A.length; i++) {int temp = A[i];//⼆分法查找int low = 0;int high = i - 1;int mid;while(low <= high) {mid = (high + low)/2;if (A[mid] > temp) {high = mid - 1;} else {low = mid + 1;}}//向后移动插⼊关键字位置后的元素for(int j = i - 1; j >= high + 1; j--) {A[j + 1] = A[j];}//将元素插⼊到寻找到的位置A[high + 1] = temp;}}2. 希尔排序希尔排序⼜称缩⼩增量排序，其本质还是插⼊排序，只不过是将待排序列按某种规则分成⼏个⼦序列，然后如同前⾯的插⼊排序⼀般对这些⼦序列进⾏排序。

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时传入自定义的比较器。

java算法大全

java算法大全
Java算法大全可以包含许多不同的算法，包括排序算法、搜索算法、图算法等等。

下面是一些常见和常用的Java算法示例：
1. 排序算法：
- 冒泡排序
- 插入排序
- 选择排序
- 快速排序
- 归并排序
- 堆排序
2. 搜索算法：
- 二分查找
- 广度优先搜索（BFS）
- 深度优先搜索（DFS）
3. 图算法：
- 最短路径算法（如Dijkstra算法、Floyd-Warshall算法）
- 最小生成树算法（如Prim算法、Kruskal算法）
- 拓扑排序算法
4. 动态规划算法：
- 背包问题
- 最长上升子序列（LIS）问题
- 最长公共子序列（LCS）问题
5. 字符串算法：
- 字符串匹配（如暴力匹配、KMP算法、Boyer-Moore
算法）
- 字符串排序（如基数排序）
6. 数值算法：
- 求解线性方程组
- 求解方程的根
- 求解数值积分
以上只是一些常见的算法示例，Java算法的范围非常广泛，涉及到各种不同的问题和应用领域。

如果你有特定的算法
需求，可以提供更具体的问题描述，我可以为你提供更详
细的解答。

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)。

插入排序：package org.rut.util.algorithm.support;import org.rut.util.algorithm.SortUtil;/***@author treeroot*@since2006-2-2*@version1.0*/publicclass InsertSort implements SortUtil.Sort{/*(non-Javadoc)*@see org.rut.util.algorithm.SortUtil.Sort#sort(int[])*/publicvoid sort(int[]data){int temp;for(int i=1;i<data.length;i++){for(int j=i;(j>0)&&(data[j]<data[j-1]);j--){SortUtil.swap(data,j,j-1);}}}}冒泡排序：package org.rut.util.algorithm.support;import org.rut.util.algorithm.SortUtil;/***@author treeroot*@since2006-2-2*@version1.0*/publicclass BubbleSort implements SortUtil.Sort{/*(non-Javadoc)*@see org.rut.util.algorithm.SortUtil.Sort#sort(int[])*/publicvoid sort(int[]data){int temp;for(int i=0;i<data.length;i++){for(int j=data.length-1;j>i;j--){if(data[j]<data[j-1]){SortUtil.swap(data,j,j-1);}}}}}选择排序：package org.rut.util.algorithm.support;import org.rut.util.algorithm.SortUtil;/***@author treeroot*@since2006-2-2*@version1.0*/publicclass SelectionSort implements SortUtil.Sort{/**(non-Javadoc)**@see org.rut.util.algorithm.SortUtil.Sort#sort(int[])*/publicvoid sort(int[]data){int temp;for(int i=0;i<data.length;i++){int lowIndex=i;for(int j=data.length-1;j>i;j--){if(data[j]<data[lowIndex]){lowIndex=j;}}SortUtil.swap(data,i,lowIndex);}}}Shell排序：package org.rut.util.algorithm.support;import org.rut.util.algorithm.SortUtil;/***@author treeroot*@since2006-2-2*@version1.0*/publicclass ShellSort implements SortUtil.Sort{/*(non-Javadoc)*@see org.rut.util.algorithm.SortUtil.Sort#sort(int[])*/publicvoid sort(int[]data){for(int i=data.length/2;i>2;i/=2){for(int j=0;j<i;j++){insertSort(data,j,i);}}insertSort(data,0,1);}/***@param data*@param j*@param i*/privatevoid insertSort(int[]data,int start,int inc){int temp;for(int i=start+inc;i<data.length;i+=inc){for(int j=i;(j>=inc)&&(data[j]<data[j-inc]);j-=inc){SortUtil.swap(data,j,j-inc);}}}}快速排序：package org.rut.util.algorithm.support;import org.rut.util.algorithm.SortUtil;/***@author treeroot*@since2006-2-2*@version1.0*/publicclass QuickSort implements SortUtil.Sort{/*(non-Javadoc)*@see org.rut.util.algorithm.SortUtil.Sort#sort(int[])*/publicvoid sort(int[]data){quickSort(data,0,data.length-1);}privatevoid quickSort(int[]data,int i,int j){int pivotIndex=(i+j)/2;//swapSortUtil.swap(data,pivotIndex,j);int k=partition(data,i-1,j,data[j]);SortUtil.swap(data,k,j);if((k-i)>1)quickSort(data,i,k-1);if((j-k)>1)quickSort(data,k+1,j);}/***@param data*@param i*@param j*@return*/privateint partition(int[]data,int l,int r,int pivot){ do{while(data[++l]<pivot);while((r!=0)&&data[--r]>pivot);SortUtil.swap(data,l,r);}while(l<r);SortUtil.swap(data,l,r);return l;}}改进后的快速排序：package org.rut.util.algorithm.support;import org.rut.util.algorithm.SortUtil;/***@author treeroot*@since2006-2-2*@version1.0*/publicclass ImprovedQuickSort implements SortUtil.Sort{privatestaticint MAX_STACK_SIZE=4096;privatestaticint THRESHOLD=10;/*(non-Javadoc)*@see org.rut.util.algorithm.SortUtil.Sort#sort(int[])*/publicvoid sort(int[]data){int[]stack=newint[MAX_STACK_SIZE];int top=-1;int pivot;int pivotIndex,l,r;stack[++top]=0;stack[++top]=data.length-1;while(top>0){int j=stack[top--];int i=stack[top--];pivotIndex=(i+j)/2;pivot=data[pivotIndex];SortUtil.swap(data,pivotIndex,j);//partitionl=i-1;r=j;do{while(data[++l]<pivot);while((r!=0)&&(data[--r]>pivot));SortUtil.swap(data,l,r);}while(l<r);SortUtil.swap(data,l,r);SortUtil.swap(data,l,j);if((l-i)>THRESHOLD){stack[++top]=i;stack[++top]=l-1;}if((j-l)>THRESHOLD){stack[++top]=l+1;stack[++top]=j;}}//new InsertSort().sort(data);insertSort(data);}/***@param data*/privatevoid insertSort(int[]data){int temp;for(int i=1;i<data.length;i++){for(int j=i;(j>0)&&(data[j]<data[j-1]);j--){SortUtil.swap(data,j,j-1);}}}}归并排序：package org.rut.util.algorithm.support;import org.rut.util.algorithm.SortUtil;/***@author treeroot*@since2006-2-2*@version1.0*/publicclass MergeSort implements SortUtil.Sort{/*(non-Javadoc)*@see org.rut.util.algorithm.SortUtil.Sort#sort(int[])*/publicvoid sort(int[]data){int[]temp=newint[data.length];mergeSort(data,temp,0,data.length-1);}privatevoid mergeSort(int[]data,int[]temp,int l,int r){ int mid=(l+r)/2;if(l==r)return;mergeSort(data,temp,l,mid);mergeSort(data,temp,mid+1,r);for(int i=l;i<=r;i++){temp=data;}int i1=l;int i2=mid+1;for(int cur=l;cur<=r;cur++){if(i1==mid+1)data[cur]=temp[i2++];elseif(i2>r)data[cur]=temp[i1++];elseif(temp[i1]<temp[i2])data[cur]=temp[i1++];elsedata[cur]=temp[i2++];}}}改进后的归并排序:package org.rut.util.algorithm.support;import org.rut.util.algorithm.SortUtil;/***@author treeroot*@since2006-2-2*@version1.0*/publicclass ImprovedMergeSort implements SortUtil.Sort{privatestaticfinalint THRESHOLD=10;/**(non-Javadoc)**@see org.rut.util.algorithm.SortUtil.Sort#sort(int[])*/publicvoid sort(int[]data){int[]temp=newint[data.length];mergeSort(data,temp,0,data.length-1);}privatevoid mergeSort(int[]data,int[]temp,int l,int r){ int i,j,k;int mid=(l+r)/2;if(l==r)return;if((mid-l)>=THRESHOLD)mergeSort(data,temp,l,mid);elseinsertSort(data,l,mid-l+1);if((r-mid)>THRESHOLD)mergeSort(data,temp,mid+1,r);elseinsertSort(data,mid+1,r-mid);for(i=l;i<=mid;i++){temp=data;}for(j=1;j<=r-mid;j++){temp[r-j+1]=data[j+mid];}int a=temp[l];int b=temp[r];for(i=l,j=r,k=l;k<=r;k++){if(a<b){data[k]=temp[i++];a=temp;}else{data[k]=temp[j--];b=temp[j];}}}/***@param data*@param l*@param i*/privatevoid insertSort(int[]data,int start,int len){for(int i=start+1;i<start+len;i++){for(int j=i;(j>start)&&data[j]<data[j-1];j--){SortUtil.swap(data,j,j-1);}}}}堆排序：package org.rut.util.algorithm.support;import org.rut.util.algorithm.SortUtil;/***@author treeroot*@since2006-2-2*@version1.0*/publicclass HeapSort implements SortUtil.Sort{/*(non-Javadoc)*@see org.rut.util.algorithm.SortUtil.Sort#sort(int[]) */publicvoid sort(int[]data){MaxHeap h=new MaxHeap();h.init(data);for(int i=0;i<data.length;i++)h.remove();System.arraycopy(h.queue,1,data,0,data.length); }privatestaticclass MaxHeap{void init(int[]data){this.queue=newint[data.length+1];for(int i=0;i<data.length;i++){queue[++size]=data;fixUp(size);}}privateint size=0;privateint[]queue;publicint get(){return queue[1];}publicvoid remove(){SortUtil.swap(queue,1,size--);fixDown(1);}//fixdownprivatevoid fixDown(int k){int j;while((j=k<<1)<=size){if(j<size&&queue[j]<queue[j+1])j++;if(queue[k]>queue[j])//不用交换break;SortUtil.swap(queue,j,k);k=j;}}privatevoid fixUp(int k){while(k>1){int j=k>>1;if(queue[j]>queue[k])break;SortUtil.swap(queue,j,k);k=j;}}}}SortUtil：package org.rut.util.algorithm;import org.rut.util.algorithm.support.BubbleSort;import org.rut.util.algorithm.support.HeapSort;import org.rut.util.algorithm.support.ImprovedMergeSort; import org.rut.util.algorithm.support.ImprovedQuickSort; import org.rut.util.algorithm.support.InsertSort;import org.rut.util.algorithm.support.MergeSort;import org.rut.util.algorithm.support.QuickSort;import org.rut.util.algorithm.support.SelectionSort; import org.rut.util.algorithm.support.ShellSort;/***@author treeroot*@since2006-2-2*@version1.0*/publicclass SortUtil{publicfinalstaticint INSERT=1;publicfinalstaticint BUBBLE=2;publicfinalstaticint SELECTION=3;publicfinalstaticint SHELL=4;publicfinalstaticint QUICK=5;publicfinalstaticint IMPROVED_QUICK=6;publicfinalstaticint MERGE=7;publicfinalstaticint IMPROVED_MERGE=8;publicfinalstaticint HEAP=9;publicstaticvoid sort(int[]data){sort(data,IMPROVED_QUICK);}privatestatic String[]name={"insert","bubble","selection","shell","quick", "improved_quick","merge","improved_merge","heap"};privatestatic Sort[]impl=new Sort[]{new InsertSort(),new BubbleSort(),new SelectionSort(),new ShellSort(),new QuickSort(),new ImprovedQuickSort(),new MergeSort(),new ImprovedMergeSort(),new HeapSort()};publicstatic String to String(int algorithm){return name[algorithm-1];}publicstaticvoid sort(int[]data,int algorithm){impl[algorithm-1].sort(data);}publicstaticinterface Sort{publicvoid sort(int[]data);}publicstaticvoid swap(int[]data,int i,int j){int temp=data;data=data[j];data[j]=temp;}}。