基本思想
n個記錄的文件的直接選擇排序可經過n-1趟直接選擇排序得到有序結果:
- 初始狀態:無序區爲R[1..n],有序區爲空。
- 第1趟排序: 在無序區R[1..n]中選出關鍵字最小的記錄R[k],將它與無序區的第1個記錄R[1] 交換,使R[1..1]和R[2..n]分別變爲記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。
- ……
- 第i趟排序: 第i趟排序開始時,當前有序區和無序區分別爲R[1..i-1]和R[i..n](1≤i≤n-1)。 該趟排序從當前無序區中選出關鍵字最小的記錄R[k],將它與無序區的第1個記錄R[i]交換,使R[1..i] 和R[i+1..n]分別變爲記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。
這樣,n個記錄的文件的直接選擇排序可經過n-1趟直接選擇排序得到有序結果。
算法實現
歸併排序算法,Java實現,代碼如下所示:
01 |
public abstract class Sorter
{ |
02 |
public abstract void sort( int []
array); |
03 |
} |
04 |
05 |
public class MergeSorter extends Sorter
{ |
06 |
07 |
@Override |
08 |
public void sort( int []
array) { |
09 |
int []
auxArray = new int [array.length]; |
10 |
mergeSort(array,
auxArray, 0 ,
array.length - 1 ); |
11 |
} |
12 |
13 |
/** |
14 |
*
基於分治思想,執行歸併排序 |
15 |
*
@param low 待排序數組下標下界 |
16 |
*
@param high 待排序數組下標上界 |
17 |
*/ |
18 |
private void mergeSort( int []
array, int []
auxArray, int low, int high)
{ |
19 |
int dividedIndex
= 0 ; //
分治位置索引變量 |
20 |
if (low
< high) { |
21 |
dividedIndex
= (low + high) / 2 ; //
計算分治位置(採用簡單的二分思想) |
22 |
mergeSort(array,
auxArray, low, dividedIndex); //
左側遞歸歸併排序 |
23 |
mergeSort(array,
auxArray, dividedIndex + 1 ,
high); //
右側遞歸歸併排序 |
24 |
merge(array,
auxArray, low, dividedIndex, high); //
合併分治結果 |
25 |
} |
26 |
} |
27 |
28 |
private void merge( int []
array, int []
auxArray, int low, int dividedIndex, int high)
{ |
29 |
int i
= low; //
指向左半分區數組的指針 |
30 |
int j
= dividedIndex + 1 ; //
指向右半分區數組的指針 |
31 |
int auxPtr
= 0 ; //
指向輔助區數組的指針 |
32 |
//
合併兩個有序數組:array[low..dividedIndex]與array[dividedIndex+1..high]。 |
33 |
while (i
<= dividedIndex && j <= high) { //
將兩個有序的數組合並,排序到輔助數組auxArray中 |
34 |
if (array[i]
> array[j]) { //
左側數組array[low..dividedIndex]中的array[i]大於右側數組array[dividedIndex+1..high]中的array[j] |
35 |
auxArray[auxPtr++]
= array[j++]; |
36 |
} else { |
37 |
auxArray[auxPtr++]
= array[i++]; |
38 |
} |
39 |
} |
40 |
//
如果array[low..dividedIndex].length>array[dividedIndex+1..high].length,經過上面合併 |
41 |
//
array[low..dividedIndex]沒有合併完,則直接將array[low..dividedIndex]中沒有合併的元素複製到輔助數組auxArray中去 |
42 |
while (i
<= dividedIndex) { |
43 |
auxArray[auxPtr++]
= array[i++]; |
44 |
} |
45 |
//
如果array[low..dividedIndex].length<array[dividedIndex+1..high].length,經過上面合併 |
46 |
//
array[dividedIndex+1..high]沒有合併完,則直接將array[dividedIndex+1..high]中沒有合併的元素複製到輔助數組auxArray中去 |
47 |
while (j
<= high) { |
48 |
auxArray[auxPtr++]
= array[j++]; |
49 |
} |
50 |
//
最後把輔助數組auxArray的元素複製到原來的數組中去,歸併排序結束 |
51 |
for (auxPtr
= 0 ,
i = low; i <= high; i++, auxPtr++) { |
52 |
array[i]
= auxArray[auxPtr]; |
53 |
} |
54 |
} |
55 |
} |
歸併排序算法,Python實現,代碼如下所示:
01 |
class Sorter: |
02 |
''' |
03 |
Abstract
sorter class, which provides shared methods being used by |
04 |
subclasses. |
05 |
''' |
06 |
__metaclass__ = ABCMeta |
07 |
|
08 |
@abstractmethod |
09 |
def sort( self ,
array): |
10 |
pass |
11 |
12 |
class MergeSorter(Sorter): |
13 |
''' |
14 |
Merge
sorter |
15 |
''' |
16 |
|
17 |
def sort( self ,
array): |
18 |
length = len (array) |
19 |
#
initialize auxiliary list |
20 |
auxiliary_list = [ 0 for x in range (length)] |
21 |
self .__merge_sort(array,
auxiliary_list, 0 ,
length - 1 ) |
22 |
|
23 |
def __merge_sort( self ,
array, auxiliary_list, low, high): |
24 |
dividedIndex = 0 |
25 |
if low<high: |
26 |
dividedIndex = (low + high) / / 2 |
27 |
self .__merge_sort(array,
auxiliary_list, low, dividedIndex) |
28 |
self .__merge_sort(array,
auxiliary_list, dividedIndex + 1 ,
high) |
29 |
self .__merge(array,
auxiliary_list, low, dividedIndex, high) |
30 |
|
31 |
def __merge( self ,
array, auxiliary_list, low, dividedIndex, high): |
32 |
i = low |
33 |
j = dividedIndex + 1 |
34 |
pointer = 0 |
35 |
while i< = dividedIndex and j< = high: |
36 |
if array[i]>array[j]: |
37 |
auxiliary_list[pointer] = array[j] |
38 |
j = j + 1 |
39 |
else : |
40 |
auxiliary_list[pointer] = array[i] |
41 |
i = i + 1 |
42 |
pointer = pointer + 1 |
43 |
while i< = dividedIndex: |
44 |
auxiliary_list[pointer] = array[i] |
45 |
pointer = pointer + 1 |
46 |
i = i + 1 |
47 |
while j< = high: |
48 |
auxiliary_list[pointer] = array[j] |
49 |
pointer = pointer + 1 |
50 |
j = j + 1 |
51 |
#
copy elements in auxiliary list to the original list |
52 |
pointer = 0 |
53 |
i = low |
54 |
while i< = high: |
55 |
array[i] = auxiliary_list[pointer] |
56 |
i = i + 1 |
57 |
pointer = pointer + 1 |
排序過程
假設待排序數組爲array = {94,12,34,76,26,9,0,37,55,76,37,5,68,83,90,37,12,65,76,49},數組大小爲20,我們以該數組爲例,執行歸併排序的具體過程,如下所示:
01 |
[94,12,34,76,26,9,0,37,55,76,
37,5,68,83,90,37,12,65,76,49] |
02 |
[94,12,34,76,26,
9,0,37,55,76] |
03 |
[94,12,34,
76,26] |
04 |
[94,12,
34] |
05 |
[94,
12] |
06 |
{12,
94} |
07 |
{12,34,
94} |
08 |
[76,
26] |
09 |
{26,
76} |
10 |
{12,26,34,
76,94} |
11 |
[9,0,37,
55,76] |
12 |
[9,0,
37] |
13 |
[9,
0] |
14 |
{0,
9} |
15 |
{0,9,
37} |
16 |
[55,
76] |
17 |
{55,
76} |
18 |
{0,9,37,
55,76} |
19 |
{0,9,12,26,34,
37,55,76,76,94} |
20 |
[37,5,68,83,90,
37,12,65,76,49] |
21 |
[37,5,68,
83,90] |
22 |
[37,5,
68] |
23 |
[37,
5] |
24 |
{5,
37} |
25 |
{5,37,
68} |
26 |
[83,
90] |
27 |
{83,
90} |
28 |
{5,37,68,
83,90} |
29 |
[37,12,65,
76,49] |
30 |
[37,12,
65] |
31 |
[37,
12 ] |
32 |
{12,
37 } |
33 |
{12,37,
65 } |
34 |
[76,
49 ] |
35 |
{49,
76} |
36 |
{12,37,49,
65,76} |
37 |
{5,12,37,37,49,
65,68,76,83,90} |
38 |
{0,5,9,12,12,26,34,37,37,37,
49,55,65,68,76,76,76,83,90,94} |
上面示例的排序過程中,方括號表示“分解”操作過程中,將原始數組進行遞歸分解,直到不能再繼續分割爲止;花括號表示“歸併”的過程,將上一步分解後的數組進行歸併排序。因爲採用遞歸分治的策略,所以從上面的排序過程可以看到,“分解”和“歸併”交叉出現。
算法分析
- 時間複雜度
對長度爲n的文件,需進行FLOOR(logn) 趟二路歸併,每趟歸併的時間爲O(n),故其時間複雜度無論是在最好情況下還是在最壞情況下均是O(nlgn)。
- 空間複雜度
需要一個輔助向量來暫存兩有序子文件歸併的結果,故其輔助空間複雜度爲O(n),顯然它不是就地排序。
- 排序穩定性
歸併排序是一種穩定的排序。
轉載原地址:http://shiyanjun.cn/archives/820.html