排序算法----冒泡，插入，希尔，选择排序

冒泡排序

原理

冒泡排序实际上是交换排序，将大的数据通过交换的方式排到一边，依次进行

代码实现 

void Swap(int* p1, int* p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

void BullerSort(int* a, int n)
{
	for (int end = n - 1; end > 0; end--)
	{
		for (int j = 0; j < end; j++)
		{
			if (a[j] > a[j + 1])
			{
				Swap(&a[j], &a[j + 1]);
			}
		}
	}
}

 时间复杂度

以最坏的情况来看，当每一个元素都需要交换的话（即当该数组里面的元素都是有序，需要把该数组调成另一种顺序），于是第一趟的元素需要交换N-1次（元素个数为N），第二趟为N-2，第三为N-3，最后一趟为1，所以时间复杂度为

O（N）=1+2+3+4+5+.......+N-1

通过等差数列的公式可知O（N）=N^2

值得注意得是，在计算时间复杂度得时候，不要看循环嵌套的次数，而是应该看该程序的原理

插入排序

原理

插入排序的思想类似于你玩扑克牌是要把顺序弄好，假设你手里面的牌的顺序是乱的，你要把顺序从左到右从小到大的把牌弄好，你要先找到第二张，和前面的比较，比前面的小就把前面的向后移一个位置，直到前面的牌比这张牌小了，把这张牌插入到前面的这张牌的后面

 

代码实现

void InsertSort(int* a, int n)  
{
	for (int i = 0; i <= n - 2; i++)
	{
		int end = i;
		int temp =  a[end + 1];;
		while (end >= 0)
		{
			
			if (temp<a[end])
			{
				a[end+1] = a[end];
				end--;
			}
			else
			{
				break;
			}
			
		}
		a[end+1] = temp;
	}
	
}

时间复杂度

插入排序的时间复杂度其实和冒泡排序的差不多，都是O（N^2），在逆序的情况下，第一次要挪动一次，第二次要挪动2次，最后一次（即就是N-1次）要挪动N-1次

但是最好的情况下是该序列接近有序，为O（N）

希尔排序

原理

希尔排序的思想和插入排序的差不多，唯独多了一点，就是间隔比较，这样比较快

 代码实现

void ShellSort(int* a, int n)
{
	int gap = n / 3 + 1;              //n除以3可能为0，所以加1
	for (int j = 0; j < gap; j++)
	{
		for (int i = 0; i <= n - gap; i += gap)
		{
			int end = i;
			int temp = a[end + gap];;
			while (end >= 0)
			{

				if (temp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}

			}
			a[end + gap] = temp;
		}
	}
}

时间复杂度

关于希尔排序的复杂度，现在还没有一种数学方法能够算得出来

 选择排序

思想

假设最大值和最小值分别位于序列得两端，通过遍历得方式找出最大值和最下的值，最大值和最小值找到后分别和最左端和最右端交换，第二趟和次左端和次右端交换

代码实现

void SelectSort(int* a, int n)
{
	int begin = 0;
	int end = n - 1;
	while (begin < end)
	{
		int maxi = end, mini = begin;
		for (int i = begin ; i <=end; i++)
		{
			if (a[i] < a[mini])
			{
				mini = i;
			}
			if (a[i] > a[maxi])
			{
				maxi = i;
			}
		}
		Swap(&a[mini], &a[begin]);
		if (maxi == begin)
		{
			maxi = mini;
		}
		Swap(&a[maxi], &a[end]);
		begin++;
		end--;
	}
}

时间复杂度

第一次运行2*（N-1）次，第二次为2*（N-2）次，依次类推，时间复杂度为O（N^2）