（一）算法基础——排序算法

作为算法的入门，排序算法再合适不过了，在这里我主要介绍四种排序算法——插入排序、归并排序、快速排序以及希尔排序。不过在介绍这些算法之前，我们先来做一些准备工作。
（一）算法测试函数
在实现一个算法后，必然要对这个算法进行调试和分析，这里我写了一些函数用于算法的测试。

1. 随机数组生成函数

int* generateRandomArray(int n, int rangeL, int rangeR){
	assert(rangeL<=rangeR);
	int* arr=new int[n];
	scrand(time(NULL));
	for(int i=0;i<n;i++)
		arr[i]=rand()%(rangeR-rangeL+1)+rangeL;
	return arr;
}

2. 数组打印函数

void printArray(int* arr, int n){
	for(int i=0;i<n;i++)
		cout<<arr[i]<<" ";
	cout<<endl;
}

3. 数组有序判断函数

bool isSorted(int* arr, int n){
	for(int i=0;i<n-1;i++)
		if(arr[i]>arr[i+1])
			return false;
	return true;
}

4. 测试算法函数

void TestSort(string SortName, void(*sort)(T[], int n), T arr[], int n) {
  clock_t startTime = clock();
  sort(arr, n);
  clock_t endTime = clock();
  assert(isSorted(arr, n));
  cout << SortName << " : " << double(endTime - startTime) / CLOCKS_PER_SEC << "s";
  cout << endl;
 }

5. 数组复制函数

int* CopyIntArray(int a[], int n) {
  int* arr = new int[n];
  copy(a, a + n, arr);
  return arr;
 }

6. 近似有序数组生成函数

int* generateNearlyOrderArray(int n, int SwapTimes) {
  int* arr = new int[n];
  for (int i = 0; i < n; i++)
   arr[i] = i;
  srand(time(NULL));
  for (int i = 0; i < SwapTimes; i++) {
   int pos1 = rand() % n;
   int pos2 = rand() % n;
   swap(arr[pos1], arr[pos2]);
  }
  return arr;
 }

（二）排序算法介绍

1. 插入排序
2. 归并排序
3. 快速排序
4. 希尔排序

插入排序
所谓插入排序，就是选定一个基准，然后从前向后或是从后向前不断插入。我们举一个例子，数组arr[]={1 6 5 2 8 7}。
arr数组中0-0范围内的数已经排好序了，我们继续看0-1的范围。1 6也已经排好序了，继续看0-2的范围。这时发现，1 6 5顺序没有排好，那么我们来进行插入。5<6,所以5和6进行交换，5>1所以停止，继续看0-4的范围。显然，1 5 6 2没有排好序，2<6，所以2和6交换；2<5，所以2和5交换；2>1所以停止，以此类推。

int insertionSort(int* arr, int n){
	for (int i = 1; i < n; i++) {
  		T temp = arr[i];
  		int j = i;
  		for (; j > 0 && arr[j - 1] > temp; j--) {
   			arr[j] = arr[j - 1];
  		}
  		arr[j] = temp;
  	}
}

虽然插入排序比较简单，但是这是希尔排序的基础。
归并排序
归并排序采用的是分而治之的思想。这里我们不过多的用语言去解释，直接用例子。

void merge(int arr[], int left, int mid, int right) {
 vector<int> aux(right - left + 1);
 for (int i = left; i <= right; i++)
  aux[i - left] = arr[i];
 int i = left, j = mid + 1;
 for (int k = left; k <= right; k++) {
  if (i > mid) {
   arr[k] = aux[j - left];
   j++;
  }
  else if (j > right) {
   arr[k] = aux[i - left];
   i++;
  }
  else if (aux[i - left] < aux[j - left]) {
   arr[k] = aux[i - left];
   i++;
  }
  else {
   arr[k] = aux[j - left];
   j++;
  }
 }
}
void mergeSort(T arr[], int left, int right) {
 /*if (left >= right)
  return;*/
 int mid = left + (right - left) / 2;
 if (right - left <= 15) {
  insertionSort(arr, left, right);
  return;
 }
 else {
  mergeSort(arr, left, mid);
  mergeSort(arr, mid + 1, right);
 }
 if (arr[mid] > arr[mid + 1])
  merge(arr, left, mid, right);
}

快速排序

void quick_sort(int q[], int l, int r)
{
 if (l >= r) return;
 int i = l - 1, j = r + 1, x = q[l + r >> 1];
 while (i < j)
 {
  do i++; while (q[i] < x);
  do j--; while (q[j] > x);
  if (i < j) swap(q[i], q[j]);
 }
 quick_sort(q, l, j), quick_sort(q, j + 1, r);
}