数据结构笔记（2）：高级排序

这里介绍两个O(nlogn)的算法，归并排序和快速排序

归并排序：利用分治法的思想将数组一分为二，对分好的两段数组分别进行排序，再排好后的两段进行归并即可。

下面我们说一下归并排序几个可以优化的点：

1. 当待排序的数组元素个数小于15个的时候我们采用插入排序，因为在数据量较大的时候，待排序列小于15个元素时我可以认为这些待排的元素近乎有序，而对于一个近乎有序的数组采用插入排序是接近O(n)的时间复杂度的
2. 只有当arr[mid] > arr[mid + 1]时我们才进行归并

这里还添加一种利用循环（即自底向上）的方式进行的归并排序

void insertionSort(int arr[], int l, int r) {
	for (int i = l + 1; i <= r; i++) {
		int tmp = arr[i];
		int j;
		for (j = i - 1; j >= l; j--) {
			if (tmp < arr[j]) {
				arr[j + 1] = arr[j];
			} else {
				break;
			}
		}
		arr[j + 1] = tmp;
	}
}

void __merge(int arr[], int l, int mid, int r) {
	int aux[r - l + 1];
	for (int i = l; i <= r; i++) {
		aux[i - l] = arr[i];
	}
	int i = l, j = mid + 1;
	for (int k = l; k <= r; k++) {
		if (i > mid) {
			arr[k] = aux[j - l];
			j++;
		} else if (j > r) {
			arr[k] = aux[i - l];
			i++;
		} else if (aux[i - l] < aux[j - l]) {
			arr[k] = aux[i - l];
			i++;
		} else {
			arr[k] = aux[j - l];
			j++;
		}
	}
}

void __mergeSort(int arr[], int l, int r) {
	if (r - l <= 15) {
		insertionSort(arr, l, r);
		return;
	}
	int mid = (r + l) / 2;
	__mergeSort(arr, l, mid);
	__mergeSort(arr, mid + 1, r);
	if (arr[mid] > arr[mid + 1])
		__merge(arr, l, mid, r);
}

void mergeSort(int arr[], int n) {
	return __mergeSort(arr, 0, n - 1);
}

void mergeSortBU(int arr[], int n) {
	for (int sz = 1; sz <= n; sz <<= 1) {
		for (int i = 0; i + sz < n; i += (sz << 1)) {
			if (arr[i + sz - 1] > arr[i + sz]) {
				__merge(arr, i, i + sz - 1, min(i + sz + sz - 1, n - 1));
			}
		}
	}
}

快速排序：随机选一个数作为基准数，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边，在递归对左右区间重复上述过程

这里介绍的是3路快排，即只考虑小于0和大于0的区间不考虑等于0的

void __partition(int arr[], int l, int r, int& lt, int& gt) {
	srand(time(0));
	int x = (rand() % (r - l + 1) + l);
	swap(arr[l], arr[x]);
	int v = arr[l];
	lt = l;
	gt = r + 1;
	int i = l + 1;
	while (i < gt) {
		if (arr[i] == v) {
			i++;
		} else if (arr[i] < v) {
			swap(arr[lt + 1], arr[i]);
			lt++;
			i++;
		} else {
			swap(arr[gt - 1], arr[i]);
			gt--;
		}
	}
	swap(arr[l], arr[lt]);
}

void __quickSort(int arr[], int l, int r) {
	if (r - l <= 15) {
		insertionSort(arr, l, r);
		return;
	}
	int lt, gt;
	__partition(arr, l, r, lt, gt);
	__quickSort(arr, l, lt - 1);
	__quickSort(arr, gt, r);
}

void quickSort(int arr[], int n) {
	__quickSort(arr, 0, n - 1);
}

下面是对上面的程序的测试结果：

1.100000个随机数的彩测试结果

void test0() {
	int n = 1000000;
	int* arr = SortTestHelper::generateRandomArray(n, 0, n);
	int* arr1 = SortTestHelper::copyIntArray(arr, n);
	int* arr2 = SortTestHelper::copyIntArray(arr, n);
        SortTestHelper::testSort("mergeSort", mergeSort, arr, n);
        SortTestHelper::testSort("mergeSortBU", mergeSortBU, arr1, n);
	SortTestHelper::testSort("quickSort", quickSort, arr2, n);
	delete[] arr;
	delete[] arr1;
	delete[] arr2;
}

2.1000000个包含大量重复元素的数组

void test1() {
	int n = 1000000;
	int* arr = SortTestHelper::generateRandomArray(n, 0, 5);
	int* arr1 = SortTestHelper::copyIntArray(arr, n);
	int* arr2 = SortTestHelper::copyIntArray(arr, n);
  SortTestHelper::testSort("mergeSort", mergeSort, arr, n);
  SortTestHelper::testSort("mergeSortBU", mergeSortBU, arr1, n);
	SortTestHelper::testSort("quickSort", quickSort, arr2, n);
	delete[] arr;
	delete[] arr1;
	delete[] arr2;
}

这里可以看出3路快排有非常明显的优势

void test2() {
	int n = 1000000;
	int* arr = SortTestHelper::generateNearlyOrderedArray(n, 100);
	int* arr1 = SortTestHelper::copyIntArray(arr, n);
	int* arr2 = SortTestHelper::copyIntArray(arr, n);
        SortTestHelper::testSort("mergeSort", mergeSort, arr, n);
        SortTestHelper::testSort("mergeSortBU", mergeSortBU, arr1, n);
	SortTestHelper::testSort("quickSort", quickSort, arr2, n);
	delete[] arr;
	delete[] arr1;
	delete[] arr2;
}