C#中常见的数组（一维）排序算法

选择排序:

       排序轮数：元素个数-1

       算法逻辑：每一轮获取当前轮的第一个元素，依次和其后的各个元素进行比较，按照排序规则进

         行相应的元素值交换。每一轮排序完成，会找到当前轮的一个最值存储在第一个元素中，下一轮比较

       忽略该元素

            例：8  3 6  5  1   从小到大排序

             * 第一轮：

                1  8 6  5  3   

             * 第二轮

                    3 8  6  5

             * 第三轮

                        5 8  6

             * 第四轮

                            6 8

 

选择排序写法：

            //外层循环控制排序轮数

            for (int i = 0; i < array.Length- 1; i++)

          {

                //内层循环控制每一轮的内部比较操作

                for (int j= i+ 1; j<array.Length; j++)

                   {

                    //从小到大排序，如果第一个元素值比后面的大则交换

                    if (array[i]> array[j]) {

                        int tmp= array[i];

                        array[i]= array[j];

                        array[j] = tmp;

                    }

             } 

冒泡排序：

      排序轮数:元素个数-1

      算法逻辑：每一轮从首元素开始依次比较相邻的两个元素，按照排序规则进行相应交换。每一轮

            比较完成找出当前轮的最后一个元素存储一个最值，下一轮比较忽略该元素

       例：1 5  6  8 4  从大到小排序

             * 第一轮：

                   5 6  8  4  1

             * 第二轮:

                   6 8  5  4

             * 第三轮:

                   8 6  5

             * 第四轮：

                   8 6

            

冒泡排序写法：

            //外层循环控制轮数

            for (int i = 0; i < array.Length- 1; i++)

           {

                //内层循环控制每一轮的内部比较

                //每一轮都从首元素开始，相邻两个依次比较，循环终止条件为元素个数-1并且每一轮完成还要额

                   外去掉一个

                for (int j = 0; j < array.Length - 1- i;j++)

                {

                    if(array[j] < array[j +1])

                    {

                        int tmp= array[j];

                        array[j] = array[j +1];

                        array[j + 1] = tmp;

                    }

                }

            }

插入排序：

  排序轮数：元素个数-1

   算法逻辑：插入排序是每一轮选定一个值，然后来追踪该值找到其在初始所在元素左侧最合理的位置。第一轮找到第二个元素的值作为要追踪的值，向左查找最合理位置。以后各轮依次向后后移找到初始元素值，进行操作

              15  6 8  9 14  从小到大排序

             * 第一轮

               * 6  15 8  9  14  起始下标：1  追踪的值：6

             * 第二轮

               * 6  8 15  9  14  起始下标：2  追踪的值：8

             * 第三轮

               * 6  8 9  15  14  起始下标：3  追踪的值：9

             * 第四轮

               * 6  8 9  14  15 起始下标：4 追踪的值：14  

插入排序写法：

//外层循环控制轮数

            for (int i = 0; i < array.Length- 1; i++)

            {

                //记录内层循环要追踪值的初始下标， 其后用其记录追踪值的所在下标

                int index = i+ 1;

                //内层循环控制每一轮的内部比较

                for (int j = index - 1; j >=0; j--)

                {

                    //从小到大排序，后面的比前面的小就交换

                    if (array[index] <array[j])

                    {

                        int tmp= array[index];

                        array[index] =array[j];

                        array[j] = tmp;

                        //若交换，则记录追踪值的新的所在位置

                        index = j;

                    }

                }

            }