蟲子 歸并 計數 內核必備，基本算法，linux二次發育，項目遠見

排序

常見的排序算法

常見排序算法的實現

歸并排序

基本思想

遞歸寫法

通過調試看一下現象

歸并順序

排序

常見的排序算法

常見排序算法的實現

歸并排序

基本思想

遞歸寫法

通過調試看一下現象

歸并順序

歸并排序遞歸子函數

歸并排序遞歸實現

非遞歸寫法

2^n^個元素的數組

隨便幾個元素的數組

修正下標

歸并排序非遞歸實現? ? ? ??修正下標

歸一部分拷一部分

歸并排序非遞歸實現? ? ? ? 歸一部分拷一部分

歸并排序的特性總結

時間復雜度

測性能

1000? ? 一千

10000? ? 一萬? ? ==先拋棄選擇和冒泡==

100000? ? 十萬? ? ? ? ? ==再拋棄直接插入==

1000000? ? 一百萬

10000000? ? 一千萬

代碼

Sort.h

Sort.c

test.c

排序

常見的排序算法

常見排序算法的實現

歸并排序

歸并排序（MERGE-SORT）是建立在歸并操作上的一種有效的排序算法,該算法是采用分治法（Divide and Conquer）的一個非常典型的應用。將已有序的子序列合并，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合并成一個有序表，稱為二路歸并。 歸并排序核心步驟：

實際上歸并我們不是第一次接觸，之前我們也是接觸過的，比如合并兩個有序數組這個就是歸并思想

但是我們上面的題目是左區間有序，右區間也有序。我們正常題目肯定不會直接給你有序。這時候再深一點，你不是沒有序嗎，那我們再分，分到你無法再分，==也就是只有一個了，你能說一個沒有序嗎，肯定不行==，所以我們繼續分治。

看上面的GIF也知道第一反應是遞歸

// 歸并排序遞歸子函數 void _MergeSort(int* a, int left, int right, int* tmp){ //左大于右說明是空數組，空數組就跳 //左等于右就是我們要的單體有序 if (left >= right) return; //防溢出寫法 int mid = left + (right - left) / 2; _MergeSort(a, left, mid, tmp); _MergeSort(a, mid+1,right, tmp); // int begin1 = left; int end1 = mid; int begin2 = mid + 1; int end2 = right; int i = left; //跑空一組就直接跳 while (begin1<=end1 && begin2<=end2){ if (a[begin1] < a[begin2]) { tmp[i++] = a[begin1++]; } else { tmp[i++] = a[begin2++]; } } while (begin1 <= end1) { tmp[i++] = a[begin1++]; } while (begin2 <= end2) { tmp[i++] = a[begin2++]; } //把tmp數組拷貝回到原來的數組中 i = left; while (i<=right) { a[i] = tmp[i]; i++; } }

// 歸并排序遞歸實現 void MergeSort(int* a, int n) { assert(a); //首先創建一個臨時數組 int* tmp = (int*)malloc(sizeof(int) * n); //空就直接錯 assert(tmp); //子函數 _MergeSort(a, 0, n - 1, tmp); //不用了就free掉 free(tmp); //然后置空 tmp = NULL; }

我們看到上面好像沒啥問題，那是用為數組元素個數真的太有好了，一直沒有落單的元素，好的不真實

越界情況討論

但是出現另一種惡心情況 ==重復拷貝==

所以接下來我們需要解決index問題

我們修正到n-1，同樣也可以把數組修不存在，讓他不進下面的循環也就可以不會進行歸并

// 歸并排序非遞歸實現 void MergeSortNonR(int* a, int n) { assert(a); //首先創建一個臨時數組 int* tmp = (int*)malloc(sizeof(int) * n); //空就直接錯 assert(tmp); int gap = 1; int i = 0; while (gap= n) { end1 = n - 1; } //[begin2,end2]不存在 if (begin2 >= n) { begin2 = n ; end2 = n - 1; } //end2出界 if (end2 >= n) { end2 = n - 1; } //printf("[%d,%d],[%d,%d]",begin1,end1,begin2,end2); ////重復拷貝基本是我們修正到同一個位置的原因 ////我們條件斷點一下 //if (begin1 == end1 && end1 == begin2 && begin2 == end2 && end2 == n-1) //{ // //隨便一個代碼來承接斷點，一句費代碼 // int a = 0; //} //tmp需要一個索引 int index = i; while (begin1 <= end1 && begin2 <= end2){ if (a[begin1] > a[begin2]) { tmp[index++] = a[begin2++]; } else{ tmp[index++] = a[begin1++]; } } //肯定還有一個沒跑完 while (begin1 <= end1){ tmp[index++] = a[begin1++]; } while (begin2 <= end2) { tmp[index++] = a[begin2++]; } //printf(" %d", index); } //printf("\n"); //一行歸并完了再考回去 for (i = 0; i < n; i++) { a[i] = tmp[i]; } gap *= 2; } //不用了就free掉 free(tmp); //然后置空 tmp = NULL; }

