模拟实现选择排序

直接选择排序

直接选择排序： 每一次从待排序元素中选择一个最大或最小的一个元素，存放到序列的起始位置，知道所有元素排完

流程：

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

void Swap(int *left, int * right)
{
	int temp = *left;
	*left = *right;
	*right = temp;
}
void SelectSort(int *array, int size)
{
	for (int j = 0; j < size - 1; j++)
	{
		int maxpos = j;
		for (int i = j + 1; i < size; i++)
		{
			if (array[i]<array[maxpos])
				maxpos = i;
		}
		Swap(&array[j], &array[maxpos]);
	}
}

时间复杂度 O(N^2)
空间复杂度O(1)
稳定性：不稳定
适用场景 效率不是很高，不常使用

但是一次只挑选一个最大或者是最小的效率也达不到最好，我们可以一次性找两个一共最大一共最小，然后进行交换；这样效率会更好一点

void Swap(int *left, int * right)
{
	int temp = *left;
	*left = *right;
	*right = temp;
}
void SelectSort(int *array, int size)
{
	int begin = 0;
	int end = size - 1;
	while (begin<=end)
	{
		int Maxpos = begin;//标记最大数
		int Minpos = begin;//标记最小数
		
		for (int i = begin; i <= end; i++)
		{
			if (array[i] > array[Maxpos])
				Maxpos = i;
			if (array[i] < array[Minpos])
				Minpos = i;
		}
		
		Swap(&array[begin], &array[Minpos]);
		if (Maxpos == begin)
		{
			Maxpos = Minpos;
		}
		Swap(&array[end], &array[Maxpos]);

		begin++;
		end--;
	}
}

堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆

流程：

1. 先根据排序的要求进行建堆（向下调整算法）
2. 然后经堆顶元素和堆尾元素进行交换，数组长度减小一位，然后调整堆，重复上述操作
3. 知道对元素为1是结束

void AdjustDown(int* arr,size_t n,int parent)//建大堆
{
	//排升序，建大堆
	//排降序，建小堆
	//leftchild = parent * 2 + 1;
	//rightchild = parent * 2 + 2;
	int child = parent * 2 +1;
	while(child < n)
	{
		if(child+1<n&&arr[child+1] > arr[child])//找到左右孩子中较大的哪一个
		{
			++child;
		}
		if(arr[child]>arr[parent])
		{
			Swap(&arr[child],&arr[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
			break;
	}
}


void HeapSort(int *array, int size)
{
	int end = size - 1;
	//建堆
	for (int i = (size - 2) / 2; i >= 0; i--)
	{
		AdjustDown(array, size, i);
	}

	//排序
	while (end > 0)
	{
		Swap(&array[0], &array[end]);
		AdjustDown(array, end, 0);
		--end;
	}
}

时间复杂度 O(N + logN)
空间复杂度 O(1)
稳定性：不稳定
适用场景 用堆选数，效率很高，常用