Java 排序最大值与其大小相似的数组
我正试图找出对最大值与其大小相似的数组进行排序的最佳方法。数组不包含重复的元素Java 排序最大值与其大小相似的数组,java,sorting,Java,Sorting,我正试图找出对最大值与其大小相似的数组进行排序的最佳方法。数组不包含重复的元素 import java.util.Arrays; import java.util.Random; public class SortExamples { public static void main(String[] args) { SortExamples sortExample = new SortExamples(); int[] sizes = { 1000
import java.util.Arrays;
import java.util.Random;
public class SortExamples {
public static void main(String[] args) {
SortExamples sortExample = new SortExamples();
int[] sizes = { 10000, 100000, 500000, 750000, 1000000, 1500000,
2000000, 5000000, 7500000, 10000000, 15000000 };
SortingMethod arraySort = new ArraySort();
SortingMethod quickSort = new QuickSort();
for (int i = 0; i < sizes.length; i++) {
System.out.println("Sorting array of length: " + sizes[i]);
int[] array1 = sortExample.getArraySample(sizes[i]);
int[] array2 = Arrays.copyOf(array1, array1.length);
assert Arrays.equals(array1, array2);
sortExample.sort(array1, arraySort);
sortExample.sort(array2, quickSort);
assert Arrays.equals(array1, array2);
System.out.println();
}
}
public void sort(int[] array, SortingMethod sortingMethod) {
assert !checkOrdered(array);
long startTime = System.currentTimeMillis();
sortingMethod.sort(array);
long endTime = System.currentTimeMillis();
System.out.println("Total time with "
+ sortingMethod.getClass().getSimpleName() + ": "
+ (endTime - startTime) + " millis.");
assert checkOrdered(array);
}
public int[] getArraySample(int size) {
int[] array = new int[size];
for (int i = 0; i < size; i++)
array[i] = i;
shuffle(array);
return array;
}
/**
* Same as java.util.Collections.shuffle(List<?>, Random)
*
* @param array
*/
public void shuffle(int[] array) {
Random random = new Random();
int count = array.length;
for (int i = count; i > 1; i--)
swap(array, i - 1, random.nextInt(i));
}
public boolean checkOrdered(int[] array) {
for (int i = 1; i < array.length; i++)
if (array[i] < array[i - 1])
return false;
return true;
}
public static class ArraySort implements SortingMethod {
public void sort(int[] array) {
if (array.length < 2)
return;
Integer[] auxiliarArray = new Integer[getMax(array) + 1];
for (int i = 0; i < array.length; i++) {
int current = array[i];
auxiliarArray[current] = current;
}
int k = 0;
for (int j = 0; j < auxiliarArray.length; j++) {
Integer current = auxiliarArray[j];
if (current != null) {
array[k] = current;
k++;
}
}
}
public int getMax(int[] array) {
int max = array[0];
for (int i = 0; i < array.length; i++)
if (max < array[i])
max = array[i];
return max;
}
}
public static class QuickSort implements SortingMethod {
public void sort(int[] array) {
sortInternal(array, 0, array.length - 1);
}
public void sortInternal(int[] array, int start, int end) {
int i = start;
int j = end;
int pivot = array[(start + end) / 2];
while (i <= j) {
while (array[i] < pivot)
i++;
while (array[j] > pivot)
j--;
if (i <= j) {
swap(array, i, j);
i++;
j--;
}
}
int startLeft = start;
int endLeft = i - 1;
if (startLeft < endLeft)
sortInternal(array, startLeft, endLeft);
int startRigth = i;
int endRigth = end;
if (startRigth < endRigth)
sortInternal(array, startRigth, endRigth);
}
}
public interface SortingMethod {
public void sort(int[] array);
}
public static void swap(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
这是现有的方法吗?它对什么有用吗?您的算法是的一个变体。计数排序(
O(N+K)
)比快速排序(O(N*log(N)
)或基于比较的任何其他排序(此类排序不能比O(N log(N)
)快),但它的用途有限。您认为这种解决方法怎么样?-这里不讨论代码审查,您可能想把这个问题带到。不,Java使用快速排序。是的,它可能很有用。问题是,您的方法只对较小的数组大小(高达7.5mil)进行了改进,并且仅适用于特殊类型的数组。此外,您没有一个如此兼容的问题。您的代码似乎运行良好…此问题似乎与主题无关,因为它是关于应该打开的内容(关闭投票的自动评论,抱歉)您试过了吗?如果不是在这里,则抱歉。我删除此问题“你觉得用这种方法来解决它怎么样?”我只是想知道这是否是一种现有的方法,以及它是否对某些事情有用。再次抱歉。
Sorting array of length: 10000
Total time with ArraySort: 2 millis.
Total time with QuickSort: 2 millis.
Sorting array of length: 100000
Total time with ArraySort: 14 millis.
Total time with QuickSort: 16 millis.
Sorting array of length: 500000
Total time with ArraySort: 22 millis.
Total time with QuickSort: 59 millis.
Sorting array of length: 750000
Total time with ArraySort: 25 millis.
Total time with QuickSort: 91 millis.
Sorting array of length: 1000000
Total time with ArraySort: 33 millis.
Total time with QuickSort: 122 millis.
Sorting array of length: 1500000
Total time with ArraySort: 66 millis.
Total time with QuickSort: 191 millis.
Sorting array of length: 2000000
Total time with ArraySort: 100 millis.
Total time with QuickSort: 278 millis.
Sorting array of length: 5000000
Total time with ArraySort: 391 millis.
Total time with QuickSort: 662 millis.
Sorting array of length: 7500000
Total time with ArraySort: 2805 millis.
Total time with QuickSort: 1033 millis.
Sorting array of length: 10000000
Total time with ArraySort: 3629 millis.
Total time with QuickSort: 1409 millis.
Sorting array of length: 15000000
Total time with ArraySort: 3825 millis.
Total time with QuickSort: 2185 millis.