一、Arrays.sort()陣列排序

Java Arrays中提供了對所有型別的排序。其中主要分為Primitive(8種基本型別)和Object兩大類。

　　基本型別：採用調優的快速排序；

　　物件型別：採用改進的歸併排序。

1、對於基本型別原始碼分析如下（以int[]為例）：

Java對Primitive（int，float等原型資料）陣列採用快速排序，對Object物件陣列採用歸併排序。對這一區別，sun在<<The Java Tutorial>>中做出的解釋如下：

The sort operation uses a slightly optimized merge sort algorithm that is fast and stable:

* Fast: It is guaranteed to run in n log(n) time and runs substantially faster on nearly sorted lists. Empirical tests showed it to be as fast as a highly optimized quicksort. A quicksort is generally considered to be faster than a merge sort but isn't stable and doesn't guarantee n log(n) performance.

* Stable: It doesn't reorder equal elements. This is important if you sort the same list repeatedly on different attributes. If a user of a mail program sorts the inbox by mailing date and then sorts it by sender, the user naturally expects that the now-contiguous list of messages from a given sender will (still) be sorted by mailing date. This is guaranteed only if the second sort was stable.

　　也就是說，優化的歸併排序既快速（nlog(n)）又穩定。

　　對於物件的排序，穩定性很重要。比如成績單，一開始可能是按人員的學號順序排好了的，現在讓我們用成績排，那麼你應該保證，本來張三在李四前面，即使他們成績相同，張三不能跑到李四的後面去。

　　而快速排序是不穩定的，而且最壞情況下的時間複雜度是O(n^2)。

　　另外，物件陣列中儲存的只是物件的引用，這樣多次移位並不會造成額外的開銷，但是，物件陣列對比較次數一般比較敏感，有可能物件的比較比單純數的比較開銷大很多。歸併排序在這方面比快速排序做得更好，這也是選擇它作為物件排序的一個重要原因之一。

　　排序優化：實現中快排和歸併都採用遞迴方式，而在遞迴的底層，也就是待排序的陣列長度小於7時，直接使用氣泡排序，而不再遞迴下去。

　　分析：長度為6的陣列氣泡排序總比較次數最多也就1+2+3+4+5+6=21次，最好情況下只有6次比較。而快排或歸併涉及到遞迴呼叫等的開銷，其時間效率在n較小時劣勢就凸顯了，因此這裡採用了氣泡排序，這也是對快速排序極重要的優化。

　　原始碼中的快速排序，主要做了以下幾個方面的優化：

1）當待排序的陣列中的元素個數較少時，原始碼中的閥值為7，採用的是插入排序。儘管插入排序的時間複雜度為0(n^2)，但是當陣列元素較少時，插入排序優於快速排序，因為這時快速排序的遞迴操作影響效能。

2）較好的選擇了劃分元（基準元素）。能夠將陣列分成大致兩個相等的部分，避免出現最壞的情況。例如當陣列有序的的情況下，選擇第一個元素作為劃分元，將使得演算法的時間複雜度達到O(n^2).

　　原始碼中選擇劃分元的方法:

　　　　當陣列大小為 size=7 時，取陣列中間元素作為劃分元。int n=m>>1;(此方法值得借鑑)

　　　　當陣列大小 7<size<=40時，取首、中、末三個元素中間大小的元素作為劃分元。

　　　　當陣列大小 size>40 時，從待排陣列中較均勻的選擇9個元素，選出一個偽中數做為劃分元。

3）根據劃分元 v ，形成不變式 v* (<v)* (>v)* v*

　　普通的快速排序演算法，經過一次劃分後，將劃分元排到素組較中間的位置，左邊的元素小於劃分元，右邊的元素大於劃分元，而沒有將與劃分元相等的元素放在其附近，這一點，在Arrays.sort()中得到了較大的優化。

　　舉例：15、93、15、41、6、15、22、7、15、20

