东子说算法

激励我写博文有很大的原因是，在校电面的时候，被问到了很多基础算法问题。当时瞬间懵哔了。痛定思痛。决定好好复习下常用的基础算法。

一).常见的排序算法。

1).简单选择排序。

基本思想：每一趟在后面n-1个待排的数据中选出一个最小（大）的数据作为有序序列的第i个元素。之后依次循环遍历。

简单选择排序是稳定排序，平均时间复杂度为O(n²)，最坏时间复杂度为O(n²)，空间复杂度O(1)；

static void swap(int a[], int i, int j)
{
	int tmp = 0;
	tmp = a[i];
	a[i] = a[j];
	a[j] = tmp;
}

void SelectSort(int a[], int n)
{
	if (!a && n < 0) return;
	int i = 0, j = 0;
	int k = -1;
	for (; i < n; i++)
	{
		k = i;
		for (j = i + 1; j < n; j++)
		{
			if (a[j] < a[k])
				k = j;
		}
		swap(a, i, k);
	}
}

2).冒泡排序算法

　　基本思想：将序列中第一个元素与第二个元素进行比较，若为逆序（升序）a[2] > a[1](a[2] < a[1])则交换，然后再比较第二个元素与第三个元素，依次进行，每趟选出一个最大（小）值。冒泡排序已选择排序的区别：选择排序是每趟与最小（大）值交换，冒泡排序是每趟移动相邻的位置。

　　小技巧： 可以在冒泡排序中定义一个变量，用于表示冒泡排序受否排列好了。如果要有一个已经基本有序的序列，则可以减少循环次数。

　　冒泡排序属于交换排序，是稳定排序。平均时间复杂度为O(n²)，最坏时间复杂度为O(n²)，空间复杂度O(1)；

void BubbleSort(int a[], int len)
{
	if (!a && len < 0) return;
	int i = 0, j = 0;
	int exchange = 1;
	for (; (i < len - 1) && exchange; i++)
	{
		exchange = 0;
		for (j = 0; j < len - 1 - i; j++)
		{
			if (a[j + 1] < a[j])
			{
				swap(a, j, j + 1);
				exchange = 1;
			}
		}
	}
}

3).快速排序

　　基本思想：通过一趟排序将序列分割成独立的两部分，其中一部分的所有数据要比另一部分的所有数据小。基准数据排在两个部分的中间。依次快排两个模块。现在这个算法分为两个过程，一个是根据基准数据划分模块，一个是递归的划分模块及排列数据。

　　快速排序也属于交换排序，不稳定排序。平均时间复杂度为O(nlog2n), 最坏时间复杂度为O(n²),空间复杂度为O(nlog2n)；

int partion(int a[], int low, int high)
{
	if (!a) return -1;
	int privot = a[low];
	while (low < high)
	{
		while ((low < high) && (a[high] > privot))
			high--;
		swap(a, low, high);
		while ((low < high) && (a[low] <= privot))
			low++;
		swap(a, low, high);
	}
	return low;
}

void Qsort(int a[], int low, int high)
{
	int privot = 0;
	if (low < high)
	{
		privot = partion(a, low, high);
		Qsort(a, low, privot - 1);
		Qsort(a, privot + 1, high);
	}
}
void Quicksort(int a[], int len)
{
	Qsort(a, 0, len - 1);
}

4).归并排序

　　基本思想：与快速排序相反，选择排序是先排序再分组，归并排序是先分组再进行排序。归并过程为：比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素a[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。

　　归并排序是稳定排序。平均时间复杂度为O(nlog2n), 最坏时间复杂度为O(nlog2n),空间复杂度为O(n)；

//对划分的序列进行排序，并放入新的序列中
void Merge(int a[], int des[], int low, int mid, int high)
{
	int i = low;
	int j = mid + 1;
	int k = low;
	while ((i < mid) && (j < high))
	{
		if (a[i] < a[j])
			des[k++] = a[i++];
		else
			des[k++] = a[j++];
	}
	while (i <= mid)               一个有序表取完，将有序表中剩余的元素复制到剩下的单元。
		des[k++] = a[i++];
	while (j <= high)
		des[k++] = a[j++];
}
//递归的划分序列，直到总序列中只有一个元素及low = high
void Msort(int a[], int des[], int low, int high, int max)
{
	if (!a) return;
	int mid = 0;
	if (low == high)
	{
		des[low] = a[low];
	}
	else
	{
		mid = (low + high) / 2;
		int *space = malloc(sizeof(int)* max);
		if (!space)
			return;
		else
		{
			Msort(a, space, low, mid, max);
			Msort(a, space, mid + 1, high, max);
			Merge(space, des, low, mid, high);
		}
		free(space);
	}
}

5).插入排序

　　基本思想：每步将一个待排序的记录，按照其大小插入到前面的已经排序好的序列中，直到数据全部插入为止。

　　插入排序是稳定排序，平均时间复杂度为O(n²),最坏时间复杂度为O(n²)，空间复杂度为O(1);

void InsertSort(int a[], int len)
{
	if (!a) return;
	int i = 0, j = 0;
	int k = 0;
	int tmp = 0;
	for (i = 1; i < len; i++)
	{
		k = i;
		tmp = a[k];
		for (j = i - 1; (j >= 0) && (a[j] > tmp); j--)
		{
			a[j + 1] = a[j];
			k = j;
		}
		a[k] = tmp;
	}
}