五十道程式設計小題目 --- 28 八大排序演算法 java 之 07歸併排序
阿新 • • 發佈：2019-01-08
7. 歸併排序（Merge Sort）
基本思想：
歸併（Merge）排序法是將兩個（或兩個以上）有序表合併成一個新的有序表，即把待排序序列分為若干個子序列，每個子序列是有序的。然後再把有序子序列合併為整體有序序列。
歸併排序示例：
合併方法：
設r[i…n]由兩個有序子表r[i…m]和r[m+1…n]組成，兩個子表長度分別為m+1-i 、n+1-m。
- j=m+1；k=i；i=i; //置兩個子表的起始下標及輔助陣列的起始下標
- 若i>m 或j>n，轉⑷ //其中一個子表已合併完，比較選取結束
- //選取r[i]和r[j]較小的存入輔助陣列rf
如果r[i]<r[j]，rf[k]=r[i]； i++； k++； 轉⑵
否則，rf[k]=r[j]； j++； k++； 轉⑵ - //將尚未處理完的子表中元素存入rf
如果i<=m，將r[i…m]存入rf[k…n] //前一子表非空
如果j<=n , 將r[j…n] 存入rf[k…n] //後一子表非空 - 合併結束。
輸出結果：public class MergeSort2 { private static void mergeSort(int[] a) { double len = a.length; int time = (int)len >> 1; //相當於len/2 ，即歸併的趟數 for(int i=0; i<time; i++){ int subLength = 1 << i; //相當於2的i次方 ，子序列的長度 int subNum = (int) Math.ceil(len/((subLength+1)*(i+1))); //子序列數 for(int j=0; j<subNum; j++){ int a1_start = (int) (j*2*subLength< len ? j*2*subLength : len-1); //即下一組歸併開始索引與上一組相差值 int a2_start = (int) (a1_start+subLength < len ? a1_start+subLength : len-1); int a2_end = (int) ((a1_start+2*subLength-1) < len ? (a1_start+2*subLength-1): len-1); //防止最後一個越界 merge(a, a1_start, a2_start, a2_end); } System.out.println("-------------歸併排序後:-------------"); print(a); System.out.println("************************************"); } } //歸併函式，傳入的引數分別為：原陣列，第一個字序列的開始索引，第二個字序列的開始索引，第二個字序列的結束索引 private static void merge(int[] a, int a1_start, int a2_start, int a2_end){ int len = a.length; int[] rf = new int[a2_end-a1_start+1]; int i = a1_start, j = a2_start, k = 0; while( i<a2_start && j <= a2_end){ if(a[i]<a[j]){ rf[k] = a[i]; i++; k++; }else{ rf[k] = a[j]; j++; k++; } } while(i<a2_start){ rf[k] = a[i]; k++; i++; } while(j <= a2_end){ rf[k] = a[j]; k++; j++; } //拷貝rf陣列，到原陣列 arraycopy(源陣列，源陣列開始索引，目標陣列，目標陣列開始索引，需要拷貝的長度); System.arraycopy(rf,0,a,a1_start,rf.length); print(a); } // 列印陣列 public static void print(int[] arr) { for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); } System.out.println(); } public static void main(String[] args) { int a[] = { 49, 38, 65, 97, 76, 13, 27}; System.out.println("排序前 ： "); print(a); System.out.println("排序 ： "); mergeSort(a); print(a); } }
排序前 ： 49 38 65 97 76 13 27 排序 ： 38 49 65 97 76 13 27 38 49 65 97 76 13 27 38 49 65 97 13 76 27 38 49 65 97 13 76 27 -------------歸併排序後:------------- 38 49 65 97 13 76 27 ************************************ 38 49 65 97 13 76 27 38 49 65 97 13 27 76 -------------歸併排序後:------------- 38 49 65 97 13 27 76 ************************************ 13 27 38 49 65 76 97 -------------歸併排序後:------------- 13 27 38 49 65 76 97 ************************************ 13 27 38 49 65 76 97
歸併的迭代演算法(方法二)
1 個元素的表總是有序的。所以對n 個元素的待排序列，每個元素可看成1 個有序子表。對子表兩兩合併生成n/2個子表，所得子表除最後一個子表長度可能為1 外，其餘子表長度均為2。再進行兩兩合併，直到生成n 個元素按關鍵碼有序的表。
public class MergeSort {
// private static long sum = 0;
/**
* <pre>
* 二路歸併
* 原理：將兩個有序表合併和一個有序表
* </pre>
*
* @param a
* @param s
* 第一個有序表的起始下標
* @param m
* 第二個有序表的起始下標
* @param t
* 第二個有序表的結束小標
*
*/
private static void merge(int[] a, int s, int m, int t) {
int[] tmp = new int[t - s + 1];
int i = s, j = m, k = 0;
while (i < m && j <= t) {
if (a[i] <= a[j]) {
tmp[k] = a[i];
k++;
i++;
} else {
tmp[k] = a[j];
j++;
k++;
}
}
while (i < m) {
tmp[k] = a[i];
i++;
k++;
}
while (j <= t) {
tmp[k] = a[j];
j++;
k++;
}
System.arraycopy(tmp, 0, a, s, tmp.length);
print(a);
}
/**
*
* @param a
* @param s
* @param len
* 每次歸併的有序集合的長度
*/
public static void mergeSort(int[] a, int s, int len) {
int size = a.length;
int mid = size / (len << 1); // size/(len*2)
int c = size & ((len << 1) - 1); // 判斷陣列長度奇偶數
// -------歸併到只剩一個有序集合的時候結束演算法-------//
if (mid == 0)
return;
// ------進行一趟歸併排序-------//
for (int i = 0; i < mid; ++i) {
s = i * 2 * len;
merge(a, s, s + len, (len << 1) + s - 1);
}
// -------將剩下的數和倒數一個有序集合歸併-------//
if (c != 0)
merge(a, size - c - 2 * len, size - c, size - 1);
// -------遞迴執行下一趟歸併排序------//
mergeSort(a, 0, 2 * len);
}
public static void main(String[] args) {
int[] a = new int[] {49, 38, 65, 97, 76, 13, 27 };
mergeSort(a, 0, 1);
for (int i = 0; i < a.length; ++i) {
System.out.print(a[i] + " ");
}
}
// 列印陣列
public static void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
輸出結果：
38 49 65 97 76 13 27
38 49 65 97 76 13 27
38 49 65 97 13 76 27
38 49 65 97 13 27 76
38 49 65 97 13 27 76
13 27 38 49 65 76 97
13 27 38 49 65 76 97
7. 歸併排序（Merge Sort）
基本思想：
歸併（Merge）排序法是將兩個（或兩個以上）有序表合併成一個新的有序表，即把待排序序列分為若干個子序列，每個子序列是有序的。然後再把有序子序列合併為整體有序序列。
歸併排序示例：
合併方法：
設r[i…n]由兩個有序子表r[i…m]和r[m+1…n]組成，兩個子表長度分別為m+1-i 、n+1-m。
- j=m+1；k=i；i=i; //置兩個子表的起始下標及輔助陣列的起始下標
- 若i>m 或j>n，轉⑷ //其中一個子表已合併完，比較選取結束
- //選取r[i]和r[j]較小的存入輔助陣列rf
如果r[i]<r[j]，rf[k]=r[i]； i++； k++； 轉⑵
否則，rf[k]=r[j]； j++； k++； 轉⑵ - //將尚未處理完的子表中元素存入rf
如果i<=m，將r[i…m]存入rf[k…n] //前一子表非空
如果j<=n , 將r[j…n] 存入rf[k…n] //後一子表非空 - 合併結束。
public class MergeSort2 {
private static void mergeSort(int[] a) {
double len = a.length;
int time = (int)len >> 1; //相當於len/2 ，即歸併的趟數
for(int i=0; i<time; i++){
int subLength = 1 << i; //相當於2的i次方 ，子序列的長度
int subNum = (int) Math.ceil(len/((subLength+1)*(i+1))); //子序列數
for(int j=0; j<subNum; j++){
int a1_start = (int) (j*2*subLength< len ? j*2*subLength : len-1); //即下一組歸併開始索引與上一組相差值
int a2_start = (int) (a1_start+subLength < len ? a1_start+subLength : len-1);
int a2_end = (int) ((a1_start+2*subLength-1) < len ? (a1_start+2*subLength-1): len-1); //防止最後一個越界
merge(a, a1_start, a2_start, a2_end);
}
System.out.println("-------------歸併排序後:-------------");
print(a);
System.out.println("************************************");
}
}
//歸併函式，傳入的引數分別為：原陣列，第一個字序列的開始索引，第二個字序列的開始索引，第二個字序列的結束索引
private static void merge(int[] a, int a1_start, int a2_start, int a2_end){
int len = a.length;
int[] rf = new int[a2_end-a1_start+1];
int i = a1_start, j = a2_start, k = 0;
while( i<a2_start && j <= a2_end){
if(a[i]<a[j]){
rf[k] = a[i];
i++;
k++;
}else{
rf[k] = a[j];
j++;
k++;
}
}
while(i<a2_start){
rf[k] = a[i];
k++;
i++;
}
while(j <= a2_end){
rf[k] = a[j];
k++;
j++;
}
//拷貝rf陣列，到原陣列 arraycopy(源陣列，源陣列開始索引，目標陣列，目標陣列開始索引，需要拷貝的長度);
System.arraycopy(rf,0,a,a1_start,rf.length);
print(a);
}
// 列印陣列
public static void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
public static void main(String[] args) {
int a[] = { 49, 38, 65, 97, 76, 13, 27};
System.out.println("排序前 ： ");
print(a);
System.out.println("排序 ： ");
mergeSort(a);
print(a);
}
}
排序前 ：
49 38 65 97 76 13 27
排序 ：
38 49 65 97 76 13 27
38 49 65 97 76 13 27
38 49 65 97 13 76 27
38 49 65 97 13 76 27
-------------歸併排序後:-------------
38 49 65 97 13 76 27
************************************
38 49 65 97 13 76 27
38 49 65 97 13 27 76
-------------歸併排序後:-------------
38 49 65 97 13 27 76
************************************
13 27 38 49 65 76 97
-------------歸併排序後:-------------
13 27 38 49 65 76 97
************************************
13 27 38 49 65 76 97
歸併的迭代演算法(方法二)
1 個元素的表總是有序的。所以對n 個元素的待排序列，每個元素可看成1 個有序子表。對子表兩兩合併生成n/2個子表，所得子表除最後一個子表長度可能為1 外，其餘子表長度均為2。再進行兩兩合併，直到生成n 個元素按關鍵碼有序的表。
public class MergeSort {
// private static long sum = 0;
/**
* <pre>
* 二路歸併
* 原理：將兩個有序表合併和一個有序表
* </pre>
*
* @param a
* @param s
* 第一個有序表的起始下標
* @param m
* 第二個有序表的起始下標
* @param t
* 第二個有序表的結束小標
*
*/
private static void merge(int[] a, int s, int m, int t) {
int[] tmp = new int[t - s + 1];
int i = s, j = m, k = 0;
while (i < m && j <= t) {
if (a[i] <= a[j]) {
tmp[k] = a[i];
k++;
i++;
} else {
tmp[k] = a[j];
j++;
k++;
}
}
while (i < m) {
tmp[k] = a[i];
i++;
k++;
}
while (j <= t) {
tmp[k] = a[j];
j++;
k++;
}
System.arraycopy(tmp, 0, a, s, tmp.length);
print(a);
}
/**
*
* @param a
* @param s
* @param len
* 每次歸併的有序集合的長度
*/
public static void mergeSort(int[] a, int s, int len) {
int size = a.length;
int mid = size / (len << 1); // size/(len*2)
int c = size & ((len << 1) - 1); // 判斷陣列長度奇偶數
// -------歸併到只剩一個有序集合的時候結束演算法-------//
if (mid == 0)
return;
// ------進行一趟歸併排序-------//
for (int i = 0; i < mid; ++i) {
s = i * 2 * len;
merge(a, s, s + len, (len << 1) + s - 1);
}
// -------將剩下的數和倒數一個有序集合歸併-------//
if (c != 0)
merge(a, size - c - 2 * len, size - c, size - 1);
// -------遞迴執行下一趟歸併排序------//
mergeSort(a, 0, 2 * len);
}
public static void main(String[] args) {
int[] a = new int[] {49, 38, 65, 97, 76, 13, 27 };
mergeSort(a, 0, 1);
for (int i = 0; i < a.length; ++i) {
System.out.print(a[i] + " ");
}
}
// 列印陣列
public static void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
輸出結果：
38 49 65 97 76 13 27
38 49 65 97 76 13 27
38 49 65 97 13 76 27
38 49 65 97 13 27 76
38 49 65 97 13 27 76
13 27 38 49 65 76 97
13 27 38 49 65 76 97