　　因  7<size<=40,所以在15、6、和20 中選擇v = 15 作為劃分元。

　　經過一次換分後： 15、15、7、6、41、20、22、93、15、15. 與劃分元相等的元素都移到了素組的兩邊。

　　接下來將與劃分元相等的元素移到陣列中間來，形成：7、6、15、15、15、15、41、20、22、93.

　　最後遞迴對兩個區間進行排序[7、6]和[41、20、22、93].

　　部分原始碼（一）如下：

1 package com.util;

2

3publicclass ArraysPrimitive {

4private ArraysPrimitive(){}

5

6/**

  7     * 對指定的 int 型陣列按數字升序進行排序。

  8      */

9publicstaticvoid sort(int[] a) {

10         sort1(a, 0, a.length);

11    }

12

13/**

 14     * 對指定 int 型陣列的指定範圍按數字升序進行排序。

 15      */

16publicstaticvoid sort(int[] a, int fromIndex, int toIndex) {

17        rangeCheck(a.length, fromIndex,toIndex);

18         sort1(a, fromIndex, toIndex -fromIndex);

19    }

20

21privatestaticvoid sort1(int x[], int off, int len) {

22/*

 23         * 當待排序的陣列中的元素個數小於 7 時，採用插入排序。

 24         *

 25         * 儘管插入排序的時間複雜度為O(n^2),但是當陣列元素較少時，插入排序優於快速排序，因為這時快速排序的遞迴操作影響效能。

 26          */

27if (len < 7) {

28for (int i = off; i <len + off; i++)

29for (int j = i; j > off&& x[j - 1] > x[j]; j--)

30                     swap(x, j, j - 1);

31return;

32        }

33/*

 34         * 當待排序的陣列中的元素個數大於或等於7 時，採用快速排序。

 35         *

 36         * Choose a partition element, v

 37         * 選取一個劃分元，V

 38         *

 39         * 較好的選擇了劃分元(基準元素)。能夠將陣列分成大致兩個相等的部分，避免出現最壞的情況。例如當陣列有序的的情況下，

 40         * 選擇第一個元素作為劃分元，將使得演算法的時間複雜度達到O(n^2).

 41          */

42// 當陣列大小為size=7時，取陣列中間元素作為劃分元。

43int m = off + (len>> 1);

44// 當陣列大小 7<size<=40時，取首、中、末三個元素中間大小的元素作為劃分元。

45if (len > 7) {

46int l = off;

47int n = off + len - 1;

48/*

 49             * 當陣列大小  size>40 時，從待排陣列中較均勻的選擇9個元素，

 50             * 選出一個偽中數做為劃分元。

 51              */

52if (len > 40) {

53int s = len / 8;

54                 l = med3(x, l, l + s, l + 2 * s);

55                 m = med3(x, m - s, m, m + s);

56                 n = med3(x, n - 2 * s, n - s, n);

57            }

58// 取出中間大小的元素的位置。

59             m = med3(x, l, m, n); // Mid-size, medof 3

60        }

61

62//得到劃分元V

63int v = x[m];

64

65// EstablishInvariant: v* (<v)* (>v)* v*

66int a = off, b = a, c= off + len - 1, d = c;

67while (true) {

68while (b <= c&& x[b] <= v) {

69if (x[b] == v)

70                     swap(x, a++, b);

71                 b++;

72            }

73while (c >= b&& x[c] >= v) {

74if (x[c] == v)

75                     swap(x, c, d--);

76                 c--;

77            }

78if (b > c)

79break;

80             swap(x, b++, c--);

81        }

82// Swap partitionelements back to middle

83int s, n = off + len;

84         s = Math.min(a - off, b - a);

85         vecswap(x, off, b - s, s);

86         s = Math.min(d - c, n - d - 1);

87         vecswap(x, b, n - s, s);

88// Recursivelysort non-partition-elements

89if ((s = b - a) >1)

90            sort1(x, off, s);

91if ((s = d - c) >1)

92             sort1(x, n - s, s);

93    }

94

95/**

 96     * Swaps x[a] with x[b].

 97      */

98privatestaticvoid swap(int x[], int a, int b) {

99int t = x[a];

100        x[a] = x[b];

101        x[b] = t;

102   }

103

104/**

105     * Swaps x[a.. (a+n-1)] with x[b .. (b+n-1)].

106      */

107privatestaticvoid vecswap(int x[], int a, int b, int n) {

108for (int i=0; i<n; i++, a++, b++)

109       swap(x, a, b);

110   }

111

112/**

113     * Returnsthe index of the median of the three indexed integers.

114      */

115privatestaticint med3(int x[], int a, int b, int c) {

116return (x[a] < x[b] ? (x[b] < x[c] ? b : x[a] < x[c] ? c : a)

117                 : (x[b] > x[c] ? b : x[a]> x[c] ? c : a));

118   }

119

120/**

121     * Checkthat fromIndex and toIndex are in range, and throw an

122     *appropriate exception if they aren't.

123      */

124privatestaticvoid rangeCheck(int arrayLen, int fromIndex, int toIndex) {

125if (fromIndex > toIndex)

126thrownewIllegalArgumentException("fromIndex(" + fromIndex

127                     + ") >toIndex(" + toIndex + ")");

128if (fromIndex < 0)

129thrownewArrayIndexOutOfBoundsException(fromIndex);

130if (toIndex > arrayLen)

131thrownewArrayIndexOutOfBoundsException(toIndex);

132   }

133 }

