Bottom-up merge sort (merge sort)

First, the idea

Another way to implement merge sorting is to merge the mini-arrays and then merge the resulting sub-arrays until the entire array is merged together.

We first 1-by-1 merge, then 2-by-2 Merge,4-by-4 merge, so go on.

In the last merge, the second array may be smaller than the first array.

Second, the Code implementation

Key code:

     Public Static void sort (comparable[] input) {                int N = input.length;         New Comparable[n];                  for  (int sz = 1; sz < N; SZ + = sz)            {for (int lo = 0; lo < n-sz; lo + = SZ + sz) {                merge (input, lo, lo+sz-1, Math.min (N-1, lo+sz+sz-1));                 }}}

Test data: M e r G E S O r T e X A m P L E

Output result 1:

m e r G E S O r T e X A m P L e merge (input,0, 0, 1) e M r G e S O r T E X A M P L e merge (input,2, 2, 3) e M G r e S O r T E X A M P L e merge (input,4, 4, 5) e M G r e S O r T E X A M P L e merge (input,6, 6, 7) e M G r e S O r T E X A M P L e merge (input,8, 8, 9) e M G r e S O r e T X A M P L e merge (input,10, 10, 11) e M G r e S O r e T A X M P L e merge (input,12, 12, 13) e M G r e S O r e T A X M P L e merge (input,14, 14, 15) e M G r e S O r e T A X M P e L merge (input,0, 1, 3) e G M r e S O r e T A X M P e L merge (input,4, 5, 7) e G M r e O r S e T A X M P E L Merge (input,8, 9, 11) e G M r e O r S A e T X M P E L Merge (input,12, 13, 15) e G M r e O r S A E T X E L M P Merge (input,0, 3, 7) e e G M O r r S A e T X E L M P Merge (input,8, 11, 15) e e G m O r r S A e e L M P T X Merge (input,0, 7, 15) A e e e g l m m O p r r S T x A e e e g L m m O p r r S t x

Contrast from top to bottom:

m e r G E S O r T e X A m P L e merge (input,0, 0, 1) e M r G e S O r T E X A M P L e merge (input,2, 2, 3) e M G r e S O r T E X A M P L e merge (input,0, 1, 3) e G M r e S O r T E X A M P L e merge (input,4, 4, 5) e G M r e S O r T E X A M P L e merge (input,6, 6, 7) e G M r e S O r T E X A M P L e merge (input,4, 5, 7) e G M r e O r S T e X A M P L e merge (input,0, 3, 7) e e G M O r r S T e X A M P L e merge (input,8, 8, 9) e e G M O r r S E T X A M P L e merge (input,10, 10, 11) e e G M O r r S E T A X M P L e merge (input,8, 9, 11) e e G M O r r S A e T X M P L e merge (input,12, 12, 13) e e G M O r r S A e T X M P L e merge (input,14, 14, 15) e e G M O r r S A e T X M P E L Merge (input,12, 13, 15) e e G M O r r S A e T X E L M P Merge (input,8, 11, 15) e e G m O r r S A e e L M P T X Merge (input,0, 7, 15) A e e e g l m m O p r r S T x A e e e g L m m O p r r S t x

Output Result 2:

M e r G E S O r T e X A m
Merge (input, 0, 0, 1) e M r G e S O r T E X A M
Merge (input, 2, 2, 3) e M G r e S O r T E X A M
Merge (Input, 4, 4, 5) e M G r e S O r T E X A M
Merge (input, 6, 6, 7) e M G r e S O r T E X A M
Merge (input, 8, 8, 9) e M G r e S O r e T X A M
Merge (input, ten, ten, one) e M G r e S O r e T A X M
Merge (input, 0, 1, 3) e G M r e S O r e T A X M
Merge (Input, 4, 5, 7) e G M r e O r S e T A X m
Merge (input, 8, 9, one) e G M R E O r S A E T X M
Merge (input, 0, 3, 7) e e G M O r r S A E T X M
Merge (input, 8, one, a) e e G m O r r S A E m T X
Merge (input, 0, 7, A) A e e e G m M O r R S T X
A e e e G m M O r R S T X

Contrast from top to bottom:

M e r G E S O r T e X A m
Merge (input, 0, 0, 1) e M r G e S O r T E X A M
Merge (input, 2, 2, 3) e M G r e S O r T E X A M
Merge (input, 0, 1, 3) e G M r e S O r T E X A M
Merge (Input, 4, 4, 5) e G M r e S O r T E X A M
Merge (Input, 4, 5, 6) e G M r e O S r T E X A M
Merge (input, 0, 3, 6) e e G M O r S R T E X A M
Merge (input, 7, 7, 8) e e G M O r S R T E X A M
Merge (input, 7, 8, 9) e e G M O R S E r T X A M
Merge (input, ten, ten, one) e e G M O R S E r T A X M
Merge (input, ten, one, a) e e G M O R S E r T A M X
Merge (input, 7, 9, a) e e G m O r S A E m R T X
Merge (input, 0, 6, A) A e e e G m M O r R S T X
A e e e G m M O r R S T X

When the array length is a power of 2, the number of comparisons and the number of accesses to the top-down and bottom-up is exactly the same, except in order.

Otherwise, the two methods use different numbers of comparisons and groups of accesses.

Third, performance analysis

Conclusion: For any array of length n, the bottom-up merge sort requires a 1/2nlgn to NLGN comparison and a maximum of 6NlgN accesses to the array.

Analysis: See P279

Iv. sorting complexity

There is no comparison-based algorithm that can guarantee the use of less than lgn! ~ NLGN comparison Sorts the array of length n.

Bottom-up merge sort (merge sort)