排序小结（二）

排序小结（二）

//并归排序（稳定的排序算法,时间复杂度O(nlogn)）
#include<iostream>
using namespace std;
#define MAX 500000
#define SENTINEL 2000000000


int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;


void merge(int A[], int n, int left, int mid, int right) {
	int n1 = mid - left;
	int n2 = right - mid;
	for (int i = 0; i < n1; i++)L[i] = A[left + i];
	for (int i = 0; i < n2; i++)R[i] = A[mid + i];
	L[n1] = R[n2] = SENTINEL;
	int i = 0, j = 0;
	for (int k = left; k < right; k++) {
		cnt++;
		if (L[i] <= R[i]) {
			A[k] = L[i++];
		}
		else {
			A[k] = R[j++];
		}
	}
}


void mergeSort(int A[],int n,int left,int right) {
	if (left + 1 < right) {
		int mid = (left + right) / 2;
		mergeSort(A, n, left, mid);
		mergeSort(A, n, mid, right);
		merge(A, n, left, mid, right);
	}
}


int main() {
	int A[MAX], n, i;
	cnt = 0;


	cin >> n;
	for (i = 0; i < n; i++)
		cin >> A[i];


	mergeSort(A, n, 0, n);
	
	for (i = 0; i < n; i++) {
		if (i)	cout << " ";
		cout << A[i];
	}
	cout << endl;
	cout << cnt << endl;
	return 0;
}

//分割问题（以数组最后一个元素为中间数，将小于该数的放左边，大于该数的放右边）
//时间复杂度O(n)
#include<stdio.h>
#define MAX 100000
int A[MAX], n;


int partition(int p, int r) {
	int x, i, j, t;
	x = A[r];
	i = p - 1;
	for (j = p; j < r; j++) {
		if (A[j] <= x) {
			i++;
			t = A[i]; A[i] = A[j]; A[j] = t;
		}
	}
	t = A[i + 1]; A[i + 1] = A[r]; A[r] = t;
	return i + 1;
}


int main()
{
	int i, q;
	scanf("%d", &n);
	for (i = 0; i < n; i++)
		scanf("%d", &A[i]);
	q = partition(0, n - 1);
	for (i = 0; i < n; i++)
	{
		if (i)
			printf(" ");
		if (i == 0)
			printf("]");
		printf("%d", A[i]);
		if (i == q)
			printf("]");
	}
	printf("\n");


	return 0;
}

//计数排序（只要从输入数组A的末尾元素开始选择，计数排序就属于稳定的排序算法。）
//平均时间复杂度O(n+k)
//以下代码以数组A非负为前提，其运行所需的时间及内存空间也与数组A中的最大值成正比
#include<stdio.h>
#include<stdlib.h>
#define MAX 2000001
#define VMAX 10000


int main() {
	unsigned short *A, *B;
	int C[VMAX + 1];
	int n, i, j;
	scanf("%d", &n);
	A = (unsigned short *)malloc(sizeof(short)*n + 1);
	B = (unsigned short *)malloc(sizeof(short)*n + 1);


	for (i = 0; i <= VMAX; i++)
	{
		scanf("%hu", &A[i + 1]);//%hu代表以unsigned short格式输出
		C[A[i + 1]]++;
	}


	for (i = 1; i <= VMAX; i++)
		C[i] = C[i] + C[i - 1];
	for (j = 1; j <= n; j++) {
		if (i > 1) printf(" ");
		printf("%d", B[i]);
	}
	printf("\n");


	return 0;
}

STL的sort基于快速排序，抛开处理器的影响不谈，它是一种复杂度为O(nlogn)的高效排序方法。
另外，sort还对快速排序的最坏情况添加了应对机制，克服了其在最坏情况下复杂度高达O(n²)的缺点
但要注意，sort属于不稳定的排序算法

在需要稳定的排序算法时，我们可以选用以并归排序为基础的stable_sort。
只不过stable_sort的复杂度虽然也O(nlogn)，但比sort需求的内存更多，速度也稍慢。