測試程式碼如下：

1 package com.test;

2

3 importcom.util.ArraysPrimitive;

4

5publicclass ArraysTest {

6publicstaticvoid main(String[]args) {

7int [] a={15,93,15,41,6,15,22,7,15,20};

8        ArraysPrimitive.sort(a);

9for(int i=0;i<a.length;i++){

10             System.out.print(a[i]+",");

11       }

12//結果：6,7,15,15,15,15,20,22,41,93,

13   }

14 }

2、對於Object型別原始碼分析如下：

　　部分原始碼（二）如下：

1 package com.util;

2

3 importjava.lang.reflect.Array;

4

5publicclass ArraysObject {

6privatestatic final intINSERTIONSORT_THRESHOLD = 7;

7

8private ArraysObject() {}

9

10publicstaticvoid sort(Object[] a){

11//java.lang.Object.clone()，理解深表複製和淺表複製

12         Object[] aux = (Object[]) a.clone();

13         mergeSort(aux, a, 0, a.length, 0);

14    }

15

16publicstaticvoid sort(Object[] a, int fromIndex, int toIndex) {

17        rangeCheck(a.length, fromIndex,toIndex);

18         Object[] aux = copyOfRange(a,fromIndex, toIndex);

19         mergeSort(aux, a, fromIndex, toIndex,-fromIndex);

20    }

21

22/**

 23     * Src is the source array that starts atindex 0

 24     * Dest is the (possibly larger) arraydestination with a possible offset

 25     * low is the index in dest to startsorting

 26     * high is the end index in dest to endsorting

 27     * off is the offset to generatecorresponding low, high in src

 28      */

29privatestaticvoidmergeSort(Object[] src, Object[] dest, int low,

30int high, int off) {

31int length = high -low;

32

33// Insertion sorton smallest arrays

34if (length <INSERTIONSORT_THRESHOLD) {

35for (int i = low; i <high; i++)

36for (int j = i; j > low&&

37                         ((Comparable) dest[j -1]).compareTo(dest[j]) > 0; j--)

38                     swap(dest, j, j - 1);

39return;

40        }

41

42// Recursivelysort halves of dest into src

43int destLow = low;

44int destHigh = high;

45         low += off;

46         high += off;

47/*

 48         * >>>：無符號右移運算子

 49         * expression1 >>> expresion2：expression1的各個位向右移expression2

 50         *  指定的位數。右移後左邊空出的位數用0來填充。移出右邊的位被丟棄。

 51         * 例如：-14>>>2；結果為：1073741820

 52          */

53int mid = (low +high) >>> 1;

54         mergeSort(dest, src, low, mid, -off);

55         mergeSort(dest, src, mid, high, -off);

56

57// If list isalready sorted, just copy from src to dest. This is an

58// optimizationthat results in faster sorts for nearly ordered lists.

59if (((Comparable)src[mid - 1]).compareTo(src[mid]) <= 0) {

60            System.arraycopy(src, low, dest,destLow, length);

61return;

62        }

63

64// Merge sortedhalves (now in src) into dest

65for (int i = destLow, p =low, q = mid; i < destHigh; i++) {

66if (q >= high ||p < mid

67                     && ((Comparable)src[p]).compareTo(src[q]) <= 0)

68                 dest[i] = src[p++];

69else

70                 dest[i] = src[q++];

71        }

72    }

73

74/**

 75     * Check that fromIndex and toIndex are inrange, and throw an appropriate

 76     * exception if they aren't.

 77      */

78privatestaticvoid rangeCheck(int arrayLen, int fromIndex, int toIndex) {

79if (fromIndex >toIndex)

80thrownewIllegalArgumentException("fromIndex(" + fromIndex

81                     + ") >toIndex(" + toIndex + ")");

82if (fromIndex < 0)

83thrownewArrayIndexOutOfBoundsException(fromIndex);

84if (toIndex >arrayLen)

85thrownewArrayIndexOutOfBoundsException(toIndex);

86    }

87

88publicstatic <T> T[]copyOfRange(T[] original, intfrom, int to) {

89returncopyOfRange(original, from, to,(Class<T[]>) original.getClass());

90    }

91

92publicstatic <T, U> T[]copyOfRange(U[] original, intfrom, int to,

93             Class<? extends T[]>newType) {

94int newLength = to - from;

95if (newLength < 0)

96thrownewIllegalArgumentException(from + " > " + to);

97         T[] copy = ((Object) newType ==(Object) Object[].class)

98                 ? (T[]) new Object[newLength]

99                : (T[])Array.newInstance(newType.getComponentType(), newLength);

100        System.arraycopy(original, from, copy, 0,

101                 Math.min(original.length - from, newLength));

102return copy;

103   }

104

105/**

106     * Swapsx[a] with x[b].

107      */

108privatestaticvoid swap(Object[] x, int a, int b) {

109        Object t = x[a];

110        x[a] = x[b];

111        x[b] = t;

112   }

113 }