我們也可以像遞歸那樣歸一半分拷貝一部分，就不需要修正了，因為修正要考慮很多邊界情況，有點繁瑣

// 歸并排序非遞歸實現 void MergeSortNonR(int* a, int n) { assert(a); //首先創建一個臨時數組 int* tmp = (int*)malloc(sizeof(int) * n); //空就直接錯 assert(tmp); int gap = 1; int i = 0; while (gap= n) { // end1 = n - 1; //} ////[begin2,end2]不存在 //if (begin2 >= n) { // begin2 = n ; // end2 = n - 1; //} ////end2出界 //if (end2 >= n) { // end2 = n - 1; //} //適用任何元素個數的核心部分 //end1出界，[begin2,end2]不存在 都不需要歸并 if (end1 >= n || begin2 >= n) { //直接跳，因為是在原數組操作的不需要擔心最后一個沒考進去 break; } //end2出界 需要歸并 就修正 if (end2 >= n) { end2 = n - 1; } //printf("[%d,%d],[%d,%d]",begin1,end1,begin2,end2); ////重復拷貝基本是我們修正到同一個位置的原因 ////我們條件斷點一下 //if (begin1 == end1 && end1 == begin2 && begin2 == end2 && end2 == n-1) //{ // //隨便一個代碼來承接斷點，一句費代碼 // int a = 0; //} //tmp需要一個索引 int index = i; while (begin1 <= end1 && begin2 <= end2){ if (a[begin1] > a[begin2]) { tmp[index++] = a[begin2++]; } else{ tmp[index++] = a[begin1++]; } } //肯定還有一個沒跑完 while (begin1 <= end1){ tmp[index++] = a[begin1++]; } while (begin2 <= end2) { tmp[index++] = a[begin2++]; } //歸一部分拷貝一部分 int j = 0; for (j = i; j <= end2; j++) { a[j] = tmp[j]; } //printf(" %d", index); } //printf("\n"); ////一行歸并完了再考回去 //for (i = 0; i < n; i++) { // a[i] = tmp[i]; //} gap *= 2; } //不用了就free掉 free(tmp); //然后置空 tmp = NULL; }

歸并的缺點在于需要O(N)的空間復雜度，歸并排序的思考更多的是解決在磁盤中的外排序問題。

時間復雜度：O(N*logN)

空間復雜度：O(N)

穩定性：穩定

時間復雜度:O(N*logN)

歸并排序方法就是把一組n個數的序列，折半分為兩個序列，然后再將這兩個序列再分，一直分下去，直到分為n個長度為1的序列。然后兩兩按大小歸并。如此反復，直到最后形成包含n個數的一個數組。

==歸并排序總時間=分解時間+子序列排好序時間+合并時間==

無論每個序列有多少數都是折中分解，所以分解時間是個常數，可以忽略不計。

==則：歸并排序總時間=子序列排好序時間+合并時間==

測性能

代碼

#pragma once #include #include #include #include #define HEAP 1 // 排序實現的接口 // 打印數組 extern void PrintArray(int* a, int n); // 插入排序 extern void InsertSort(int* a, int n); // 希爾排序 extern void ShellSort(int* a, int n); //數據交換 extern void Swap(int* pa, int* pb); // 選擇排序 extern void SelectSort(int* a, int n); //向下調整 extern void AdjustDwon(int* a, int n, int parent); // 堆排序 extern void HeapSort(int* a, int n); // 冒泡排序 extern void BubbleSort(int* a, int n); // 快速排序遞歸實現 // 快速排序hoare版本 extern int PartSort1(int* a, int left, int right); // 快速排序挖坑法 extern int PartSort2(int* a, int left, int right); // 快速排序前后指針法 extern int PartSort3(int* a, int left, int right); extern void QuickSort(int* a, int left, int right); // 快速排序 非遞歸實現 extern void QuickSortNonR(int* a, int left, int right); // 歸并排序遞歸實現 extern void MergeSort(int* a, int n); // 歸并排序非遞歸實現 extern void MergeSortNonR(int* a, int n); // 計數排序 extern void CountSort(int* a, int n);

