【发布时间】：2015-04-24 16:52:52
【问题描述】：
好的，所以我有一个冒泡排序、选择排序和插入排序的实现。我正在使用 Java.Random 对象创建三个相同的十万数字数组。我将这些依次传递给每个排序方法。我正在使用 System.nanotime 对结果进行计时。
了解一些背景信息。我在选择和插入排序中遵循的排序算法来自 Frank Carano 的“Java 3rd Ed 中的数据结构和抽象”。冒泡排序让我想不通。
下面我提供了一个执行所有这些的自包含类。 Carano 的算法哪里出了问题，我没看到？
您将在下面看到我正在计算基本操作的周期并计时完成。在运行时，周期数的差异可以忽略不计。对我来说，在查看完成时间时，Bubble 是第 1 个，Selection 是第 2 个，Insertation 是第 3 个。这与传统智慧背道而驰。为什么。我是不是做了一些相当愚蠢的事情？
顺便说一句，您应该能够编译和运行提供的代码而无需任何更改。
import java.util.Random;
/**
*
* Performs sorts on generic data, here using Integers.
*/
public class GenSorts {
static int selectionCount = 0, bubbleCount = 0, insertionCount = 0;;
//=========================================================================
/**
* Do an insertion sort.
* @param data The array to sort
* @param first The index of the first element
* @param lasr The index of the last element
*/
//=========================================================================
public static <T extends Comparable<? super T>> void insertionSort(T[]array, int first, int last){
for(int untouch = first + 1; untouch < last; untouch++){
T nextToInsert = array[untouch];
insertInOrder(nextToInsert, array, first, untouch-1);
}//end for
}//=========================================================================
//=========================================================================
/**
* Performs the shuffle and insert part of the insertion sort.
* @param anEntry The value to insert
* @param array The target array
* @param begin The begin of the unsorted part.
* @param end The end of the unsorted part.
*/
//=========================================================================
public static <T extends Comparable<? super T>> void insertInOrder(T anEntry, T[]array, int begin, int end){
int index = end;
//Do a shunt while an entry is less than the value at the index
while( ( index >= begin ) && (anEntry.compareTo(array[index]) < 0) ){
array[index+1] = array[index];
index --;
insertionCount++;
}
array[index+1] = anEntry;//Insert
}//======================================================================
//======================================================================
/**
* BUBBLE SORT///////////////////////////////////////////////////////////
* Perform a bubble sort on the data.
* @param data The array to be sorted.
*/
//======================================================================
public static <T extends Comparable <? super T> >void bubbleSort (T[] data)
{
Boolean swapped = true;
int stop = data.length -1;
while (swapped) {
swapped = false;
for (int x = 0; x < stop ; x++ ) {
bubbleCount++;
//if x smaller than x +1 swap
if ( data[x].compareTo( data[x+1] ) > 0 ) {
swap(x, x+1, data );
swapped = true;
}//end if
stop --;
}//end for
}//end while
}//end method============================================================
//========================================================================
/**
* SELECTION SORT/////////////////////////////////////////////////////////
* A selection sort algorithm to sort data.
* @param data
* @return
*/
//========================================================================
public static <T extends Comparable<? super T> > void selectionSort(T[] data, int n){
for (int index = 0; index < n - 1; index++)
{
selectionCount++;
int min = getSmallestIndex( index, n,data);
swap( index, min, data);
//DISPLAYME
// displaySelectionArray(index, min, data);
}
}//========================================================================
//==========================================================================
/**
* Get the index of the smallest item in the array from start to end/
* @param start The place in the array to start looking.
* @param end The place in the array to end looking.
* @param array The array to inspect.
* @returnThe index of the smallest.
*/
//==========================================================================
private static <T extends Comparable<? super T>> int getSmallestIndex( int start, int end, T[] array)
{
T min = array[start];//value of smallest
int minIndex = start;//index of smallest
for (int i = start + 1; i < end; i++)
{
// System.out.print(array[i].toString() + ", ");
if (array[i].compareTo(min) < 0)
{
minIndex = i;
min = array[i];
}//end if
}//end for
// System.out.println("");
return minIndex;
}//========================================================================
//=========================================================================
/**
* Swap emelement numbers j and iMin in array data.
* @param j
* @param iMin
* @param data
*/
//=========================================================================
public static<T extends Comparable <? super T> > void swap(int j, int iMin, T[] data){
T temp = data[j];
data[j] = data[iMin];
data[iMin] = temp;
}//end swap================================================================
public static Integer[] largeRandom1, largeRandom2, largeRandom3;
//========================================================================
/**
* Generate large integers for sorting.
* @param n The value of n.
*/
//========================================================================
public static void genLargeRandom(int n){
Random r = new Random();
largeRandom1 = new Integer[n];
largeRandom2 = new Integer[n];
largeRandom3 = new Integer[n];
for(int i = 0; i < n; i++){
largeRandom1[i] = r.nextInt(100);
largeRandom2[i] = largeRandom1[i];
largeRandom3[i] = largeRandom1[i];
}//end for
}//end genLarge//==========================================================
//=========================================================================
/**
* Sort a large numvber.
* @param args
*/
//=========================================================================
public static void main(String[] args){
genLargeRandom(100000);//one hundred thousand
Integer[] data = largeRandom1;///{40, 3, 2, 7, 4};
Integer[] data2 = largeRandom2;
Integer[] data3 = largeRandom3;
System.out.println("BUBBLE SORT!!");
Long t1s = System.nanoTime();
bubbleSort(data);///////////////Bubble Sort
Long t1e = System.nanoTime();
System.out.println("SELECTION SORT!!");
Long t2s = System.nanoTime();
selectionSort(data2, data2.length);///////////////Selection Sort
Long t2e = System.nanoTime();
System.out.println("INSERTION SORT!!");
Long t3s = System.nanoTime();
insertionSort(data3,0, data3.length);////////////Insertion Sort
Long t3e = System.nanoTime();
System.out.println("Bubble Time: " + (t1e - t1s));
System.out.println("Selection Time: " + (t2e - t2s));
System.out.println("insertion Time: " + (t3e - t3s));
System.out.println("Bubble count: " + bubbleCount );
System.out.println("Selection ccount :" + selectionCount );
System.out.println("Insertion ccount :" + selectionCount );
}//========================================================================
}//############################################################################
【问题讨论】：
-
我投票决定将此问题作为离题结束，因为它属于codereview。
-
为了真正看到这些代码片段的性能，您应该多次发出排序；需要考虑 JIT。这就是微基准库的用武之地（JMH、caliper——尽管后者已经有一段时间没有维护了）
-
在未来，强调冒泡排序比其他算法快多少会很有用。 “在运行时，周期数几乎可以忽略不计”这一行看起来像是 JVM 细节和微优化的问题。
-
@UwePlonus 据我所知，这没有理由属于代码审查。代码审查是为了提供关于工作代码的建议，而不是解决问题。
标签： java performance sorting