排序基础

插入排序

直接插入排序

// 对数组A[1...n]进行直接插入排序 (A[0]不存储数据)
void InsertSort(int A[], int n)
{
	int i, j;
	for(i = 2; i <= n; i++)
	{
		A[0] = A[i];
		for(j = i-1; A[j] > A[0]; j--)
			A[j+1] = A[j];
		A[j+1] = A[0];
	}
}

折半插入排序

// 对数组A[1...n]进行折半插入排序 (A[0]不存储元素)
void BinaryInsertSort(int A[], int n)
{
	int i, j, left, right, mid;
	for(i = 2; i <= n; i++)
	{
		A[0] = A[i]; left = 1; right = i-1;
		while(left <= right)
		{
			mid = (left + right)/2;
			if(A[mid] > A[0])
				right = mid-1;
			else if(A[mid] < A[0])
				left = mid+1;
		}
		for(j = i-1; j >= left; j--)
			A[j+1] = A[j];
		A[left] = A[0];
	}
}

Shell排序

// 对数组A[1...n]进行Shell排序 (A[0]不存储元素)
void ShellSort(int A[], int n)
{
	int i, j, d;
	for(d = n/2; d >= 1; d /= 2)
	{
		for(i = d+1; i <= n; i+=d)
		{
			A[0] = A[i];
			for(j = i-d; j > 0 && A[j] > A[0]; j -= d)
				A[j+d] = A[j];
			A[j+d] = A[0];
		}
	}	
}

交换排序

冒泡排序

void BubbleSort(int A[], int n)
{
	// 对A[0...n-1]进行冒泡排序
	bool flag; // 是否发生交换标志
	for(int i = 0; i < n-1; i++)
	{
		flag = false;
		for(int j = n-1; j > i; j--)
		{
			if(A[j] < A[j-1])
			{
				swap(A[j], A[j-1]);
				flag = true;
			}
		}
		if(!flag)
			break; // 本趟排序没有交换元素,表明已经排序完毕
	}
}

快速排序

int Partition(int A[], int left, int right)
{
	int pivot = A[left]; // 选取第一个元素作为pivot
	while(left < right)
	{
		while(left < right && A[right] >= pivot)
			right--;
		A[left] = A[right];
		while(left < right && A[left] <= pivot)
			left++;
		A[right] = A[left];
	}
	A[left] = pivot;
	return left;
}

void QuickSort(int A[], int left, int right)
{
	if(left >= right)
		return;
	int pivotpos = Partition(A, left, right);
	QuickSort(A, left, pivotpos-1);
	QuickSort(A, pivotpos+1, right);
}

选择排序

简单选择排序

// 对数组A[0...n-1]进行简单选择排序
void SelectSort(int A[], int n)
{
	int minIndex;
	for(int i = 0; i < n-1; i++)
	{
		minIndex = i;
		for(int j = i+i; j < n; j++)
			if(A[j] < A[minIndex])
				minIndex = j;
		swap(A[i], A[minIndex]);
	}
}

堆排序

// 对A[k]进行ShiftDown操作
void ShiftDown(int A[], int n, int k)
{
	A[0] = A[k];
	for(int i = 2*k; i <= n; i *= 2)
	{
		if(i < n && A[i] < A[i+1])
			i++;
		if(A[i] > A[0])
		{
			A[k] = A[i];
			k = i;
		}else
			break;
		A[k] = A[0];
	}
}

// 对A[k]进行ShiftUp操作
void ShiftUp(int A[], int n, int k)
{
	A[0] = A[k];
	while(k > 1 && A[0] > A[k/2])
	{
		A[k] = A[k/2];
		k /= 2;
	}
	A[k] = A[0];
}

// 对数组A[1...n]建立大根堆
void BuildMaxHeap(int A[], int n)
{
	// 从最后一个分支节点开始,依次进行ShiftDown操作
	for(int k = n/2; k > 0; k--)
	{
		ShiftDown(A, n, k);
	}
}

// 对A[1...n]进行堆排序(升序排序,A[0]不存储元素)
void HeapSort(int A[], int n)
{
	BuildMaxHeap(A, n);
	for(int i = n; i > 1; i--)
	{
		swap(A[i], A[1]);
		ShiftDown(A, i-1, 1);
	}
}

归并排序

void Merge(int A[], int left, int mid, int right)
{
	int *temp = new int[right-left+1]; // 申请辅助数组
	int i, j, k;
	for(i = left; i <= right; i++)
		temp[i-left] = A[i]; // 将数组A中元素复制到辅助数组中
	for(i = left, j = mid+1, k = left; k <= right; k++)
	{
		if(i > mid)
		{
			A[k] = temp[j-left];
			j++;
		}else if(j > right){
			A[k] = temp[i-left];
			i++;
		}else if(temp[i-left] <= temp[j-left]){
			A[k] = temp[i-left];
			i++;
		}else{
			A[k] = temp[j-left];
			j++;
		}
	}
}

void MergeSort(int A[], int left, int right)
{
	if(left >= right)
		return;
	int mid = (left + right)/2;
	MergeSort(A, left, mid);
	MergeSort(A, mid+1, right);
	if(A[mid] > A[mid+1])
		Merge(A, left, mid, right);
}