之前学习了冒泡排序法和选择排序法，最近被老师问某个道题用的是什么排序法。自己居然答不出来，才发现自己没有真正弄懂，这两个算法的原理和区别，所以·····
 
1冒泡排序法
 
1.1什么是冒泡排序法？
 
顾名思义，冒泡排序法，就是把要排序的一组数据中的元素当成一个一个气泡,每次比较相邻两个相邻“气泡”的"轻重’，“气泡”较重的往下"沉"，轻的往上”浮“。
 
1.2原理
 
从第一个数开始，依次往后进行相邻两个数之间的比较，如果前面的数比后面的数大就交换这两个数的位置，如果前面的数较小或两者一样大，就不作处理。
 
1.3详细描述
 
➀比较相邻的元素的大小。如果第一个比第二个大，就交换它们两个的顺序；
 ➁对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
 ➂针对所有的元素重复以上的步骤，除了最后一个；
 ➃重复步骤➀~➂，直到排序完成。
 
1.4动态图片演示
 
 
1.5代码演示
 
1.5.1首先是从大到小
 
public class BubbleSortMax {
	public static void main(String[] args) {
		int[] array = { 1, 8, 5, 16, 32, 21 };
		int temp;
		System.out.print("原来数组排序为：");
		// for循环输出数组
		for (int i = 0; i< array.length; i++)
			System.out.print(array[i] + ",");
        //换行
		System.out.println();
		// 开始冒泡排序
		// 外层循环控制比较的趟数,一般为数组长度-1
		for (int i = 0; i < array.length - 1; i++) {
			// 内层循环控制每一趟排序多少次，一般为数组长度-外层循环变量-1
			for (int j = 0; j < array.length - i - 1; j++) {
				// 降序--如果前面小于后面则交换
				if (array[j] < array[j + 1]) {
					//引入temp变量作为交换媒介
					temp = array[j + 1];
					array[j + 1] = array[j];
					array[j] = temp;
				}
			}
		}
		System.out.print("由大到小的排序为：");
		// for循环输出数组
		for (int i= 0; i< array.length; i++)
			System.out.print(array[i] + ",");
	}
}
 
运行结果：
 
 1.5.2从小到大排序
 
public class BubbleSortMin {
	public static void main(String[] args) {
		int[] array = { 1, 8, 5, 16, 32, 21 };
		int temp;
		System.out.print("原来数组排序为：");
		// for循环输出数组
		for (int i = 0; i < array.length; i++)
			System.out.print(array[i] + ",");
		// 换行
		System.out.println();
		// 开始冒泡排序
		// 外层循环控制比较的趟数,一般为数组长度-1
		for (int i = 0; i < array.length - 1; i++) {
			// 内层循环控制每一趟排序多少次，一般为数组长度-外层循环变量-1
			for (int j = 0; j < array.length - i - 1; j++) {
				// 升序--如果前面大于后面则交换
				if (array[j] > array[j + 1]) {
					// 引入temp变量作为交换媒介
					temp = array[j + 1];
					array[j + 1] = array[j];
					array[j] = temp;
				}
			}
		}
		System.out.print("由小到大的排序为：");
		// for循环输出数组
		for (int i = 0; i < array.length; i++)
			System.out.print(array[i] + ",");
	}
}
 
运行结果：
 
 
1.6对比分析
 
从上面两个排序我们可以发现，
 
1.外层控制循环的比较次数，循环次数：数组长度-1
 2.内层控制循环排序次数，，循环次数：数组长度-外层循环变量-1
 3.要实现一组数据的排序是从大到小还是从小到大，只需要改变下面这一行代码的比较大小符号即可。
 
