using System;
namespace ConsoleApp2
{
    class Program
    {
        public static void Main(string[] args)
        {
            //冒泡排序的核心思想就是两两交换，谁小谁去前面
            //那么就剩下循环几次的问题
            int[] arr = new int[] { 64, 57, 25, 46, 95, 12, 35, 47, 55 };
           
            for (int i = 0; i <arr.Length ; i++)//外层循环计数，每减一，就运算一次
            {
                for(int j = 0; j < arr.Length-1; j++)//内层循环
                {
                    if (arr[j] > arr[j + 1])//当前者大于后者，就交换二者的值，但是不是全部循环
                    {
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
        }
    }
}

2、插入排序

插入排序是较为简单的一个，将一个原来的数组，切片，然后一个个插入新的数组，当然每次插入新的元素，都要进行一次排序。

优点：

就是交换次数要减少很多，运算量也少了很多。

?实现

using System;
namespace ConsoleApp2
{
    class Program
    {
        public static void Main(string[] args)
        {
            
            int[] arr = new int[] { 64, 57, 25, 46, 95, 12, 35, 47, 55 };
           //定义数组
            for (int i = 0; i <arr.Length ; i++)
                //循环访问数组中的元素
            {
                int temp = arr[i];
                //定义一个int变量，并使用获得数组元素值赋值
                int j=i;
                while ((j > 0) && (arr[j-1]>temp))
                 //判断数组中的原数是否大于获得的所有元素？
                {
                    arr[j] = arr[j - 1];
                   //如果是,则将最后一个元素的值提前

                    --j;
                }
                arr[j] = temp;
                //最后将int变量存储的值赋值给最后一个元素。
            }
            Console.WriteLine("循环排序后结果的为：");
            foreach (int n in arr)
                //循环打印
                Console.WriteLine("{0}", n + "");
            Console.WriteLine();
        }
    }
}

3、选择排序

基本原理

现在原有的数组上，进行排序，找到那个需要排序的，比如原数组最小或者最大的，把他挑出来放到新数组中，然后依次继续。

优点：

就是交换次数要减少很多，运算量也少了很多。

实现

using System;
namespace ConsoleApp2
{
    class Program
    {
        public static void Main(string[] args)
        {
           
            int[] arr = new int[] { 64, 57, 25, 46, 95, 12, 35, 47, 55 };
           //定义数组
            for (int i = 0; i <arr.Length -1; i++)
                //循环访问数组中的元素
            {
                int min = 0;//先定义min
                min = i;
                //为定义的数组下标赋值
                for(int j=i+1;j<arr.Length;j++)
                    //循环访问数组中的元素值
                {
                    if(arr[j] < arr[min])
                        //判断相邻元素两个元素值的大小
                    {
                        min = j;
                    }
                    int temp = arr[min];
                    //定义一个int变量，用来存储比较大的数组元素值
                    arr[min]=arr[i];
                    //交换小的下标位置
                    arr[i] = temp;
                    //将int变量中存储的较大的数组元素值向后移
                }
            }
            Console.WriteLine("循环排序后结果的为：");
            foreach (int n in arr)
                //循环打印
                Console.WriteLine("{0}", n + "");
            Console.WriteLine();
        }
    }
}

4、希尔排序

该排序书上未讲解，引用前辈方案。

以下方式均为摘抄

希尔排序利用了插入排序的一个特点来优化排序算法，插入排序的这个特点就是：当数组基本有序的时候，插入排序的效率比较高。比如对于下面这样一个数组：

int[] array = { 1, 0, 2, 3, 5, 4, 8, 6, 7, 9 };

插入排序的输出如下：

可以看到，尽管比较的趟数没有减少，但是交换的次数却明显很少。希尔排序的总体想法就是先让数组基本有序，最后再应用插入排序。具体过程如下：假设有数组int a[] = {42,20,17,13,28,14,23,15}，不失一般性，我们设其长度为length。

第一趟时，步长step = length/2 = 4，将数组分为4组，每组2个记录，则下标分别为(0,4)(1,5)(2,6)(3,7)；转换为数值，则为{42,28}, {20,14}, {17,23}, {13,15}。然后对每个分组进行插入排序，之后分组数值为{28,42}, {14,20}, {17,23}, {13,15}，而实际的原数组的值就变成了{28,14,17,13,42,20,23,15}。这里要注意的是分组中记录在原数组中的位置，以第2个分组{14,20}来说，它的下标是(1,5)，所以这两个记录在原数组的下标分别为a[1]=14;a[5]=20。

第二趟时，步长 step = step/2 = 2，将数组分为2组，每组4个记录，则下标分别为(0,2,4,6)(1,3,5,7)；转换为数值，则为{28,17,42,23}, {14,13,20,15}，然后对每个分组进行插入排序，得到{17,23,28,42}{13,14,15,20}。此时数组就成了{17,13,23,14,28,15,42,20}，已经基本有序。

第三趟时，步长 step=step/2 = 1，此时相当进行一次完整的插入排序，得到最终结果{13,14,15,17,20,23,28,42}。