排序小结（一）

冒泡排序法（时间复杂度：O(N²)）

//使用flag的冒泡排序法
int bubbleSort(int A[], int N)
{
	int sw = 0;//记录交换的次数
	bool flag = 1;//假如某一次循环过程中没有交换相邻元素，则不必再排下去了
	for (int i = 0; flag; i++)//表示未排序部分的开头元素
	{
		flag = 0;
		for (int j = N - 1; j >= i + 1; j--)//用于对未排序部分中的相邻元素两两比较
		{
			if (A[j] < A[j - 1])
			{
				swap(A[j], A[j - 1]);
				flag = 1;
				sw++;
			}
		}
	}
	return sw;
}

插入排序法（能快速处理相对有序的数据，降序情况下时间复杂度O(N²)，升序情况下则为O(N)）

//插入排序（0起点数组）
void insertionSort(int A[], int N)
{
	int j, i, v;
	//i表示未排序部分的开头元素
	//v临时保存A[i]的值
	//j用于在已排序部分寻找v的插入位置
	for (i = 1; i < N; i++)
	{
		v = A[i];
		j = i - 1;
		while (j >= 0 && A[j] > v)
		{
			A[j + 1] = A[j];
			j--;
		}
		A[j + 1] = v;
	}
}

选择排序法（不稳定排序，可能会交换相同值的位置，时间复杂度O(N²)）

//选择排序法（0起点）
int selectionSort(int A[], int N)
{
	int i, j, t, sw = 0, minj;
	for (i = 0; i < N - 1; i++)
	{
		minj = i;
		for (j = i; j < N; j++)
		{
			if (A[j] < A[minj])
				minj = j;
		}
		t = A[i]; A[i] = A[minj]; A[minj] = t;
		if (i != minj) sw++;
	}
	return sw;
}

希尔排序（重复进行一间隔为g的元素为对象的插入排序，当时间复杂度基本维持在）

vector<int> G;

//指定了间隔g的插入排序
void insertionSort(int A[], int n, int g)
{
	for (int i = g; i < n; i++)
	{
		int v = A[i];
		int j = i - g;
		while (j >= 0 && A[j] > v)
		{
			A[j + g] = A[j];
			j -= g;
		}
		A[j + g] = v;
	}
}

void shelllSort(int A[], int n)
{
	//生成数列G={1,4,13,40,121,364,1093...}
	for (int h = 1; ;)
	{
		if (h > n)	break;
		G.push_back(h);
		h = 3 * h + 1;
	}
	for (int i = G.size() - 1; i >= 0; i--)
	{
		insertionSort(A, n, G[i]);
	}
}