** sort Big Synthesis **
Sort big comprehensive test I remember.
#include <iostream> #include <stdlib.h> #include <string.h> using namespace std;
void Bubblesort (int a[], int n) {if (NULL = = A | | n = = 0) {return; } for (int i = n-1; i > 0, i--) {for (int j = 0; J < i; J + +) {if (A[j] > a[
J + 1]) {swap (a[j], a[j+ 1]);
}}}} void Insertsort (int a[], int n) {if (NULL = = A | | n = = 0) {return;
} Int J;
for (int i = 1; i < n; i++) {j = i;
while (J > 0 && a[j] < a[j-1]) {swap (a[j-1], a[j]);
j--;
}}} void Merge (int a[], int l, int mid, int r) {int leftsize = mid-l + 1;
int rightsize = R-mid;
int *left = new Int[leftsize];
int *right = new Int[rightsize];
for (int i = 0; i < leftsize; i++) {Left[i] = a[l + i]; } for (int i = 0; i < rightsize;
i++) {Right[i] = A[mid + i + 1];
} int i = 0, j = 0, k = l; while (I < leftsize && J < rightsize) {if (Left[i] < right[j]) {a[k++] =
Left[i++];
} if (Left[i] > Right[j]) {a[k++] = right[j++];
}} while (I < leftsize) {a[k++] = left[i++];
} while (J < rightsize) {a[k++] = right[j++];
} free (left);
Free (right);
} void MergeSort (int a[], int l, int r) {if (L < r) {int mid = (L + r)/2;
MergeSort (A, L, mid);
MergeSort (A, mid + 1, R);
Merge (A, L, Mid, R); }} void QuickSort (int a[], int left, int. right) {if (left < right) {int i = left, j = right, key = a
[Left];
while (I < J && A[j] > key) {j--;
} if (I < j) {a[i++] = a[j]; } WHile (i < J && A[i] < key) {i++;
} if (I < j) {a[j--] = A[i];
} A[i] = key;
QuickSort (A, left, I);
QuickSort (A, i + 1, j);
}} void Choosesort (int a[], int n) {int min, index;
for (int i = 0; i < n; i++) {min = a[i];
for (int j = i + 1; j < N; j + +) {if (A[j] < min) {min = a[j];
index = j;
}} swap (A[i], a[index]);
}} void Shellsort (int a[], int n) {int d = n;
while (d) {d = D/2; for (int i = 0; i < n-d; i++) {if (A[i] > a[i + d]) {swap (a[i], a[
I+d]);
}}}} void Adjustheap (int a[], int start, int end) {int value = A[start]; for (int i = 2*start + 1; I <= end; I *= 2) {if (I < end && A[i] > A[i + 1]) {i++;
} if (Value > A[i]) {A[start] = A[i];
start = i;
} else {break;
}} A[start] = value; } void Heapsort (int a[], int n) {//Build a large top heap for (int i = N/2-1; I >= 0; i--) {Adjustheap (A, I, N)
;
}//heap sort for (int i = n-1; i > 0; i--) {swap (a[0], a[i]);
Adjustheap (A, 0, i-1);
}} int main () {int *arr = new int;
int n = 0;
CIN >> N;
for (int i = 0; i < n; i++) {cin >> arr[i];
}//bubblesort (arr, n);
Insertsort (arr, n);
MergeSort (arr, 0, n-1);
QuickSort (arr, 0, n-1);
Choosesort (arr, n);
Shellsort (arr, n);
Binaryinsertsort heapsort (arr, n);
for (int i = 0; i < n; i++) {cout << arr[i] << "";
} system ("Pause");
return 0; }

PS: Stability can be judged based on whether the relative position of the two same digits will change.