八大排序算法

• 冒泡排序

时间复杂度O(n^2)，空间复杂度O(1)，稳定

void BubbleSort(int* arr, int len)
{
	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]);
			}
		}
	}
}

• 选择排序

选择排序就是找到最小的元素并且与0下标的元素进行交换，时间复杂度O(n^2)，空间复杂度O(1)，不稳定

void SelectSort(int* arr, int len)
{
	for (int i = 0; i < len; i++)
	{
		int min_index = i;
		for (int j = i; j < len; j++)
		{
			if (arr[min_index] > arr[j])
			{
				min_index = j;
			}
		}
		swap(arr[min_index], arr[i]);
	}
}

• 直接插入排序

直接插入排序的思想就是： 任意时刻数据都将被分成两部分，其中左边的部分总是排好序的，右边的部分有可能是有序的也有可能是乱序的。
时间复杂度O(n^2)，空间复杂度O(1)，稳定

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

• 希尔排序

希尔排序其实是直接插入排序的一个优化，将一组数据分为不同的组，然后对每组再进行直接插入排序。
时间复杂度O(n^1.3)~O(ⁿ1.5)，空间复杂度O(1)，不稳定

void Shell(int* arr, int len, int d)
{
	for (int i = d; i < len; i += d)
	{
		int tmp = arr[i], j;
		for (j = i - d; j >= 0; j -= d)
		{
			if (arr[j] < tmp)
			{
				break;
			}
			arr[j + d] = arr[j];
		}
		arr[j + d] = tmp;
	}
}
void ShellSort(int* arr, int len)
{
	int d[] = { 5,3,1 };//增量序列的值必须都是互质的，且最后一个必须为1
	int n = sizeof(d) / sizeof(d[0]);
	for (int i = 0; i < n; i++)
	{
		Shell(arr, len, d[i]);
	}
}

• 快速排序
  https://blog.youkuaiyun.com/csdn_edition/article/details/110732594
• 堆排序

先将一组数据按照完全二叉树的顺序存储方式存储：

• 如果根节点的下标为i，则左孩子结点的下标为2i+1，有孩子结点的下标为2i+2。
• 如果一个孩子的下标为i，则其父节点的下标为(i-1)/2

时间复杂度O(nlogn)，空间复杂度O(logn)，是一个不稳定排序

void OneAdjust(int* arr, int len, int root)
{
	int i = root;
	int j = 2 * i + 1;
	int tmp = arr[i];
	while (j < len)
	{
		if (j + 1 < len && arr[j] < arr[j + 1])
		{
			j = j + 1;//j为较大孩子的下标
		}
		if (tmp > arr[j])
		{
			break;
		}
		arr[i] = arr[j];
		i = j;
		j = 2 * i + 1;
	}
	arr[i] = tmp;
}
void CreateHeap(int* arr, int len)
{
	//root为最后一颗子树的根节点
	int root = (len - 2) / 2;
	for (root; root >= 0; root--)
	{
		OneAdjust(arr, len, root);
	}
}
void HeapSort(int* arr, int len)
{
	CreateHeap(arr, len);
	for (int i = 0; i < len - 1; i++)
	{
		swap(arr[0], arr[len - 1 - i]);
		OneAdjust(arr, len - 1 - i, 0);
	}
}

• 二路归并排序

时间复杂度O(nlogn)，空间复杂度O(n)，是稳定排序

https://blog.youkuaiyun.com/u010647471/article/details/49563701

• 基数排序

https://blog.youkuaiyun.com/weixin_39408343/article/details/107115403