简单排序--冒泡、插入、选择

说明：此处表示的算法都是针对大量的数据（10000+）。
前提条件：
参数都是两个，待排数组，元素个数（默认讨论的是整数类型，从小到大）
基于比较的排序（元素之间能够标比较大小）
内部排序（内存空间充分大，数据可以一次性导入内存中）
稳定性：相等的数据，排序前后的位置不变，（小明1和小明2）
每一种算法有其存在的理由，没有一种排序是任何情况下都是最好的。

简单排序

冒泡排序

比较相邻的两个元素，一趟排序之后，最大的元素放在最下面，排序n-1趟

考虑一种情况，就是在中间某一次排序之后，元素已经有序了。还是需要比较的。
什么情况下知道元素已经有序，不需要比较了呢？
一趟排序之后，从头到尾没有元素交换过。
运用标记flag，一趟排序之后判断一下flag即可

考虑时间复杂度：
最好的情况：元素已经有序，只需要比较一趟，运用flag结束排序，O(N);
最坏情况：元素逆序，需要不断地比较和交换O(N^2)
优点：编写的时候非常简单，但是O(N^2)级别的排序算法是不可接受的。有一个好处是，从上往下按照一个方向扫描，每次交换相邻的元素。（元素存放在链表中时，此种排序算法任然可用，其他排序算法不容易做到这一点），并且发现，只有当严格的大于才做交换，相等的话，不做交换，故是稳定的
算法实现：

void Bubble_Sort(int A[],int N)
{
	
	int flag = 0;
	for(int p = N-1;p>=1;p--)//总共需要n-1次排序
	{
		flag = 0;
		for(int i = 0;i<p;i++)
		{	
			if(A[i]>A[i+1])//两两元素比较，严格大于才开始交换
			{
				flag = 1;
				swap(A[i],A[i+1]);
			}
		}
		if(flag == 0)
			return ;
	}
}

Q:最好的情况下和最坏的情况下需要比较多少次，交换多少次?
测试代码：

//北航机试2020/3/24
#include<stdio.h>
#include<algorithm>
using namespace std;



void Bubble_Sort(int A[],int N,int& compare_c,int& swap_c)
{
	
	int flag = 0;
	for(int p = N-1;p>=1;p--)//总共需要n-1次排序
	{
		flag = 0;
		for(int i = 0;i<p;i++)
		{
			compare_c++;
			if(A[i]>A[i+1])//两两元素比较，严格大于才开始交换
			{
				swap_c++;
				flag = 1;
				swap(A[i],A[i+1]);
			}
		}
		if(flag == 0)
			return ;
	}
}

/*
void Bubble_Sort(int A[],int N)
{
	
	int flag;
	for(int p = N-1;p>=1;p--)//总共需要n-1次排序
	{
		flag = 0;
		for(int i = 0;i<p;i++)
		{	
			if(A[i]>A[i+1])//两两元素比较，严格大于才开始交换
			{
				flag = 1;
				swap(A[i],A[i+1]);
			}
		}
		if(flag == 0)
			return ;
	}
}
*/


int main()
{
	int i;
	int compare_c1 = 0,swap_c1 = 0;
	int compare_c2 = 0,swap_c2 = 0;

	int A[8] = {1,4,9,13,8,6,3,2};
	int A1[8] = {1,2,3,4,6,8,9,13};
	int A2[8] = {13,9,8,6,4,3,2,1};

	Bubble_Sort(A1,8,compare_c1,swap_c1);
	for( i = 0;i<8;i++)
    {
        if(i == 7)
            printf("%d\n",A1[7]);
        else printf("%d ",A1[i]);
    }
	printf("%d %d\n",compare_c1,swap_c1);


	Bubble_Sort(A2,8,compare_c2,swap_c2);
	for( i = 0;i<8;i++)
    {
        if(i == 7)
            printf("%d\n",A2[7]);
        else printf("%d ",A2[i]);
    }
	printf("%d %d\n",compare_c2,swap_c2);

	return 0;
}
/*
1 2 3 4 6 8 9 13
7 0
1 2 3 4 6 8 9 13
28 28
*/

A:最好情况下只进行了一趟比较，比较次数为n-1,交换次数为0
最坏情况下进行了n-1趟比较，比较次数为(n-1) + (n-2)+…+1 = (n-1)*n/2,交换次数为(n-1) + (n-2)+…+1 = (n-1)*n/2

