排序算法

冒泡排序

冒泡排序是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。

时间复杂度：O(n^2)

算法稳定性：稳定

 

大致步骤为：

1. 比较相邻的元素。如果第一个比第二个大，将两个元素进行交换；
2. 对每一对相邻元素作同样的操作，从开始第一对到结尾的最后一对；
3. 针对所有的元素重复以上的步骤（除了最后一个）；
4. 重复步骤1~3，直到排序完成。

C++代码如下：

void bubbleSort(int *arr, int len)
{
	for (int i = 0; i < len-1; ++i)
	{
		for (int j = 0; j < len - 1; ++j)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

3 55 10 2 66 30 6 19 25 9
第1趟: 3 10 2 55 30 6 19 25 9 66
第2趟: 3 2 10 30 6 19 25 9 55 66
第3趟: 2 3 10 6 19 25 9 30 55 66
第4趟: 2 3 6 10 19 9 25 30 55 66
第5趟: 2 3 6 10 9 19 25 30 55 66
第6趟: 2 3 6 9 10 19 25 30 55 66
第7趟: 2 3 6 9 10 19 25 30 55 66
第8趟: 2 3 6 9 10 19 25 30 55 66
第9趟: 2 3 6 9 10 19 25 30 55 66
2 3 6 9 10 19 25 30 55 66

 

---

--------------------------我是分割线--------------------------

选择排序

工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

时间复杂度：O(n^2)

算法稳定性：稳定

void selectesort(int arr[], int len)
{
	int minIndex, temp;
	for (int i = 0; i < len - 1; i++) 
	{
		minIndex = i;
		for (int j = i + 1; j < len; j++) 
		{
			if (arr[j] < arr[minIndex])// 寻找最小的数
			{     
				minIndex = j;          // 将最小数的索引保存
			}
		}
		temp = arr[i];
		arr[i] = arr[minIndex];
		arr[minIndex] = temp;
	}
}

3 55 10 2 66 30 6 19 25 9
第1趟: 2 55 10 3 66 30 6 19 25 9
第2趟: 2 3 10 55 66 30 6 19 25 9
第3趟: 2 3 6 55 66 30 10 19 25 9
第4趟: 2 3 6 9 66 30 10 19 25 55
第5趟: 2 3 6 9 10 30 66 19 25 55
第6趟: 2 3 6 9 10 19 66 30 25 55
第7趟: 2 3 6 9 10 19 25 30 66 55
第8趟: 2 3 6 9 10 19 25 30 66 55
第9趟: 2 3 6 9 10 19 25 30 55 66

---

插入排序

时间复杂度:无序O(n^2) 有序O(n)

空间复杂度：O(1)

算法稳定性：稳定

原理：把一个元素按升序或(降序)插入已经有序的一个序列里面，插入后保持序列的有序。

步骤：

1. 认为第一个元素为有序，i=0；
2. 取下一个元素（新元素）,i = i+1，在有序序列中从后往前扫描；
3. 从后往前依次判断新元素和已排序序列中各个元素的大小，小则不动；大则进行交换，
4. 不断的重复步骤2~3。

void Insert_Sort(int *arr, int len)
{
	int i, j;
	int tmp = 0;
	for (i = 1; i < len; i++)
	{
		tmp = arr[i];//把将要比较的值放入tmp里
		for (j = i - 1; j >= 0; j--)//j在i的前一位
		{
			if (tmp < arr[j])//如果tmp里的值比j的值小就互换tmp和j的值
			{
				arr[j + 1] = arr[j];//即把j里的值放在下一位，把tmp的值放在原来j的位置
			}
			else
			{
				break;
			}
		}
		arr[j + 1] = tmp;//不是则就放在它原来的位置，包扩j减到-1位置 j+1位0号位置
	}
}

原 始：3 55 10 2 66 30 6 19 25 9
第1趟: 3 55 10 2 66 30 6 19 25 9
第2趟: 3 10 55 2 66 30 6 19 25 9
第3趟: 2 3 10 55 66 30 6 19 25 9
第4趟: 2 3 10 55 66 30 6 19 25 9
第5趟: 2 3 10 30 55 66 6 19 25 9
第6趟: 2 3 6 10 30 55 66 19 25 9
第7趟: 2 3 6 10 19 30 55 66 25 9
第8趟: 2 3 6 10 19 25 30 55 66 9
第9趟: 2 3 6 9 10 19 25 30 55 66

---

希尔排序

希尔排序==》直接插入的优化

分组的直接插入排序---》先对数据进行分组，使用直接插入算法使得组内有序再分组，在直接插入使组内有序，直到分组只有一个

时间复杂度：O(n^1.3)——O(n^1.5)

空间复杂度：O（1）

算法稳定性：不稳定

原理：设定一个增量gap，每次插入排序使相距为d的元素排成一个有序列，然后缩小增量，继续插入排序，最后一次gap=1，排序完成 。

在进行大量数据排序上，效率较高，因为相比于冒泡，选择排序，

其每次操作省略了三步赋值的开销，只有一步。

 

ps:我程序求gap用的不断对长度求二分。常用的gap可以选择{ 5，3，1 }或者{ 7，5，3，1 }，过程有差异，最终结果是一样的。

void Shell_Sort(int arr[], int len)
{
    //gap可以为{ 5,3,1 }或者{ 7,5,3,1 }
	for (int gap = floor(len / 2); gap > 0; gap = floor(gap / 2))
	{
		for (int i = gap; i < len; i++)
		{			
			int tmp = arr[i];
			int j = i - gap;
			for (; j >= 0; j -= gap)
			{
				if (arr[j] > tmp)
				{
					arr[j + gap] = arr[j];
				}
				else
				{
					break;
				}
			}
			arr[j + gap] = tmp;
		}
	}
}

原 始：3 55 10 2 66 30 6 19 25 9
第1趟: 3 6 10 2 9 30 55 19 25 66
第2趟: 3 2 9 6 10 19 25 30 55 66
第3趟: 2 3 6 9 10 19 25 30 55 66