插入排序、选择排序

插入排序

每一步将一个待排序的元素，按其排序码的大小，插入到前面已经排好序的一组元素的合适位置上去，直到元素全部插完为止

直接插入排序

当插入第i（i>=1）个元素时，前面的array[0]、array[1]......array[i-1]已经排好序，此时用array[i]的排序码与array[i-1]，array[i-2],.....的排序码顺序进行比较，找到插入位置将array[i]插入，原来位置上的元素后移。

void Swap(int array[], int i, int j) {
	int t = array[i];
	array[i] = array[j];
	array[j] = t;
}
void InsertSort(int array[], int size) {
	for (int i = 0; i < size; i++) {
		int key = array[i];
		int j;
		for (j = i-1; j >= 0; j--) {
			if (array[j] <= key) {
				break;
			}
			array[j + 1] = array[j];
		}
		array[j + 1] = key;
	}
}

元素集合越接近有序，直接插入排序算法的时间效率越高

最好情况：时间复杂度O(n)

最坏情况：时间复杂度O(n^2)

空间复杂度：O(1),直接插入排序是一种稳定的排序算法

希尔排序

将待排序的元素分组，将分好的组按组进行插入排序，是对直接排序的优化。

void InsertSortWithGap(int array[], int size,int gap) {
	for (int i = 0; i < size; i++) {
		int key = array[i];
		int j;
		for (j = i - gap; j >= 0; j -= gap) {
			if (array[j] <= key) {
				break;
			}
			array[j + gap] = array[j];
		}
		array[j + gap] = key;
	}
}
void ShellSort(int array[], int size) {
	int gap = size;
	while (1) {
		gap = gap / 3 + 1;
		InsertSortWithGap(array, size, gap);
		if (gap == 1) {
			return;
		}
	}
}

希尔排序的组间跨度越大，移动的越快
最好情况：O(n)
平均情况：O(n^1.3-1.4)
最坏情况：O(n^2) ，希尔排序是不稳定的排序算法

选择排序

每一趟（第i趟，i=0,1,....，n-2）在后面n-i个待排序的数据元素的集合中选出关键码最小的数据元素，作为有序元素序列的第i个元素。待到第n-2趟走完，待排序元素的集合中只剩下1个元素，排序结束

直接选择排序

• 在元素集合array[i]-array[n-1]中选择关键码最大（小）的数据元素
• 若它不是这组元素中的最后一个（第一个）元素，则将它与这组元素中的最后一个（第一个）元素交换。
• 在剩余的array[i]-array[n-2]（array[i+1]-array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

void SelectSort(int array[], int size) {
	for (int i = 0; i < size; i++) {
		int record = 0;
		for (int j = 0; j < size - 1 - i; j++) {
			if (array[j] > array[record]) {
				record = j;//在无序的部分找最大数的下标
			}
		}
		Swap(array, record, size - 1 - i);
	}
}

时间复杂度是O(n^2)，直接选择排序是一种不稳定的排序算法。

堆排序

• 创建堆：升序->大堆，降序->小堆

从最后一个非叶子结点开始调整，一直到根节点为止，将每个结点及其子树调整到满足大(小)堆的性质

• 把堆顶array[0]元素和当前最大（小）堆的最后一个元素交换
• 堆元素个数减1
• 由于交换元素后根节点不能满足最大（小）堆定义，向下调整根节点

把一棵完全二叉树调整为堆，每次将堆顶元素交换后进行调整的时间复杂度均为O(logn)

堆排序的时间复杂度为O（n*logn）

堆排序是一种不稳定的排序算法