注意:此处的冒泡排序的算法是添加flag之后的改进的冒泡算法。
没有改进的冒泡排序时间复杂度始终是O(N^2)数量级。

选择排序

• 算法思想：
  选择排序的算法非常直观：第i趟排序选择待排元素中最小的放到第i个位置,直到n-1趟结束（最后剩下一个元素就无需选择）。
• 算法实现：

#include<stdio.h>
#include<algorithm>
using namespace std;

void Selection_Sort(int A[],int N)
{
	for(int i = 0;i<N-1;i++)
	{
		int min = i;
		for(int j = i + 1;j<N;j++)
		{
			if(A[j] < A[min])
				min = j;
		}
		if(min != i)
		{
			swap(A[min],A[i]);
		}
	}
}


int main()
{
	int i;
	int A[8] = {1,4,9,13,8,6,3,2};
	Selection_Sort(A,8);
	for( i = 0;i<8;i++)
    {
        if(i == 7)
            printf("%d\n",A[7]);
        else printf("%d ",A[i]);
    }

	return 0;
}

是不稳定的算法，考虑{2,2,1};
第一趟排序之后，稳定性被破坏。
时间复杂度始终为O(N^2);

插入排序

和已有序的数据相比较（从后往前比）找到合适的位置插入。
假设一开始的时候的第0号牌已经有序，故从第1号牌开始比较。
将当前需要比较的数字和之前的有序数字比较，找到空位插入
最好的情况：元素有序，只需要n-1次摸牌，n-1次元素的比较，无需移动数据，O(N);
**最坏的情况：**元素逆序，需要n-1次摸牌，1 +2 + 3 + …+(n-1) = （n-1)*n/2比较， 1+2 + 3 + …+(n-1) = n-1)*n/2次移动元素。O(N^2)
优点：比较好写，
并且相比于冒泡排序来说，元素移动比元素的交换省很多步骤，其存在的更加主要的原因并不是这个。这个也是稳定的算法，时间复杂度很高

都需要9次交换，这是巧合吗？

• 算法实现

#include<stdio.h>
void Insertion_Sort(int A[],int N)
{
	for(int p=1;p<=N-1;p++)//第一张牌可以看成有序，后面n-1个元素都需要插入
	{
		int tmp = A[p];
		for(int i = p;i>0 && A[i-1]>tmp;i--)//i可以当做待插入的位置
		{
			A[i] = A[i-1];
		}
		A[i] = tmp;
	}
}


int main()
{
	int i;
	int A[8] = {1,4,9,13,8,6,3,2};

	Insertion_Sort(A,8);
	for( i = 0;i<8;i++)
    {
        if(i == 7)
            printf("%d\n",A[7]);
        else printf("%d ",A[i]);
    }

	return 0;
}

附加内容：
回答前面的巧合问题，交换次数都是9次？

• 冒泡排序和插入排序每次都是消去一个逆序对。
  因为待排序的序列中含有9个逆序对，故都需要9次交换元素
• 重新看一下插入排序的时间复杂度，不仅和元素的个数N有关还和待排序列中的逆序对的个数I有关。
• 无论如何都需要将元素扫描一遍，至少是一个O(N)复杂度的（最好的情况是元素有序，此时只需扫面一遍元素即可），另外操作的次数是和逆序对的个数成正比。
• 
• 此公式代表的意思是：如果序列基本有序，则插入排序非常好写，并且非常高效。
  思考一下为什么不是改进过后的冒泡排序呢？
  因为同样在最好的情况下（序列有序）的时间复杂度是O(N)，并且交换元素的次数都是逆序对的个数I;
  这个比较放在后面的文章冒泡排序和插入排序的比较中分析
• 
  更一般的情况
  
  即O(N^2)数量级别的逆序对。
  也就是说，不管是插入排序还是冒泡排序，平均时间复杂度都和逆序对的个数有关
  也就是说：
  
  即：这种算法的最好最好的平均时间复杂度也就是O(N^2)级别。
  此限制是交换相邻两个元素，只能够去掉一个逆序对。
  
  每次消去多个逆序对，话句话说，就是每次交换相隔比较远的两个元素。