基础的排序算法

一，选择排序

1.对一组数实现从小到大排列。首先选出0到n-1之间最小的数，他就是整个数组的最小数，放在0位置
2.再选出1到n-1之间最小的数，他就是第二小的数，放1位置
3.再找出2到n-1之间的最小数，以此类推。

#include<stdio.h>
void swap(int arr[], int min_index, int i)
{
	int temp = 0;
	temp = arr[min_index];
	arr[min_index] = arr[i];
	arr[i] = temp;
}
int main()
{
	int arr[] = { 3,2,3,325,
		546,74,8,234,6,766,76,98 };
	for (int i=0;i<sizeof(arr)/sizeof(arr[0]);
		i++)
	{
		int min_index = 0;
		min_index = i;
		for (int j=i+1; j < sizeof(arr) / sizeof(arr[0]);
			j++)
		{
			min_index = arr[min_index] < arr[j] ?min_index:j;
		}
		swap(arr, min_index,i);
	}
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%4d", arr[i]);
	}
	return;
}

时间复杂度为O(N²)

二，冒泡算法

有点像打擂台赛。胜者滚动到最右边，
1.首先arr[0]和arr[1]比较，大的在右，完事之后，此时的arr[1]是这一轮的擂台主，将和下一位参赛选手arr[2]决出胜负
2，arr[1]和arr[2]比较，大的在右，此时arr[2]是擂台主
3.以此类推，一轮冒泡之后，arr[n-1]将是擂台主，也就是最大数

#include<stdio.h>
void swap(int arr[], int j)
{
	int temp = 0;
	temp = arr[j];
	arr[j] = arr[j + 1];
	arr[j + 1] = temp;
}
int main()
{
	int arr[] = { 3,2,3,325,
		546,74,8,234,6,766,76,98 };
	for (int i = 0; i <(sizeof(arr) / sizeof(arr[0])) - 1
		; i++)
	{
		for (int j = 0; j < ((sizeof(arr) / sizeof(arr[0])))
			- i-1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				swap(arr, j);
			}
		}
	}
	for (int i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
	{
		printf("%4d", arr[i]);
	}
	return 0;
}

或者用递归

#include<stdio.h>
void swap(int arr[], int i)
{
	int temp = 0;
	temp = arr[i];
	arr[i] = arr[i + 1];
	arr[i + 1] = temp;
}
void bubble(int arr[],int length)
{
	if (length == 1)
	{
		return;
	}
	for (int i = 0; i < length-1; i++)
	{
		if (arr[i] > arr[i+1])
		{
			swap(arr,i);
		}
	}
	length =length - 1;
	bubble(arr,length);
	return;
}
int main()
{
	int arr[] = { 3,2,3,325,
		546,74,8,234,6,766,76,98 };
	int length = sizeof(arr) / sizeof(arr[0]);
	bubble(arr,length);
	for (int i=0;i<length;i++)
	{
		printf("%4d", arr[i]);
	}
	return 0;
}

时间复杂度是O(N²).

三，归并算法

利用递归，自己调用自己，先将左半部分排好，然后是右半部，最后由于左右如果单看，都是有序的
利用两个指针和辅助数组，分别指着左右两边的首元素，比出大小。

#include<stdio.h>
void merge(int arr[], int help[],int l, int r)
{
	int mid = (l + r)/2;
	if (l == r)
	{
		return;
	}
	merge( arr,help,l, mid);
	merge(arr,help,mid + 1, r);
	int j = l;
	int k = mid+1;
	for (int i =l ; i <= r; i++)
	{
		if (j <= mid && k <= r)
		{
			help[i] = arr[j] < arr[k] ?
				arr[j++] : arr[k++];
		}
		else if (j > mid)
		{
			help[i] = arr[k++];
		}
		else
		{
			help[i] = arr[j++];
		}
	}
	for (int i = l; i <= r; i++)
	{
		arr[i] = help[i];
	}
	return;
}
int main()
{
	int help[30];
	int arr[] = { 3,2,3,325,
			546,74,8,234,766
		,1,1,26,76,98,999999 };
	int length = sizeof(arr) / sizeof(arr[0]);
	int left = 0;
	int right = length-1;
	merge(arr,help,left,right);
	for (int i = 0; i < length; i++)
	{
		printf("%d\n", arr[i]);
	}
	return 0;
}

四，master公式

由master公式：

T(N)=a*T(N/b)+O(N^d)

知道，归并排列的时间复杂度为O(N)。
因为归并排列就是把数组分成两个数组，分别使用冒泡排序，所以公式的a等于2，b等于2。最后就是分开的两个数组的最左边的数依次向右进行比较，显然时间复杂度是O(N)。

五，为什么归并算法效率比冒泡算法和选择排序高？

选择排序在不是最坏情况的时候，复杂度会比O(N²)小，冒泡排序的时间复杂度一直都是 O(N²)，无论最好最坏情况。
归并排序之所以效率更高，在于他在进行最后的归并操作的时候，是用到了之前排序的结果的，这样就可以减少判断的次数。而选择排序和冒泡排序没有用到之前排序的结果。造成重复判断，影响效率。