if (array[j] > array[j + 1]) {
 
从小到大===大于号>
 
从大到小===小于号<
 
1.7冒泡排序法的主体框架
 
for (int i = 0; i < 数组长度变量名- 1; i++) {
			// 内层循环控制每一趟排序多少次，一般为数组长度-外层循环变量-1
			for (int j = 0; j <数组长度变量名   - i - 1; j++) {
				// 升序--如果前面大于后面则交换
				if (array[j] 视情况填写大于号和小于号array[j + 1]) {
					// 引入temp变量作为交换媒介
					temp = array[j + 1];
					array[j + 1] = array[j];
					array[j] = temp;
				}
			}
		}
 
1.8如何快速写出一个冒泡排序法
 
明白了原理，理解了从小到大和从大到小的规律，再记住冒泡排序法的基本框架，我们只需要确定几个量就可以写出一个冒泡排序法了。
 步骤：
 1.先确定所需要排序的数据元素个数----->用于确定外层循环的次数，循环次数：数组长度-1
 2.确定内层循环次数，循环次数：数组长度-外层循环变量-1
 3.根据从大到小还是从小到大的排序确定下面这行代码的符号
 4.代入主体框架
 
if (array[j] 视情况填写大于号和小于号array[j + 1]) {
 
2.选择排序法
 
2.1什么是选择排序法？
 
还是顾名思义，选择排序法就是从需要排序的数据元素中 选出最小或最大的一个元素，把他和第一个位置的元素进行互换。
 
2.2原理
 
通过自定义的最小值元素的下标，在内层循环中通过下标进行比较，查找过程中不移动数位置, 如果发现比自定义最小值元素下标还要小的值，则将该值的下标赋值给自定义的最小值元素下标。在一次内层循环结束后，将最小值元素交换至数组左端。
 
2.3详细描述
 
将要排序的数组分成两个数组，一个是有序数组一个是无序数组，再定义一个最值下标
 假定有序数组是数组的第一个元素，这个最值也假定为数组的第一个数，最值下标从第一个数开始
 然后将有序数组中的数和最值下标指向的数进行比较， 如果无序数组中的数大于或小于有序数组中的数，那么将最大值或者最小值的下标更新为无序数组中那个值的下标
 然后再将新的最大值或者最小值的下标和有序数组中的数比较，若大于或者小于，那就将它们两的值进行交换。
 
2.4动态图片演示
 
 
2.5代码演示
 
2.5.1首先是从大到小
 
public class SelectSortMax {
	public static void main(String[] args) {
		int[] a = { 1, 8, 5, 16, 32, 21 };
		int max;// 最大值下标
		int temp;
		// 外层循环控制循环次数,通常为数组长度-1
		for (int i = 0; i < a.length - 1; i++) {
			max = i;// 假设最大值是a[i],即a[0]
			for (int j = i + 1; j < a.length; j++) {
				if (a[j] > a[max])
					// 如果有比现在制定的最大元素还小的，就更新最大值下标
					max = j;
			}
//          退出内层循环后，判断最大下标是否
//			与原来相等，不等，说明有更大的，进行更新排序
//			if (a[i] != a[min]) {
			if (i != max) {
				// if (a[i] != a[min]) {//也可以更改这个
				temp = a[max];
				a[max] = a[i];
				a[i] = temp;
			}
		}
		for (int i = 0; i < a.length; i++)
			System.out.print(a[i] + ",");
	}
}
 
运行结果：
 
 2.5.2从小到大排序
 
public class SelectSortMin {
	public static void main(String[] args) {
		int[] a = { 1, 8, 5, 16, 32, 21 };
		int min;// 最小值下标
		int temp;
		// 外层循环控制循环次数,通常为数组长度-1
		for (int i = 0; i < a.length - 1; i++) {
			min = i;// 假设最小值是a[i],即a[0]
			for (int j = i + 1; j < a.length; j++) {
				if (a[j] < a[min])
					// 如果有比现在制定的最小元素还小的，就更新最小值下标
					min = j;
			}
//          退出内层循环后，判断最小下标是否
//			与原来相等，不等，说明有更小的，进行更新排序
			if (i != min) {
		//	if (a[i] != a[min]) {// 也可以更改为这个
				temp = a[min];
				a[min] = a[i];
				a[i] = temp;
			}
		}
		for (int i = 0; i < a.length; i++)
			System.out.print(a[i] + ",");
	}
}
 
运行结果：
 
 
2.6对比分析
 
1.外层控制循环的比较次数，循环次数：数组长度-1
 2.内层控制循环排序次数，循环次数：数组长度
 3.要实现一组数据的排序是从大到小还是从小到大，只需要改变下面这一行代码的比较大小符号即可。
 
	if (a[j] < a[min])
	//或者是if (a[j] > a[max])
 
从小到大===大于号<
 
从大到小===小于号>
 
2.7冒泡排序法的主体框架
 
int max;// 最大值下标
		int temp;
		// 外层循环控制循环次数,通常为数组长度-1
		for (int i = 0; i < a.length - 1; i++) {
			max = i;// 假设最大值是a[i],即a[0]
			for (int j = i + 1; j < a.length; j++) {
				if (a[j] 视情况填写大于号和小于号 a[max])
					// 如果有比现在制定的最大元素还小的，就更新最大值下标
					max = j;
			}
//          退出内层循环后，判断最大下标是否
//			与原来相等，不等，说明有更大的，进行更新排序
			if (i != max) {
				// if (a[i] != a[min]) {//也可以更改这个
				temp = a[max];
				a[max] = a[i];
				a[i] = temp;
			}
		}
 
2.8如何快速写出一个冒泡排序法
 
还是和前面差不多。
 1)明白原理，2）理解从小到大和从大到小的规律，3）再记住冒泡排序法的基本框架，
 开始步骤：
 1.先确定所需要排序的数据元素个数----->用于确定外层循环的次数，循环次数：数组长度
 2.确定内层循环次数，循环次数：数组长度
 3.根据从大到小还是从小到大的排序确定下面这行代码的符号
 if (a[j] < a[min]) //或者是if (a[j] > a[max])
 
4.代入主体框架
 
3 最后总结
 
3.1两种排序算法之间的共同点
 
1）都有两层循环，外层循环控制比较的轮数，和数组元素的个数有关，内层循环控制需要参与比较的元素个数，和外层循环的轮数有关
 2）两种算法进行交换的结构是相同的。（本文采用借助中间变量的方法交换是为了便于读者理解，在实际编程中，往往采用直接交换的写法，而不借助中间变量，来提高效率和简洁化）
 3）两种算法虽然效率不一样，但是最终比较的次数是一样的。
 
如何区分两种算法？------个人技巧，大佬轻喷
 
1）最好的就是记住主体框架了（理解后就很好记了），当然实在记不住，那下面是一个小方法，
 
2）在选择排序算法中，会有定义一个记录最大值或者最小最小值下标的变量，只要是看到有一个这样的变量那就是选择排序算法，没有的话，就是冒泡排序法
 
3）就是我们一般常用的是冒泡排序法（看书和网上的案例都是冒泡居多）。但是如果项目涉及效率提高，性能优化的时候往往会使用选择排序法
 为什么？
 一是代码长度的问题，二是效率和复杂度问题，这个可以去看一下两个算法的排序换位操作。
 冒泡排序算法中每次比较，两层循环都必须完全执行，因此对于任何情况下它的效率都是比较慢的。所以，你懂得。。。
 
4最后一些小问题解决
 
好像初中就学过，不过太久远，忘记了。
 
word横线怎么打
 https://jingyan.baidu.com/article/00a07f380d690c82d028dcf9.html
 
在word文档中怎么设置每段的开头空两格？
 https://zhidao.baidu.com/question/560399680.html
 
在Word中输入后文字下面会出现蓝色的双下划线怎么取消
 https://www.kafan.cn/A/gvxexzp8nr.html
 
图片及部分内容借鉴于https://blog.csdn.net/weixin_40205234/article/details/86699088

现在的IT行业并不像以前那么好混了，从业人员过多，导致初级程序员过剩，这也间接导致了公司的招聘门槛越来越高，要求程序员掌握的知识也越来越多。
 算法也是一个争论了很久的话题，程序员到底该不该掌握算法？不同的人有不同的答案，而事实上，很多公司都对算法有一定的要求，有些公司直接在面试的时候便会要求面试者手写算法题。这就对程序员的技术要求产生了很大的考验，所以面对如今的大环境，我们必须掌握算法，才能在今后的工作中占据一席之地。
 那么接下来，我就简单介绍一下几个排序算法，希望对你们有所帮助。
 
1.冒泡排序
 
冒泡排序（Bubble Sort），是一种较简单的排序算法。
 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
 这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
 演示：
 
 代码如下：
 
@Test
public void bubbleSort() {
	int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
	// 统计比较次数
	int count = 0;
	// 第一轮比较
	for (int i = 0; i < arr.length - 1; i++) {
		// 第二轮比较
		for (int j = 0; j < arr.length - 1 - i; j++) {
			if (arr[j] > arr[j + 1]) {
				// 交换位置
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
			count++;
		}
	}
	System.out.println(Arrays.toString(arr));
	System.out.println("一共比较了:" + count + "次");
}
 
运行结果：
 
[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
一共比较了:105次
 
这段代码相信大家都能够写出来，一般冒泡排序也就是这样写。但是这段程序有个缺点，就是当排序过程中已经将数组元素排序完成，但此时它仍然会去比较，这就做了无用功了，所以我们可以通过一个boolean变量来优化这段代，上面的程序中我们已经得出了比较次数为105次。
 优化代码：
 
@Test
public void bubbleSort() {
	int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
	// 统计比较次数
	int count = 0;
	for (int i = 0; i < arr.length - 1; i++) {
		boolean flag = true;
		for (int j = 0; j < arr.length - 1 - i; j++) {
			if (arr[j] > arr[j + 1]) {
				// 交换位置
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
				flag = false;
			}
			count++;
		}
		if(flag) {
			break;
		}
	}
	System.out.println(Arrays.toString(arr));
	System.out.println("一共比较了:" + count + "次");
}
 
运行结果：
 
[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
一共比较了:95次
 
我们首先在开始循环时定义了一个boolean变量为true，然后如果元素之间进行了交换，就将值置为false。所以，我们就可以通过这个boolean变量来判断是否有元素进行了交换。如果boolean变量为true，则证明没有元素进行交换，那么久说明此时的数组元素已经完成排序，那么跳出外层循环即可，否则就继续排序。通过结果也可以看出，比较次数确实是减少了很多。
 
2.选择排序
 
选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。
 演示：
 
 代码如下：
 
@Test
public void SelectionSort() {
	int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
	for (int i = 0; i < arr.length - 1; i++) {
		int index = i;
		for (int j = 1 + i; j < arr.length; j++) {
			if (arr[j] < arr[index]) {
				index = j;// 保存最小元素的下标
			}
		}
		// 此时已经找到最小元素的下标
		// 将最小元素与前面的元素交换
		int temp = arr[index];
		arr[index] = arr[i];
		arr[i] = temp;
	}
	System.out.println(Arrays.toString(arr));
}
 
运行结果：
 
[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
 
实现也非常的简单，首先在外循环里定义了一个index变量存储i的值，这是为了避免重复地比较，因为在每一轮的比较结束后，前i个元素是已经排好序的，所以无需再次比较，只需从i开始即可。后面的比较都是基于index位置的元素进行比较，倘若比较完后index位置的元素是最小值，那就无需交换，不动即可。而如果找到了比index位置的元素更小的元素，那就将该元素的索引赋值给index，然后继续比较，直到比较完成，比较完成之后得到的index即为数组中的最小值，那此时只需要将index位置的元素和i位置的元素交换即可。
 
3.插入排序
 
插入排序（Insertion sort）是一种简单直观且稳定的排序算法。如果有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外（让数组多一个空间才有插入的位置），而第二部分就只包含这一个元素（即待插入元素）。在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中。
 插入排序的基本思想是：每步将一个待排序的记录，按其关键码值的大小插入到前面已经排序的数组中的适当位置上，直到全部插入完为止。
 演示：
 
 代码如下：
 
@Test
public void InsertionSort() {
	int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
	for (int i = 1; i < arr.length; i++) {
		// 定义待插入的数
		int insertValue = arr[i];
		// 找到待插入数的前一个数的下标
		int insertIndex = i - 1;
		while (insertIndex >= 0 && insertValue < arr[insertIndex]) {
			arr[insertIndex + 1] = arr[insertIndex];
			insertIndex--;
		}
		arr[insertIndex + 1] = insertValue;
	}
	System.out.println(Arrays.toString(arr));
}
 
运行结果：
 
[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
 
那么在这里，因为数组元素我们并不确定，所以只能将数组的第一个元素看成是一个有序的序列，所以从数组的第二个元素开始才是我们需要去寻找插入位置的元素。所以外层循环从1开始，然后将arr[i]，也就是当前的第二个元素先保存起来，然后找到待插入元素的前一个元素下标，也就是i-1，此时通过一个while循环去比较。
 当insertIndex小于0时应该退出循环，因为此时已经与前面的所有元素比较完毕。在比较的过程中，如果待插入元素小于前一个元素，就将前一个元素后移，也就是将前一个元素的值直接赋值给待插入元素位置。因为在最开始已经将待插入元素进行了保存，所以只需将待插入元素的值赋值给它的前一个元素即可。因为在while循环中insertIndex执行了自减操作，所以它的前一个元素下标应为insertIndex + 1。而如果待插入的元素值大于前一个元素，那么就不会进入while循环，这样insertIndex + 1之后的位置仍然是自己所在的位置，所以赋值后值不改变，后面的操作以此类推。
 
4.希尔排序
 
传统的插入排序算法在某些场景中存在着一些问题，例如[2，3，4，5，1]这样的一个数组，当我们对其进行插入排序的时候，发现要插入的数字是1，而要想将1插入到最前面，需要经过四个步骤，分别将5、4、3、2后移。所以得出结论：如果较小的数是我们需要进行插入的数，那效率就会比较低。鉴于这种场景的缺陷，希尔排序诞生了，它是插入排序的一种更高效的版本。
 先看看希尔排序的概念：
 希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因D.L.Shell于1959年提出而得名。
 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
 
演示：
 
 动画如果没有看懂，我这里再贴几张静态图：
 
 代码实现：
 
@Test
public void ShellSort() {
	int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
	for (int gap = arr.length / 2; gap > 0; gap /= 2) {
		// 对数组元素进行分组
		for (int i = gap; i < arr.length; i++) {
			// 遍历各组中的元素
			for (int j = i - gap; j >= 0; j -= gap) {
				// 交换元素
				if (arr[j] > arr[j + gap]) {
					int temp = arr[j];
					arr[j] = arr[j + gap];
					arr[j + gap] = temp;
				}
			}
		}
	}

	System.out.println(Arrays.toString(arr));
}
 
运行结果：
 
[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
 
那么在上面的程序段中，数组长度为15，所以在第一轮，数组被分为了15 / 2 = 7个小组，然后分别对每个小组的元素进行遍历。在第一轮中小组之间的元素间隔都为7，所以分成的小组数其实也就是元素之间的间隔。接着就可以对每个小组的元素进行比较，然后进行交换，接下来以此类推。
 
推荐阅读
 
程序员那些必须掌握的排序算法(下)

原理
举例
程序范例
 
 
原理
 
选择排序法属于排序算法中常见的也是大家最容易理解的排序算法，可以作为排序算法的入门来学习。 
 那么选择排序法的原理是什么呢？选择排序就是当n个数字需要由大到小排序时，首先以第1个位置的数字，依次与2、3、4……n个位置的数字作比较。如果第1个位置的数字大于或等于某一个位置的数字，则两个位置的数字不变，反之则将两个位置的数字进行互换。 当第一轮比较大小完成后，此时第1个位置的数字即为此排序数列的最大值。接下来选择第2个位置的数字，以同样的方法依次与3、4、5……n个位置的数字作比较，将最大值放在第2个位置。依循此方法直到第n-1位置的数字和第n位置的数字比较大小之后，整个数列就由大到小来排列。简而言之，其主要思想是在要排序的一组数列中，选出最大的一个数与第1个位置的数交换；然后在剩下的数当中再找最大的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。数列如需要由小到大排序，原理相同。
 
举例
 
 
 
 
程序范例
 
package boke;
public class Sort1 {
    public static void main(String[] args) {
        System.out.print("原始数据为：");
        int[] data={3,8,9,4,6};
        print(data);
        selectionSort(data);
    }

    public static void selectionSort(int[] a){
        for(int i=0;i<a.length;i++){
            for(int j=i+1;j<a.length;j++){
                if(a[i]<a[j]){
                    int temp = a[i];
                    a[i]=a[j];
                    a[j]=temp;
                }
            }
            System.out.print("第"+(i+1)+"次排序结果为：");
            for(int k=0;k<a.length;k++){
                System.out.print(a[k]+"  ");
            }
            System.out.print("\n");
        }
    }

    public static void print(int[] a){
        for(int i=0;i<a.length;i++){
            System.out.print(a[i]+"  ");
        }
        System.out.print("\n");
    }
}

前言
 
排序(Sorting) 是计算机程序设计中的一种重要操作，它的功能是将一个数据元素（或记录）的任意序列，重新排列成一个关键字有序的序列。本文主要讲述python中经常用的三种排序算法，选择排序法，冒泡排序法和插入排序法及其区别。通过对列表里的元素大小排序进行阐述。
 原文地址：https://blog.zeruns.tech/index.php/archives/297/
 
一、选择排序法
 
选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。
 
1. 算法步骤
 
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
重复第二步，直到所有元素均排序完毕
 
2. 动图演示
 
 
3. Python 代码实现
 
def selectionSort(arr):
    # 求出arr的长度
    n = len(arr)
    # 外层循环确定比较的轮数，x是下标，arr[x]在外层循环中代表arr中所有元素
    for x in range(n - 1):
        # 内层循环开始比较
        for y in range(x + 1, n):
            # arr[x]在for y 循环中是代表特定的元素，arr[y]代表任意一个arr任意一个元素。
            if arr[x] > arr[y]:
                # 让arr[x]和arr列表中每一个元素比较，找出小的
                arr[x], arr[y] = arr[y], arr[x]
    return arr
print(selectionSort([1, 3, 1, 4, 5, 2, 0]))
 
二、冒泡排序法
 
冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
 冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。但这种改进对于提升性能来说并没有什么太大作用。
 
1. 算法步骤
 
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
 
2. 动图演示
 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AlO6NxBK-1580797495960)(https://tc.zeruns.tech/images/2020/01/31/640-1.gif)]
 
3. Python 代码实现
 
def bubbleSort(arr):
    n = len(arr)
    for x in range(n - 1):
        for y in range(n - 1 - x):
            if arr[y] > arr[y + 1]:
                arr[y], arr[y + 1] = arr[y + 1], arr[y]
    return arr
print(bubbleSort([1, 3, 1, 4, 5, 2, 0]))
 
三、插入排序法
 
插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
 插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。
 
1. 算法步骤
 
将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）
 
2. 动图演示
 
 
3. Python 代码实现
 
def insertionSort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and key < arr[j]:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
    return arr
print(insertionSort([1, 3, 1, 4, 5, 2, 0]))