排序（冒泡排序，插入排序， 选择排序，希尔排序，堆排序）

冒泡排序（稳定）：

void Swap(int* a, int* b)
{
	int tmp = 0;
	tmp = *a;
	*a = *b;
	*b = tmp;
}
void Bubble_Sort(int arr[], int len)
{
	bool flag = true;
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len-1-i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				Swap(&arr[j], &arr[j + 1]);
				flag = false;
			}
		}
		if (flag)
		{
			break;
		}
	}
}

选择排序（不稳定）：

void SelectSort(int* arr,int len)
{
	for (int i = 0; i < len-1; i++)
	{
		int min_pos = i;
		for (int j = i; j < len; j++)
		{
			if (arr[min_pos] > arr[j])
			{
				min_pos = j ;
			}
		}
		if (min_pos != i)
		{
			int tmp = arr[min_pos];
			arr[min_pos] = arr[i];
		    arr[i] = tmp;
		}
	}
}

插入排序（稳定）：

void Sort(int* arr, int len)
{
	for (int i = 1; i < len; i++) {
		int k = arr[i];
		int j;
		for (j = i - 1; j >= 0; j--) {
			if (k >= arr[j])
			{
				break;
			}
			else
			{
				arr[j + 1] = arr[j];
			}	
		}
		arr[j + 1] = k;
	}
}

希尔排序（不稳定）：

void ShellSort(int* arr, int len)
{

	for (int gap = len / 2; gap > 0; gap /= 2)
	{
		
		for (int i = gap; i < len; i++) {
			int k = arr[i];
			int j;
			for (j = i - gap; j >= 0; j -= gap) {
				if (k >= arr[j]) break;
				else arr[j + gap] = arr[j];
			}
			arr[j + gap] = k;
		}
	}
}

堆排序（不稳定）：

void Adjust_Head(int *arr, int start, int end)
{
	int tmp = arr[start];
	for (int i = 2 * start + 1; i <= end; i = i * 2 + 1)
	{
		if (i < end && arr[i] < arr[i + 1])//有右孩子并且左孩子小于右孩子
		{
			i++;
		}//i一定是左右孩子的最大值
		if (arr[i] > tmp)
		{
			arr[start] = arr[i];
			start = i;
		}
		else
		{
			break;
		}
	}
	arr[start] = tmp;
}

void Heap_Sort(int* arr, int len)
{
	//1.将数组想象成完全二叉树
	//2.二叉树->大顶堆（又内到外调整）
	//从最后一个非叶子节点下标(父->子i*2+1/i*2+2,子->父(i-1)/2)
	for (int i = (len - 1 - 1) / 2; i >= 0; i--)
	{
		Adjust_Head(arr, i, len - 1);
	}
	
	//3.头尾交换，将尾剔除
	//4.反复执行2，3直到大顶堆有效节点个数为1
	int tmp = 0;
	for (int i = 0; i < len - 1; i++)
	{
		//3.头尾交换，将尾剔除
		tmp = arr[0];
		arr[0] = arr[len - 1-i];
		arr[len - 1 - i] = tmp;
		//2.二叉树->大顶堆（外调整）
		Adjust_Head(arr,0,len - 1-1 - i);
	}

}