排序算法

选择排序

选择排序算法是通过n-i次关键字间的比较，n-i+1个记录中选出关键字最小的记录，并和第i个（1<=i<=n）个记录。

#include<iostream>
using namespace std;
void selectSort(int arr[],int size)
{
	int min = 0;
	for (int i = 0; i < size-1; i++)
	{
		min = i;
		for (int j = i + 1; j < size; j++)
		{
			if (arr[j] < arr[min])
			{
				min = j;
			}
		}
		if (min != i)
		{
			int temp = arr[min];
			arr[min] = arr[i];
			arr[i] = temp;
		}
	}
}
int main()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0};
	selectSort(arr, 10);
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i];
	}
	return 0;
}

直接插入排序

直接插入排序的基本操作是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增加1的有序表。

#include<iostream>
using namespace std;
void straightInsertSort(int arr[],int size)
{
	int j = 0, temp = 0;
	for (int i = 1; i < size; i++)
	{
		if (arr[i] < arr[i - 1])
		{
			temp = arr[i];
			for (j = i - 1; arr[j] > temp; j--)
			{
				arr[j + 1] = arr[j];
			}
			arr[j + 1] = temp;
		}
	}
}
int main()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0};
	straightInsertSort(arr, 10);
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i];
	}
	return 0;
}

希尔排序

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。 

#include<iostream>
using namespace std;
void shellSort(int arr[],int size)
{
	int j = 0, temp = 0;
	int interval = size;
	do
	{
		interval = interval / 2;
		for (int i = interval; i < size; i++)
		{
			if (arr[i] < arr[i - interval])
			{
				temp = arr[i];
				for (j = i - interval; arr[j] > temp; j -= interval)
				{
					arr[j + interval] = arr[j];
				}
				arr[j + interval] = temp;
			}
		}
	} while (interval > 1);
}
int main()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0};
	shellSort(arr, 10);
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i];
	}
	return 0;
}

堆排序

堆实际上是一棵完全二叉树，堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种改进的选择排序，它的时间复杂度均为O(nlogn)。

分为两种方法：

1. 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
2. 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；

#include<iostream>
using namespace std;
void swoap(int arr[], int index, int size)
{
	int temp = arr[index];
	arr[index] = arr[size];
	arr[size] = temp;
}
void heapAdjust(int arr[], int startindex, int size)
{
	int temp = arr[startindex];
	for (int i = startindex * 2; i <= size; i *= 2)
	{
		if (i < size && arr[i] < arr[i + 1])
		{
			i++;
		}
		if (temp >= arr[i])
		{
			break;
		}
		arr[startindex] = arr[i];
		startindex = i;
	}
	arr[startindex] = temp;
}
void heapSort(int arr[],int size)
{
	
	for (int i = size/2; i > 0; i--)
	{
		heapAdjust(arr,i,size);
	}
	for (int j = size; j > 1; j--)
	{
		swoap(arr, 1, j);
		heapAdjust(arr, 1, j-1);
	}
}
int main()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0};
	heapSort(arr, 9);
	for (int i = 1; i < 10; i++)
	{
		cout << arr[i];
	}
	return 0;
}

归并排序

将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

递归实现

#include<iostream>
using namespace std;
#define LEN 10
void mergeOperate(int *list1, int list1_size, int *list2, int list2_size)
{
	int i, j, k, m;
	int temp[LEN];

	i = j = k = 0;

	while (i < list1_size && j < list2_size)
	{
		if (list1[i] < list2[j])
		{
			temp[k++] = list1[i++];
		}
		else
		{
			temp[k++] = list2[j++];
		}
	}

	while (i < list1_size)
	{
		temp[k++] = list1[i++];
	}

	while (j < list2_size)
	{
		temp[k++] = list2[j++];
	}

	for (m = 0; m < (list1_size + list2_size); m++)
	{
		list1[m] = temp[m];
	}
}
void MergeSort(int k[], int n)
{
	if (n > 1)
	{
		int *list1 = k;
		int list1_size = n / 2;
		int *list2 = k + n / 2;
		int list2_size = n - list1_size;

		MergeSort(list1, list1_size);
		MergeSort(list2, list2_size);

		mergeOperate(list1, list1_size, list2, list2_size);
	}
}

int main()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0};
	MergeSort(arr, 10);
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i];
	}
	return 0;
}

迭代实现

#include<iostream>
using namespace std;

void MergeSort(int k[], int size)
{
	int i, next, left_min, left_max, right_min, right_max;
	int *temp = new int[size * sizeof(int)];

	for (i = 1; i < size; i *= 2)
	{
		for (left_min = 0; left_min <size - i; left_min = right_max)
		{
			right_min = left_max = left_min + i;
			right_max = left_max + i;

			if (right_max > size)
			{
				right_max = size;
			}

			next = 0;

			while (left_min < left_max && right_min < right_max)
			{
				if (k[left_min] < k[right_min])
				{
					temp[next++] = k[left_min++];
				}
				else
				{
					temp[next++] = k[right_min++];
				}
			}

			while (left_min < left_max)
			{
				k[--right_min] = k[--left_max];
			}

			while (next > 0)
			{
				k[--right_min] = temp[--next];
			}
		}
	}
}

int main()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
	MergeSort(arr, 10);
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i];
	}
	return 0;
}

冒泡排序

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

#include<iostream>
using namespace std;
#define LEN 10

void BubbleSort(int arr[], int length)
{
	for (int i = 1; i < length; i++) //趟数
	{
		for (int j = 0; j < length - i; j++) //每一趟比较的次数
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

int main()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0};
	BubbleSort(arr, 10);
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i];
	}
	return 0;
}

快速排序

快速排序是对冒泡排序的一种改进；通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

#include<iostream>
using namespace std;
#define LEN 10

//快速排序
void QuickSort(int arr[], int start, int end)//0  9
{
	int key = arr[start]; //关键值 
	int i = start;
	int j = end;

	if (i >= j) //递归的出口
	{
		return;
	}

	while (i < j)
	{
		//先从尾部开始比较
		while (i < j && key < arr[j])  //i < j用来防止越界
		{
			j--;
		}
		arr[i] = arr[j]; //遇到第一个比key值小的，交换

						 //从头部开始比较
		while (i < j && key > arr[i])
		{
			i++;
		}
		arr[j] = arr[i];//遇到第一个比key值大的，交换
	}
	arr[j] = key; //确定key值的位置

	QuickSort(arr, start, j - 1); //递归遍历左边
	QuickSort(arr, j + 1, end); //递归遍历右边
}

int main()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0};
	QuickSort(arr, 0, 9);
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i];
	}
	return 0;
}

排序算法的时间复杂度和空间复杂度