測試程式碼如下：

1 package com.test;

2

3 importcom.util.ArraysObject;

4

5publicclassArraysObjectSortTest {

6publicstaticvoid main(String[]args) {

7         Student stu1=new Student(1001,100.0F);

8         Student stu2=new Student(1002,90.0F);

9         Student stu3=new Student(1003,90.0F);

10        Student stu4=new Student(1004,95.0F);

11        Student[] stus={stu1,stu2,stu3,stu4};

12//Arrays.sort(stus);

13       ArraysObject.sort(stus);

14for(int i=0;i<stus.length;i++){

15             System.out.println(stus[i].getId()+" : "+stus[i].getScore());

16       }

17/* 1002 : 90.0

18         * 1003 :90.0

19         * 1004 :95.0

20         * 1001 :100.0

21          */

22   }

23 }

24class Studentimplements Comparable<Student>{

25privateint id;  //學號

26privatefloat score;  //成績

27public Student(){}

28public Student(int id,float score){

29this.id=id;

30this.score=score;

31   }

32   @Override

33publicint compareTo(Student s) {

34return (int)(this.score-s.getScore());

35   }

36publicint getId() {

37return id;

38   }

39publicvoid setId(int id) {

40this.id = id;

41   }

42publicfloat getScore() {

43return score;

相關推薦