C# 冒泡排序法、插入排序法、选择排序法

冒泡排序法

是数组等线性排列的数字从大到小或从小到大排序。

以从小到大排序为例。

数据 11,35,39,30,7,36,22,13,1,38,26,18,12,5,45,32,6,21,42,23

使用数组 int [] array 存储数字。

过程 (数组从小到大排序)

思路循环都把最大的数放在最后一位，无序数字个数减1。

i 为当前任务位置，n 剩下的无序数字个数

从第 0位开始，比较前后两位数字大大小，当 array[i] > array[i+1] 时，数值互换。

一个循环后，数值最大的已经存到数组最后一位。

无序数字个数 n-1

　　　　for (int j = array.Length - 1; j > 0; j--)  //每排一次，剩下的无序数减一
            {
                for (int i = 0; i < j; i++)　　　　//一个for循环获得一个最大的数
                {
                    if (array[i] > array[i + 1])　　//数值互换
                    {
                        var sap = array[i];
                        array[i] = array[i + ];
                        array[i + 1] = sap;
                    }
                }
            }

排序结果

动图如下

插入排序法

插入排序算法是把一个数插入一个已经排序好的数组中。

例如把 22 插入到 [1,10,17,28,42] 中，

结果 [1,42] 。

对数组使用插入排序法

数组 int [] array = [11,23];

数组元素是无序，设定一个从大到小或从小到大的方向，第一位就是有序的 [ 11 ] ，

第一次插入： [11,23]。

取第二个数跟第一个进行比较，两位有序 [11, 39]

第二次插入：[11,39,23]

取第三个数，[11, 35],进行插入

[11, 35,39 ,23]

... ...

以后每次取一个数，插入数组。

实现方法有很多种，笔者的方法跟冒泡排序法相似。

 public static void ReSort(ref int[] array)
        {
            0; i < array.Length; i++)　　　　//要将第几位数进行插入
            {
                int j = i; j > )
                {
                    if (array[j] > array[j - 1]) break;　　//如果要排序的数大于已排序元素的最大值，就不用比较了。不然就要不断比较找到合适的位置
                    else
                    {
                        int sap = array[j];
                        array[j] = array[j - ];
                        array[j -  sap;
                    }
                }
            }
        }

试试把下面的代码复制到控制台，可以看到每次排序的结果。

using System;

namespace ConsoleApp1
{

    class Program
    {
        )
            {
                Console.WriteLine("\n- - - - - - -");
                Console.WriteLine(\n未排序前：);
                int sun = 0; sun <= i && sun < array.Length; sun++)
                {
                    Console.Write(${array[sun]},);
                }

                ;
                     sap;
                    }
                }
                Console.WriteLine(\n排序后： );
                }
            }
        }
        void Main(string[] args)
        {
            int[] array = new int[] { 11,35,1)">39,1)">30,1)">7,1)">36,1)">22,1)">13,1)">1,1)">38,1)">26,1)">18,1)">12,1)">5,1)">45,1)">32,1)">6,1)">21,1)">42,1)">23 };
            Console.Write(原数组：[);
            foreach (var i in array)
            {
                Console.Write(${i},1)">);
            }
            Console.Write(]\n);

            ReSort(ref array);
            Console.Write(\n- - - - -\n最后结果：[);
            Console.ReadKey();
        }
    }
}

动图演示

冒泡排序法与插入排序法比较

冒泡排序是从一端开始，比较大小后存到另一端。每次都是从前开始，把最大或最小的结果放到最后。

插入排序始终是从前面开始，把下一个元素存到前面，不用比较最大最小的结果。

选择排序法

每次从后面找到最小或最大的数，进行位移排序。

数组 int [] array = [11,23];

第一位 i=0

最小值下标 minIndex = 0，最小值 min=11

从后面查找比 11 小的数，找到第下标位 8，值为1，

进行交换,交换后 [1,11,23];

第二位 i=1，

最小值下标 minIndex = 1，最小值 min=39,

从后面查找比 39 小且最小的数，找到下标为 13，值为 5，

进行交换，交换后 [1,23];

        )
            {
                int min = array[i];     //设定第i位为最小值
                int minIndex = i;       最小值下标
                int j = i; j < array.Length; j++)  从第i为开始找出最小的数
                {
                    if (array[j] < array[minIndex])     重新存储最小值和下标
                    {
                        min = array[j];
                        minIndex = j;
                    }
                }

                if (array[i] != array[minIndex])        如果到比第i为更小的数，则发生交换。找不到则不改变
                {
                    array[minIndex] = array[i];
                    array[i] = min;
                }
            }
        }