#define _CRT_SECURE_NO_WARNINGS 1 #include "Sort.h" #include"Stack.h" // 打印數組 void PrintArray(int* a, int n) { assert(a); int i = 0; for (i = 0; i < n; i++) { printf("%d ", a[i]); } printf("\n"); } // 插入排序 void InsertSort(int* a, int n) { assert(a); int i = 0; for (i = 0; i < n - 1; i++) { int end = i; int x = a[end+1]; while (end >= 0) { //要插入的數比順序中的數小就準備挪位置 if (a[end] > x) { a[end + 1] = a[end]; end--; } else { //插入的數比順序中的要大就跳出 break; } } //跳出來兩種情況 //1.end == -1 的時候 //2.break 的時候 //把x給end前面一位 a[end + 1] = x; } } // 希爾排序 void ShellSort(int* a, int n) { //分組 int gap = n; //多次預排序（gap>1）+ 直接插入（gap == 1） while (gap>1){ //gap /= 2; //除以三我們知道不一定會過1，所以我們+1讓他有一個必過1的條件 gap = gap / 3 + 1; //單組多躺 int i = 0; for (i = 0; i < n - gap; i++) { int end = i; int x = a[end + gap]; while (end >= 0) { if (a[end] > x) { a[end + gap] = a[end]; //步長是gap end -= gap; } else { break; } } a[end + gap] = x; } } } //數據交換 void Swap(int* pa, int* pb) { int tmp = *pa; *pa = *pb; *pb = tmp; } // 選擇排序 void SelectSort(int* a, int n) { int begin = 0; int end = n - 1; while (begin < end){ //單趟 //最大數，最小數的下標 int mini = begin;//這邊假設是剛開始的下標 int maxi = end; //這邊假設是末尾的下標 int i = 0; for (i = begin; i <= end; i++) { if (a[i] < a[mini]) mini = i; if (a[i] > a[maxi]) maxi = i; } //最小的放前面 Swap(&a[begin], &a[mini]); if (begin == maxi) //如果最大數就是begin位置的，那么交換的時候最大數連帶著下標一起動 maxi = mini; //最大的放后面 Swap(&a[end], &a[maxi]); begin++; end--; } } //向下調整函數 void AdjustDown(int* a, int n, int parent) { assert(a); //創建一個孩子變量，有兩個孩子就在這個上加1就行 int child = parent * 2 + 1; #if HEAP while (child < n) { //選大孩子 if (child + 1 < n && a[child] < a[child + 1]) { child++; } //大的孩子還大于父親就交換 if (a[child] > a[parent]) { Swap(&a[child], &a[parent]); parent = child; child = parent * 2 + 1; } else { break; } } #elif !HEAP while (child < n) { //選小孩子 if (child + 1 < n && a[child] > a[child + 1]) { child++; } //小的孩子還小于父親就交換 if (a[child] < a[parent]) { Swap(&a[child], &a[parent]); parent = child; child = parent * 2 + 1; } else { break; } } #endif // HEAP } // 堆排序 我們之前講過升序建大堆 void HeapSort(int* a, int n) { //建堆時間復雜度O(N) //建大堆 int i = 0; for (i = (n - 1 - 1) / 2; i >= 0; i--) { AdjustDown(a, n, i); } int end = n - 1; //堆排序時間復雜度O(N*logN) while (end>0){ //交換 把最大的放到后面 Swap(&a[0], &a[end]); //在向下調整 AdjustDown(a,end,0); end--; } } // 冒泡排序 void BubbleSort(int* a, int n) { //多躺 int j = 0; for (j = 0; j < n - 1; j++) { //交換標記變量 int flag = 0; //單趟 int i = 0; for (i = 0; i < n - 1-j; i++) { if (a[i] > a[i + 1]) { //交換標記改變 flag = 1; Swap(&a[i], &a[i + 1]); } } //標記還是0就跳出 if (!flag) break; } } //三數取中 int GetMinIndex(int* a, int left, int right) { //這樣可以防止 int 溢出 int mid = left + (right - left) / 2; if (a[left] < a[mid]) { if (a[mid] < a[right]) return mid; else if (a[left] > a[right]) return left; else return right; } else //a[left] >= a[mid] { if (a[mid] > a[right]) return mid; else if (a[left] < a[right]) return left; else return right; } } // 快速排序hoare版本 單趟排序 //最左邊做key [left,right] 我們這里給區間 int PartSort1(int* a, int left, int right) { //三數取中 int mini = GetMinIndex(a, left, right); //把中間的數放到最左邊，交換即可 Swap(&a[mini], &a[left]); //還是最左邊為keyi int keyi = left; //左右相遇就停止 while (left < right) { //最左邊為key，那么最右邊就先動 //找小于key的 while (left < right && a[right] >= a[keyi]) { right--; } //然后再動右邊的 //找大于key的 while (left < right && a[left] <= a[keyi]) { left++; } Swap(&a[left], &a[right]); } Swap(&a[keyi], &a[right]); //返回正確位置后的keyi return left; } // 快速排序挖坑法 int PartSort2(int* a, int left, int right) { assert(a); //三數取中 int mini = GetMinIndex(a, left, right); //把中間的數放到最左邊，交換即可 Swap(&a[mini], &a[left]); //先把Key存下來 int Key = a[left]; //挖坑 int pit = left; while (left= Key) { right--; } //找到后把數據扔到坑里面去 Swap(&a[right],&a[pit]); //自己就變成新的坑 pit = right; //左邊找大 while (left < right && a[left] <= Key) { left++; } //找到后把數據扔到坑里面去 Swap(&a[left], &a[pit]); //自己就變成新的坑 pit = left; } //出來后把Key放到坑里面去 a[pit] = Key; return pit; } // 快速排序前后指針法 int PartSort3(int* a, int left, int right) { assert(a); //三數取中 int mini = GetMinIndex(a, left, right); //把中間的數放到最左邊，交換即可 Swap(&a[mini], &a[left]); //把keyi記下來 int keyi = left; int prev = left; int cur = prev + 1; while (cur <= right){ ////比Key小就跳出 //while (cur <= right && a[cur] >= a[keyi]) { // cur++; //} //if (cur <= right) { // //跳出來prev++ // prev++; // //交換 // Swap(&a[prev], &a[cur]); // //交換完后cur也++ // cur++; //} if(a[cur] < a[keyi]) Swap(&a[prev++], &a[cur]); cur++; } //跳出來說明交換a[prev]和Key Swap(&a[prev],&a[keyi]); return prev; } // 快速排序 小區間優化 void QuickSort(int* a, int left, int right) { if (left >= right) return; if (right - left + 1 < 10)//10以內的數插入 { InsertSort(a + left, right - left + 1); } else { int keyi = PartSort3(a, left, right); //[left,keyi-1] keyi [keyi+1,right] QuickSort(a, left, keyi - 1); QuickSort(a, keyi + 1, right); } } // 快速排序 非遞歸實現 void QuickSortNonR(int* a, int left, int right) { //建棧 ST st; //初始化棧 StackInit(&st); //left進棧 StackPush(&st, left); //right進棧 StackPush(&st, right); //空棧跳出 while (!StackEmpty(&st)) { //先取尾 int end = StackTop(&st); //pop掉 StackPop(&st); //再取頭 int start = StackTop(&st); //再pop掉 StackPop(&st); //然后單趟排序找到keyi int keyi = PartSort3(a,start,end); //[start,keyi-1] keyi [keyi+1,end] if (keyi + 1 < end)//表示分割開來的區間大于1 { //因為我們先取尾，所以問先入頭 StackPush(&st, keyi + 1); //再入尾 StackPush(&st, end); } if (keyi - 1 > start)//表示分割開來的區間大于1 { //因為我們先取尾，所以問先入頭 StackPush(&st, start); //再入尾 StackPush(&st, keyi - 1); } } //與初始化聯動的棧銷毀 StackDestroy(&st); } // 歸并排序遞歸子函數 void _MergeSort(int* a, int left, int right, int* tmp){ //左大于右說明是空數組，空數組就跳 //左等于右就是我們要的單體有序 if (left >= right) return; //防溢出寫法 int mid = left + (right - left) / 2; _MergeSort(a, left, mid, tmp); _MergeSort(a, mid+1,right, tmp); // int begin1 = left; int end1 = mid; int begin2 = mid + 1; int end2 = right; int i = left; //跑空一組就直接跳 while (begin1<=end1 && begin2<=end2){ if (a[begin1] < a[begin2]) { tmp[i++] = a[begin1++]; } else { tmp[i++] = a[begin2++]; } } while (begin1 <= end1) { tmp[i++] = a[begin1++]; } while (begin2 <= end2) { tmp[i++] = a[begin2++]; } //把tmp數組拷貝回到原來的數組中 i = left; while (i<=right) { a[i] = tmp[i]; i++; } } // 歸并排序遞歸實現 void MergeSort(int* a, int n) { assert(a); //首先創建一個臨時數組 int* tmp = (int*)malloc(sizeof(int) * n); //空就直接錯 assert(tmp); //子函數 _MergeSort(a, 0, n - 1, tmp); //不用了就free掉 free(tmp); //然后置空 tmp = NULL; } // 歸并排序非遞歸實現 void MergeSortNonR(int* a, int n) { assert(a); //首先創建一個臨時數組 int* tmp = (int*)malloc(sizeof(int) * n); //空就直接錯 assert(tmp); int gap = 1; int i = 0; while (gap= n) { // end1 = n - 1; //} ////[begin2,end2]不存在 //if (begin2 >= n) { // begin2 = n ; // end2 = n - 1; //} ////end2出界 //if (end2 >= n) { // end2 = n - 1; //} //適用任何元素個數的核心部分 //end1出界，[begin2,end2]不存在 都不需要歸并 if (end1 >= n || begin2 >= n) { //直接跳，因為是在原數組操作的不需要擔心最后一個沒考進去 break; } //end2出界 需要歸并 就修正 if (end2 >= n) { end2 = n - 1; } //printf("[%d,%d],[%d,%d]",begin1,end1,begin2,end2); ////重復拷貝基本是我們修正到同一個位置的原因 ////我們條件斷點一下 //if (begin1 == end1 && end1 == begin2 && begin2 == end2 && end2 == n-1) //{ // //隨便一個代碼來承接斷點，一句費代碼 // int a = 0; //} //tmp需要一個索引 int index = i; while (begin1 <= end1 && begin2 <= end2){ if (a[begin1] > a[begin2]) { tmp[index++] = a[begin2++]; } else{ tmp[index++] = a[begin1++]; } } //肯定還有一個沒跑完 while (begin1 <= end1){ tmp[index++] = a[begin1++]; } while (begin2 <= end2) { tmp[index++] = a[begin2++]; } //歸一部分拷貝一部分 int j = 0; for (j = i; j <= end2; j++) { a[j] = tmp[j]; } //printf(" %d", index); } //printf("\n"); ////一行歸并完了再考回去 //for (i = 0; i < n; i++) { // a[i] = tmp[i]; //} gap *= 2; } //不用了就free掉 free(tmp); //然后置空 tmp = NULL; }

