八大排序算法：《直接插入排序》《希尔排序》《选择排序》《冒泡排序》《快速排序》《归并排序》

插入排序：直接插入排序 希尔排序
选择排序：选择排序 堆排序
交换排序：冒泡排序 快速排序
归并排序

1.直接插入排序
特点：

1. 元素集合越接近有序，直接插入排序算法的时间效率越高
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)，它是一种稳定的排序算法
4. 稳定性：稳定

void Insert(int *arr, int size)
{
	for (int i = 1; i < size; i++)
	{
		int key = arr[i];
		int end = i - 1;
		while (key<arr[end] && end>=0)
		{
			arr[end+1] = arr[end];
			end--;
		}
		arr[end+1]=key;
	}
}
int main()
{
	int arr[] = { 2, 3, 4, 7, 8, 9, 0, 1, 5, 6 };
	int size = sizeof(arr) / sizeof(arr[0]);
	Insert(arr, size);
	for (int i = 0; i < size; i++)
	{
		printf("%d ", arr[i]);
		printf(" \n");
	}
	system("pause");
	return 0;
}

2. 希尔排序
   先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
按增量序列个数k，对序列进行k 趟排序；
每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
void shell_sort(int arr[], int size)
{
int gap = size;
while (gap >1)
{
gap = gap / 3 + 1;
for (int i = gap; i < size;i++)
{
int key = arr[i];
int end = i - gap;
while (key<arr[end] && end>=0)
{
arr[end + gap] = arr[end];
end-=gap;
}
arr[end + gap] = key;
}
}
}
int main()
{
int arr[] = { 2, 3, 4, 7, 8, 9, 0, 1, 5, 6 };
int size = sizeof(arr) / sizeof(arr[0]);
shell_sort(arr, size);
for (int i = 0; i < size; i++)
{
printf("%d “, arr[i]);
printf(” \n");
}
system(“pause”);
return 0;
}

3.选择排序
以序列首元素位置为基准位置，每次将该基准位置的元素和后面元素逐个进行比较，挑选最大或者最小的那个数放在基准位置上，一趟比较结束后，然后将基准位置设置为该位置的下一位置，重复上述操作，直到基准被安排在序列的最后有一个位置时，此时序列已经排列完成。

void Select_Sort(int *arr, int size)
{
	for (int i = 0; i < size; i++){
		for (int j = i + 1; j < size; j++)
		{
			if (arr[i] < arr[j])
			{
				int tmp;
				tmp = arr[i];
				arr[i] = arr[j];
				arr[j] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 1, 3, 63, 5, 78, 9, 12, 52, 8 };
	int size = sizeof(arr) / sizeof(int), i;
	Select_Sort(arr, size);
	for (i = 0; i<size; i++)
		printf("%d ", arr[i]);
	system("pause");
	return 0;
}

算法不稳定；
时间复杂度：O（n^2）
空间复杂度：O（1）没有借助辅助空间

4.冒泡排序：
时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：稳定

void Bubble_Sort(int *arr, int size)
{
	//外层循环控制冒泡的趟数，即需要冒泡多少趟
	for (int i = 0; i < size-1; i++)
	{
		//具体冒泡的方式;依次用相邻两个元素比较，将大的元素往后翻
		//j:表示数组下标--》j表述前一个元素下标
		for (int j = 0; j < size-i-1; j++)
		{
			int tmp = 0;
			if (arr[j]>arr[j + 1])
			{
				tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 1, 3, 63, 5, 78, 9, 12, 52, 8 };
	int size = sizeof(arr) / sizeof(int), i;
	Bubble_Sort(arr, size);
	for (i = 0; i<size; i++)
		printf("%d ", arr[i]);
	system("pause");
	return 0;
}

5.块速排序
是一种不稳定的算法。
时间复杂度:O(nlog2n~~O(n^2)
空间复杂度为O(log2n)

void quickSort(int arr[], int low, int high)
{
	int first = low;
	int last = high;
	int key = arr[first];
	if (low >= high)
		return;
	while (first < last)
	{
		while (first < last && arr[last] > key)
		{
			last--;
		}
		arr[first] = arr[last];

		while (first < last && arr[first] < key)
		{
			first++;
		}
		arr[last] = arr[first];
	}
	arr[first] = key;

	quickSort(arr, low, first - 1);
	quickSort(arr, first + 1, high);
}

int main()
{
	int i;
	int arr[] = { 2,3,5,4,1,0,7,8,9,6 }; 
	int size = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < 10; i++)
		printf("%d ", arr[i]);
	printf("\n");

	quickSort(arr, 0, size-1);

	for (i = 0; i < 10; i++)
		printf("%d ", arr[i]);
	printf("\n");
	system("pause");
	return 0;
}

6.归并排序
归并排序是一种稳定的排序。
时间复杂度：O(nlgn)
空间复杂度：O（n）

void MergeData(int* arr, int left, int mid, int  right, int* tmp)
{
	int begin1 = left;
	int end1 = mid;
	int begin2 = mid;
	int end2 = right;
	int count = left;

	while ((begin1 < end1) && (begin2 < end2))
	{
		if (arr[begin1] <= arr[begin2])
		{
			tmp[count++] = arr[begin1++];
		}
		else{
			tmp[count++] = arr[begin2++];
		}
	}

	while (begin1 < end1) {
		tmp[count++] = arr[begin1++];
	}

	while (begin2 < end2) {
		tmp[count++] = arr[begin2++];
	}
}

void R_MergeSort(int* arr, int size)
{
	int* tmp = (int*)malloc(sizeof(arr[0])*size);
	if (NULL == tmp)
		return;
	int gap = 1;
	int left, mid, right;
	int i;
	while (gap < size)
	{
		for (i = 0; i < size; i += 2 * gap)
		{
			left = i;
			mid = left + gap;
			if (mid > size){
				mid = size;
			}
			right = mid + gap;
			if (right > size){
				right = size;
			}
			MergeData(arr, left, mid, right, tmp);
		}
		memcpy(arr, tmp, sizeof(arr[0]) * size);
		gap *= 2;
	}

	free(tmp);
}


void printf_arr(int arr[], int size)
{
	int i = 0;
	for (; i < size; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	//int arr[10] = {2,7,1,4,3,9,6,0,5,8};
	int arr[10] = { 4, 4, 6, 7, 3, 0, 9, 3, 5, 2 };
	int size = sizeof(arr) / sizeof(arr[0]);

	R_MergeSort(arr, size);
	printf_arr(arr, size);

	system("pause");
	return 0;
}