C#经典算法：冒泡与选择排序详解

#C#学习笔记

            // 经典算法

            // 1. 冒泡排序
            //  原理： 从前往后，相邻的两个元素两两比较，小的换到前面，大的换到后面，直到找到这轮循环中最大的数
            //        每一轮循环都会确定出该轮循环中最大的那个数，直到所有数字排好顺序
            //  图示：  https://www.runoob.com/wp-content/uploads/2019/03/bubbleSort.gif
            //  规律： n个数字最少要循环n-1轮   每一轮中都要交换 n-i次

            /*
                for ( int i = 0; i < n - 1; i++ )    // 外重循环控制循环轮数
                {  
                    for( int j=0; j < n - 1 - i ;j++ )  // 内重循环控制比较次数
                    { 
                        // 判断条件   从小到大排序    大的排后
                        if( arr[j] > arr[j+1] )  // 如果相邻的数，前面的比后面的大
                         {
                             // 使用交换算法，将小的数换到前面，大的换到后面
                             int temp = arr[j]; 
                             arr[j] = arr[j+1];
                             arr[j+1] = temp;
                         }
                    }
                }
            */

            /*
            int[] ints = { 2, 6, 1, 77, 52, 25, 7 };

            for (int i = 0; i < ints.Length-1; i++)    // 外重循环控制循环轮数
            {
                for (int j = 0; j < ints.Length - 1 - i; j++)  // 内重循环控制比较次数
                {
                    // 判断条件   从小到大排序    大的排后
                    if (ints[j] > ints[j + 1])  // 如果相邻的数，前面的比后面的大
                    {
                        // 使用交换算法，将小的数换到前面，大的换到后面
                        int temp = ints[j];
                        ints[j] = ints[j + 1];
                        ints[j + 1] = temp;
                    }
                }
            }

            foreach (var item in ints)
            {
                Console.WriteLine(item);
            }

            */

            //  2. 选择排序  
            //  原理： 从前往后，拿当前索引所在元素与后续元素一一比较，当找到比当前索引所在元素值小时，交换元素值
            //         然后继续使用当前索引所在的新元素与后续元素比较，直接全部比较完成，从而确定该轮循环结束时，
            //         索引所在元素值为最小值，每一轮循环结束时都会确定出一个索引对应的元素为该轮的最小值，直到所
            //         有数字排好顺序
            //  图示：https://www.runoob.com/wp-content/uploads/2019/03/selectionSort.gif
            //  规律： 每次交换前，将当前索引最为临时的最小值所在索引，后续比较中，每确定出比临时的最小值所在索引
            //         的值还小的值时，就将其索引值存为临时的最小值所在索引，拿其对应的值与后续元素继续进行比较，
            //         直到全部比较完成，就可以确定该索引为最小值所在索引，再将该索引对应的值与当前索引对应的值进
            //         行交换，就可以完成当前轮次最小值的排序操作

            int[] ints1 = { 2, 6, 1, 77, 52, 25, 7 };
            for(int i=0; i<ints1.Length-1;i++)  // n个索引，只需要确定n-1个顺序就好了
            {
                int tempMin = i;  // 将当前索引暂定为最小值所在索引

                for (int j = i+1; j < ints1.Length; j++) // 拿后续索引上的值与当前索引所在的值进行比较 
                {
                    if (ints1[tempMin] > ints1[j])  // 如果后续索引对应的值比临时最小值索引对应的值还小
                        tempMin = j; // 将该值对应的索引替换为临时最小值索引
                } // 循环结束，就可以确定出最小值所在的索引了

                // 将最小值与当前索引对应的值进行交换，从而确定为该索引上的最小值
                int temp=ints1[i];
                ints1[i] = ints1[tempMin];
                ints1[tempMin] = temp;
            }

            foreach (var item in ints1)
            {
                Console.WriteLine(item);
            }