经典排序算法（C/C++）

非线性时间比较排序

直接插入排序

void insert_sort(int* A, int n)
{
	if (A == nullptr) return;
	if (n <= 1) return;
	for (int i = 1; i != n; ++i)
	{
		for (int j = i; j > 0; --j)
		{
			if (A[j] < A[j - 1])
			{
				int tmp = A[j];
				A[j] = A[j - 1];
				A[j - 1] = tmp;
			}
		}
	}
}

冒泡排序

void bubble_sort(int* A, int n)
{
	if (A == nullptr) return;
	if (n <= 1) return;
	for (int i = 0; i != n - 1; ++i)
	{
		for (int j = 0; j != n - 1 - i; ++j)
		{
			if (A[j] > A[j + 1])
			{
				int tmp = A[j];
				A[j] = A[j + 1];
				A[j + 1] = tmp;
			}
		}
	}
}

选择排序

void select_sort(int* A, int n)
{
	if (A == nullptr) return;
	if (n <= 1) return;
	int minindex;
	for (int i = 0; i != n - 1; ++i)
	{
		minindex = i;
		for (int j = i + 1; j != n; ++j)
		{
			if (A[j] < A[minindex])
			{
				minindex = j;
			}
		}
		int tmp = A[i];
		A[i] = A[minindex];
		A[minindex] = tmp;
	}
}

希尔排序

void shell_sort(int* A, int n)
{
	if (A == nullptr) return;
	if (n <= 1) return;
	for (int div = n / 2; div >= 1; div /= 2)
		for (int k = 0; k < div; ++k)
			for (int i = div + k; i < n; i += div)
				for (int j = i; j > k; j -= div)
					if (A[j] < A[j - div])
					{
						int tmp = A[j];
						A[j] = A[j - div];
						A[j - div] = tmp;
					}
}

快速排序

void quick_sort(int* A, int left, int right)
{
	if (left >= right) return;
	int i, j, base;
	i = left, j = right;
	base = A[left];
	while (i < j)
	{
		while (A[j] >= base && i < j)
			--j;
		while (A[i] <= base && i < j)
			++i;
		if (i < j)
		{
			int tmp = A[i];
			A[i] = A[j];
			A[j] = tmp;
		}
	}
	A[left] = A[i];
	A[i] = base;
	quick_sort(A,left,i - 1);
	quick_sort(A,i + 1,right);
}

归并排序

void merge(int* A, int p, int q, int r)
{
	int n1 = q - p + 1;
	int n2 = r - q;
	int* B = new int[n1];
	int* C = new int[n2];
	for (int i = p; i <= q; ++i)
	{
		B[i - p] = A[i];
	}
	for (int i = q + 1; i <= r; ++i)
	{
		C[i - q - 1] = A[i];
	}
	B[n1] = INT_MAX;
	C[n2] = INT_MAX;
	int i = 0, j = 0;
	for (int k = p; k <= r; ++k)
	{
		if (B[i] <= C[j])
		{
			A[k] = B[i];
			++i;
		}
		else {
			A[k] = C[j];
			++j;
		}
	}
}


void merge_sort(int* A, int p, int r)
{
	if (p < r)
	{
		int q = (p + r) / 2;
		merge_sort(A,p,q);
		merge_sort(A,q+1,r);
		merge(A,p,q,r);
	}
}

堆排序

void adjust_heap(int* A, int node, int n)
{
	int left = node * 2 + 1;
	int right = node * 2 + 2;
	int max = node;
	if (left < n && A[left] > A[max])
		max = left;
	if (right < n && A[right] > A[max])
		max = right;
	if (max != node)
	{
		int tmp = A[max];
		A[max] = A[node];
		A[node] = tmp;
		adjust_heap(A,max,n);
	}
}	
void make_heap(int* A, int n)
{
	for (int i = n / 2; i >= 0; --i)
	{
		adjust_heap(A,i,n);
	}
}
void heap_sort(int* A, int n)
{
	make_heap(A,n);
	for (int i = n - 1; i >= 0; --i)
	{
		int tmp = A[i];
		A[i] = A[0];
		A[0] = tmp;
		adjust_heap(A,0,i);
	}

}

线性时间的非比较排序

计数排序

void count_sort(vector<int>& A)
{
	if (A.size() <= 1) return;
	int max = *max_element(A.begin(), A.end());
	int min = *min_element(A.begin(),A.end());
	int n = max - min + 1;
	vector<int> B(n,0);
	
	
	for (int i = 0; i != A.size(); ++i)
	{
		++B[A[i] - min];
	}
	for (int i = 0; i != n; ++i)
	{
		for (int j = 0; j != B[i]; ++j)
			cout << i + min << " ";
	}
	cout << endl;
}