C++ 插入排序，快排，归并排序，堆排

废话不多说，直接用就行

以从小到大排序为例

插入排序

void insertSort(int* array, int len)
//插入排序 input:原始数组 数组长度
//时间复杂度：O(n^2) 空间复杂度:O(1) 优点：处理流数据 稳定
{
	int j;
	int temp;
	for (int i = 1; i < len; i++)
	{
		j = i;
		temp = array[i];
		while (array[j - 1] > temp)
		{
			array[j] = array[j - 1];
			array[j - 1] = temp;
			j--;
		}
	}
}

快速排序

void quickSort(int* array, int start, int end)
//快速排序 input:原始数组 起始下标 终止下标
//时间复杂度 O(nlogn) 最差 O(n^2) 空间复杂度 O(log(n)) O(n) 不稳定
{
	if (start < end)
	{
		//小于等于标兵的放在左侧，大于标兵的放在右侧
		int tag = array[start];
		int i = start;
		int j = end;
		//此处应该注意i,j的关系是等价的
		while (i < j)
		{
			while (array[j] > tag && i < j)
			{
				j--;
			}
			//值得注意的是初次循环时是array[start]的值
			array[i] = array[j];
			while (array[i] <= tag && i < j)
			{
				i++;
			}
			array[j] = array[i];
		}
		array[i] = tag;
		quickSort(array, start, i - 1);
		quickSort(array, i + 1, end);
	}
}

归并排序

void mergeSort(int* array, int start, int end)
//归并排序 input:原始数组 起始下标 终止下标
//分成两步，分组+合并 (递归实现)
// 时间复杂度 O(nlogn) 空间复杂度 O(n)  稳定
{
	if (start < end)
	{
		int index = (start + end) / 2;
		mergeSort(array, start, index);
		mergeSort(array, index + 1, end);
		int temp;
		int i = start;
		int j = index + 1;
		int* tempArray = new int[end - start + 1];
		memset(tempArray, 0, end - start + 1);
		int tag = 0;
		while (i <= index && j <= end)
		{
			if (array[i] < array[j])
			{
				tempArray[tag++] = array[i];
				i++;
			}
			else
			{
				tempArray[tag++] = array[j];
				j++;
			}
		}
		while (i <= index)
		{
			tempArray[tag++] = array[i];
			i++;
		}
		while (j <= end)
		{
			tempArray[tag++] = array[j];
			j++;
		}
		for (int k = 0; k < end - start + 1; k++)
			array[k + start] = tempArray[k];
		delete[] tempArray;
	}
}

堆排序

#define swapElement(array,i,j){int temp = array[i];array[i] = array[j];array[j] = temp;}

void heapAdjust(int* array, int start, int end)
//堆调整 input:原始数组 开始下标 结束下标 构建大顶堆
//时间复杂度 O(nlogn) 空间复杂度O(1)(就地)
{
	int i = start;
	int temp = 0;
	int tag = 0;
	//值得注意的是2*i+2有可能造成越界，所以先一轮循环，在单独判断越界情况
	while ((array[i] < array[2 * i + 1] || array[i] < array[2 * i + 2]) && (2 * i + 2) <= end)
	{
		tag = array[2 * i + 1] > array[2 * i + 2] ? 2 * i + 1 : 2 * i + 2;
		swapElement(array, i, tag);
		i = tag;
	}
	//当存在越界情况时
	if (2 * i + 2 <= end && (array[i] < array[2 * i + 1] || array[i] < array[2 * i + 2]))
	{
		tag = array[2 * i + 1] > array[2 * i + 2] ? 2 * i + 1 : 2 * i + 2;
		swapElement(array, i, tag);
	}
	else if (2 * i + 1 <= end && array[i] < array[2 * i + 1])
	{
		tag = 2 * i + 1;
		swapElement(array, i, tag);
	}
}

void heapSort(int* array, int length)
//堆排序 input:原始数组 数组长度 
{
	int index = length / 2 - 1; //寻找第n/2个数，该数具有子节点
	int temp = 0;
	//如果只使用数组进行操作，则下标为x的结点，其子节点的下标为2x+1和2x+2
	for (int i = index; i >= 0; i--)
	{
		heapAdjust(array, i, length - 1);
	} 
	//从length/2个数开始，构建大顶堆
	//cout << "堆的初始化完成" << endl;
	for (int i = 0; i < length - 1; i++)
		//不断输出大顶堆根结点，并调整堆结构使之成为大顶堆
	{
		swapElement(array, 0, length - 1 - i);  //将最大值放在堆的末尾
		heapAdjust(array, 0, length - 2 - i);   
	}
}