近乎所有排序算法【Template】

#include <cstdio>
#include <stdlib.h>
#include <time.h> 
using namespace std;
 
const int maxn = 100000 + 10;
int T, n;
int a[maxn];

void InsertSort(int L, int R) {
  for (int i = L; i <= R; i ++) {
    for (int j = i; j > L; j --) {
      if (a[j] < a[j - 1]) {
        int t = a[j];
        a[j] = a[j - 1];
        a[j - 1] = t;
      }
      else {
        break;
      }
    }
  }
}

void BubbleSort(int L, int R) {
  for (int i = L; i < R; i ++) {
    for (int j = R; j > i; j --) {
      if (a[j] < a[j - 1]) {
        int t = a[j];
        a[j] = a[j - 1];
        a[j - 1] = t;
      }
    }
  }
}

void SelectionSort(int L, int R) {
  for (int i = L; i < R; i++) {
    int min_number = a[i];
    int number_location = i;
    for (int j = i + 1; j <= R; j++) {
      if (a[j] < min_number) {
        min_number = a[j];
        number_location = j;
      }
    }
    int t = a[i];
    a[i] = a[number_location];
    a[number_location] = t;
  }
}

void ShellSort(int L, int R) {
  for (int k = (R - L + 1) / 2; k >= 1; k = k / 2) {
    for (int s = L; s <= L + k - 1; s ++) {
      for (int i = s; i <= R; i = i + k) {
        for (int j = i; j - k >= s; j = j - k) {
          if (a[j] < a[j - k]) {
            int t = a[j];
            a[j] = a[j - k];
            a[j - k] = t;
          }
          else {
            break;
          }
        }
      }
    }
  }
}

class Heap {
private:
  int heap_[maxn];
  int sz_;
 
public:
  Heap() {
    sz_ = 0;
  }
 
  void Insert(int x) {
    sz_++;
    heap_[sz_] = x;
    int id = sz_;
    while (id > 1) {
      if (heap_[id] < heap_[id / 2]) {
        int t = heap_[id];
        heap_[id] = heap_[id / 2];
        heap_[id / 2] = t;
        id = id / 2;
      }
      else {
        break;
      }
    }
  }
 
  int Get() {
    int res = heap_[1];
    heap_[1] = heap_[sz_];
    sz_--;
    int id = 1;
    while (id <= sz_) {
      if (2 * id > sz_) {
        break;
      }
      int min = heap_[id * 2];
      if (id * 2 + 1 <= sz_ && heap_[id * 2 + 1] < min) {
        min = heap_[id * 2 + 1];
      }
      if (heap_[id] < min) {
        break;
      }
      int to;
      if (heap_[id * 2] == min) {
        to = 2 * id;
      }
      else {
        to = 2 * id + 1;
      }
      int t = heap_[id];
      heap_[id] = heap_[to];
      heap_[to] = t;
      id = to;
    }
    return res;
  }
};

void HeapSort(int L, int R) {
  Heap heap;
  for (int i = L; i <= R; i++) {
    heap.Insert(a[i]);
  }
  for (int i = L; i <= R; i++) {
    a[i] = heap.Get();
  }
}

int b[maxn];
 
void MergeSort(int L, int R) {
  if(L == R) {
    return;
  }
  int mid = (L + R) / 2;
  MergeSort(L, mid);
  MergeSort(mid + 1, R);
  int p1 = L;
  int p2 = mid + 1;
  int k = 0;
  while(p1 <= mid || p2 <= R) {
    if(p1 <= mid && p2 > R) {
      b[k ++] = a[p1 ++];
    } else if(p1 > mid && p2 <= R) {
      b[k ++] = a[p2 ++];
    } else {
      if(a[p1] < a[p2]) {
        b[k ++] = a[p1 ++];
      } else {
        b[k ++] = a[p2 ++];
      }
    }
  }
  for(int i = L; i <= R; i ++) {
    a[i] = b[i - L];
  }
}

int buckets[10][maxn];
int index[10];
int limit;

void BucketSort(int L, int R) {
  int f = 1;
  for(int s = 1; s <= limit; s ++) {
    for(int i = 0; i <= 9; i ++) {
      index[i] = 0;
    }
    for(int i = L; i <= R; i ++) {
      int num = (a[i] / f) % 10;
      buckets[num][index[num]] = a[i];
      index[num] ++; 
    }
    int k = L;
    for(int i = 0; i <= 9; i ++) {
      for(int j = 0; j < index[i]; j ++) {
        a[k] = buckets[i][j];
        k ++;
      }
    }
    f = f * 10;
  }
}

void QuickSort(int L, int R) {
  if (L > R) {
    return;
  }
  int p1 = L;
  int p2 = R;
  int u = rand() % 10000;
  int v = rand() % 10000;
  int pos = u * v % (R - L + 1);
  pos = pos + L;
  int t = a[L];
  a[L] = a[pos];
  a[pos] = t;
  int x = a[L];
  while (p1 < p2) {
    while (p1 < p2 && a[p2] >= x) {
      p2--;
    }
    if (p1 < p2) {
      a[p1] = a[p2];
      p1++;
    }
    while (p1 < p2 && a[p1] < x) {
      p1++;
    }
    if (p1 < p2) {
      a[p2] = a[p1];
      p2--;
    }
  }
  a[p1] = x;
  QuickSort(L, p1 - 1);
  QuickSort(p1 + 1, R);
}
 
int main() {
  srand((unsigned)time(NULL));
  scanf("%d", &T);
  while (T--) {
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
      scanf("%d", &a[i]);
    }
    QuickSort(1, n);
    for (int i = 1; i <= n; i++) {
      printf("%d", a[i]);
      printf("%s", i == n ? "\n" : " ");
    }
  }
  return 0;
}