#define _CRT_SECURE_NO_WARNINGS 1 #include "Sort.h" // 測試排序的性能對比 void TestOP() { //設置隨機起點 srand(time(NULL)); //將要創建的數組大小 const int N = 10000000; int* a1 = (int*)malloc(sizeof(int) * N); int* a2 = (int*)malloc(sizeof(int) * N); int* a3 = (int*)malloc(sizeof(int) * N); int* a4 = (int*)malloc(sizeof(int) * N); int* a5 = (int*)malloc(sizeof(int) * N); int* a6 = (int*)malloc(sizeof(int) * N); int* a7 = (int*)malloc(sizeof(int) * N); int* a8 = (int*)malloc(sizeof(int) * N); int* a9 = (int*)malloc(sizeof(int) * N); for (int i = 0; i < N; ++i) { //保證兩個數組是一樣的 a1[i] = rand(); a2[i] = a1[i]; a3[i] = a1[i]; a4[i] = a1[i]; a5[i] = a1[i]; a6[i] = a1[i]; a7[i] = a1[i]; a8[i] = a1[i]; a9[i] = a1[i]; } int begin1 = clock();//開始時間 //InsertSort(a1, N); int end1 = clock(); //結束時間 int begin2 = clock(); ShellSort(a2, N); int end2 = clock(); int begin3 = clock(); //SelectSort(a3, N); int end3 = clock(); int begin4 = clock(); HeapSort(a4, N); int end4 = clock(); int begin5 = clock(); //BubbleSort(a5, N); int end5 = clock(); int begin6 = clock(); QuickSort(a6, 0, N - 1); int end6 = clock(); int begin7 = clock(); QuickSortNonR(a7, 0, N - 1); int end7 = clock(); int begin8 = clock(); MergeSort(a8, N); int end8 = clock(); int begin9 = clock(); MergeSort(a9, N); int end9 = clock(); printf("InsertSort:%d\n", end1 - begin1);//結束時間減去開始時間 printf("ShellSort:%d\n", end2 - begin2); printf("SelectSort:%d\n", end3 - begin3); printf("HeapSort:%d\n", end4 - begin4); printf("BubbleSort:%d\n", end5 - begin5); printf("QuickSort:%d\n", end6 - begin6); printf("QuickSortNonR:%d\n", end7 - begin7); printf("MergeSort:%d\n", end8 - begin8); printf("MergeSortNonR:%d\n", end9 - begin9); free(a1); free(a2); free(a3); free(a4); free(a5); free(a6); free(a7); free(a8); free(a9); } //測試插入排序 void TestInsertSort() { int a[] = { 1,5,3,7,0,9 }; InsertSort(a, sizeof(a) / sizeof(a[0])); PrintArray(a, sizeof(a) / sizeof(a[0])); } //測試希爾排序 void TestShellSort() { int a[] = { 9,1,2,5,7,4,8,6,3,5 }; ShellSort(a, sizeof(a) / sizeof(a[0])); PrintArray(a, sizeof(a) / sizeof(a[0])); } //測試選擇排序 void TestSelectSort() { int a[] = { 9,1,2,5,7,4,8,6,3,5 }; SelectSort(a, sizeof(a) / sizeof(a[0])); PrintArray(a, sizeof(a) / sizeof(a[0])); } //測試堆排序 void TestHeapSort() { int a[] = { 9,1,2,5,7,4,8,6,3,5 }; HeapSort(a, sizeof(a) / sizeof(a[0])); PrintArray(a, sizeof(a) / sizeof(a[0])); } //測試冒泡排序 void TestBubbleSort() { int a[] = { 9,1,2,5,7,4,8,6,3,5 }; BubbleSort(a, sizeof(a) / sizeof(a[0])); PrintArray(a, sizeof(a) / sizeof(a[0])); } //測試單趟排序 void TestPartSort1() { int a[] = { 5,5,5,5,5,5,5,5,5,5 }; PartSort1(a,0 ,sizeof(a) / sizeof(a[0])-1); PrintArray(a, sizeof(a) / sizeof(a[0])); } //測試快速排序 void TestQuickSort() { int a[] = { 9,1,2,5,7,4,8,6,3,5 }; QuickSort(a, 0, sizeof(a) / sizeof(a[0]) - 1); PrintArray(a, sizeof(a) / sizeof(a[0])); } //測試快速排序--非遞歸 void TestQuickSortNonR() { int a[] = { 9,1,2,5,7,4,8,6,3,5 }; QuickSortNonR(a, 0, sizeof(a) / sizeof(a[0]) - 1); PrintArray(a, sizeof(a) / sizeof(a[0])); } //測試歸并排序--遞歸 void TestMergeSort() { int a[] = { 10,6,7,1,3,9,4,2 }; MergeSort(a, sizeof(a) / sizeof(a[0])); PrintArray(a, sizeof(a) / sizeof(a[0])); } //測試歸并排序--非遞歸 void TestMergeSortNonR() { int a[] = { 10,6,7,1,3,9,4,2,5 }; MergeSortNonR(a, sizeof(a) / sizeof(a[0])); PrintArray(a, sizeof(a) / sizeof(a[0])); } int main(){ //TestInsertSort(); //TestShellSort(); //TestSelectSort(); //TestHeapSort(); //TestBubbleSort(); //TestPartSort1(); //TestQuickSort(); //TestQuickSortNonR(); //TestMergeSort(); //TestMergeSortNonR(); TestOP(); return 0; }

數據結構

版權聲明：本文內容由網絡用戶投稿，版權歸原作者所有，本站不擁有其著作權，亦不承擔相應法律責任。如果您發現本站中有涉嫌抄襲或描述失實的內容，請聯系我們jiasou666@gmail.com 處理，核實后本網站將在24小時內刪除侵權內容。