三种简单排序比较总结（冒泡、插入、选择）

首先我们了解一下三种算法稳定性

算法	稳定性	排序方式	时间复杂度	最好时间	空间复杂度
冒泡	稳定	交换	O(n2)	O(n)	O(1)
插入	稳定	直接插入	O(n2)	O(n)	O(1)
选择	不稳定	直接选择	O(n2)	O(n)	O(1)

三种最好时间都是：在接近有序的时候！

接着我们看一下代码

首先我们定一下数组：12,23,34,2，23,6 冒泡排序

int temp = 0;  //设定空值，作为值交换
            //循环次数--外循环
            for (int i = 0; i < nums.Length; i++)  //循环小于总长度
            {
                //比较大小--内循环
                for (int j = 0; j < nums.Length - 1 - i; j++)//长度减去I的比较值在减去最后一个值
                {
                    if (nums[j] > nums[j + 1])
                    {
                        //交换位置
                        temp = nums[j];
                        nums[j] = nums[j + 1];
                        nums[j + 1] = temp;
                    }
                }

            }
            //循环遍历显示结果
            foreach (int number in nums)
            {
                Console.WriteLine(number + "");
            }

            Console.ReadKey();

插入排序

 for (int i = 1; i < nums.Length; i++)  //外层循环确定待比较数值
            {
                int temp = nums[i];  //设置哨兵作为比较
                if (nums[i] > nums[i - 1])  //判断当前数是否比i-1大在，这样可以确定是否用内循环
                {
                    temp = nums[i];    //将大数的坐标暂时赋值给哨兵，自己位置让i-1位置的填补。
                    nums[i] = nums[i - 1]; //将小数往前调，但是自己位置依旧是自己的值
                }
                int j = 0;
                for (j = i - 1; j >= 0 && nums[j] > temp; j--) //内循环是确定已排序个数的比较次数
                {
                    nums[j + 1] = nums[j];       //如果待放进的数值依次比已排序的数大，则依次往前面挪动地方。             
                }
                nums[j + 1] = temp; //最后确定需要放的位置。因为先执行的j--,现在j为-1，所以是j+1

            }
            foreach (var item in nums)  //依次循环显示数据
            {
                Console.WriteLine(item);
            }
            Console.ReadLine();

选择排序

 //选择排序主要循环代码：
            for (int i = 0; i < nums.Length; i++)  //设置外循环次数
            {
                int temp = i;  //设置变量作为被比较的数为标识
                int k = 0;//作为交换下标的空值
                int n=0; //作为交换下标值空值
                for (int j = i+1; j <nums.Length ; j++) //设置内循环，设置无序序列循环比较次数
                {
                    if (nums[temp]>nums[j]) //进行判断：如果无序数组数比标识小的情况下做交换
                    {
                        //最小值j和作为比较变量Temp交换下标
                        k = j;
                        j = temp;
                        temp = k;

                    }
                }
                //最小值和第i个数交换。
                n = nums[temp];
                nums[temp] = nums[i];
                nums[i] = n;
            }

            //依次循环显示：
            foreach (var item in nums)
            {
                Console.WriteLine(item);
            }
            Console.Read();

图表分析不同点

算 法	说明
冒泡	两次循环都是从0开始，并且交换在内循环嵌套中进行值交换
插入	插入算法在外循环进行做一个和前面数的比较大小，如果比前面数大则直接进行下一个数即可，如果小则进入内循环，在内循环中做一个值的后移操作，最后进行赋值到需要的位置即可。
选择	此算法可以进行下标的移动进而移动相对应的值，因为选择是将后面最大值/最小值放到依次对应的位置上面，所以每次都是两个值做交换，不会动到其他的值。

思想总结

算法	思想
冒泡	最简单算法，利用水泡的原理，排序一个从小到大的序列，适用于小波人排队
插入	适用于 扑克牌的抓牌，这样可以每次从无序中最前面插入到有序序列中比后面大比前面小的空位中，使得插入的值的后面位置都会加一
选择	适用于买衣服，从无序里面选择最便宜的放到你需要的买的地方去，这样每个人都会买到需要最便宜的衣服。
相同点	三种算法时间和空间复杂度都一样且最后都是值交换，循环上面都是两次循环且都需要变量来进行转换，生活场景上都可以进行算法替换！