排序算法--------冒泡排序

冒泡排序是是简单排序算法之一，通过比较相邻两个元素，当第一个元素比第二个元素大的时候就把第一个元素往后移(升序，同理可以达成降序)，每趟排序后，必定有一个最大或者最小值在最后。

第一种冒泡排序

        static void BubbleSort<T>(T[] arr)where T : IComparable<T>
        {
            //决定排序的趟数
            for(int i = 0; i < arr.Length; i++)
            {
                //每当排过一次减少I个元素，I后以排序完
                for(int j=0;j<arr.Length-i-1;j++)
                {
                    if(arr[j].CompareTo(arr[j+1])>0)
                    {
                        //交换算法
                        var temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                    
                }
                Print(arr);
            }
        }

这种冒泡排序,能够进行进一步优化，因为排序完成后，还在排序。所以能够在外层定义一个变量来表示其是否排序，这里用bool值

    static void BubbleSort<T>(T[] arr) where T : IComparable<T>
        {
            //决定排序的趟数
            for (int i = 0; i < arr.Length; i++)
            {
                //定义一个用来确定是否正在排序
                var Sorting = false;
                //每当排过一次减少I个元素，I后以排序完
                for (int j = 0; j < arr.Length - i - 1; j++)
                {
                    if (arr[j].CompareTo(arr[j + 1]) > 0)
                    {
                        //交换算法
                        var temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                        Sorting = true;
                    }

                }
                if(Sorting==false)
                {
                    break;
                }
                Print(arr);
            }
        }

冒泡排序还有第三种优化方法，排序完后,当后方已经排序完成后，不需要再继续进行比较.

        static void BubbleSort<T>(T[] arr)where T : IComparable<T>
        {
            //记录最后一次的交换位置
            int lastExChangeIndex = 0;
            //无序数列的边界，每次比较到这里就停止
            int sortBorder = arr.Length - 1;
            //决定走过的趟数
            for(int i=0;i<arr.Length;i++)
            {
                var Sorting = false;
                //决定比较的次数，每次排序后 必定有一个最大的在最后面 所以每走一趟-i
                for (int j=0;j< sortBorder; j++)
                {   
                    if(arr[j].CompareTo(arr[j+1])>0)
                    {
                        //交换算法
                        var temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                        //排序中
                        Sorting=true;
                        //把无序数列的边界更新为最后一次交换元素的位置
                        lastExChangeIndex = j;
                    }
                }
                sortBorder = lastExChangeIndex;
                //如果排序已完成就退出
                if(Sorting==false)
                {
                    break;
                }
                Print(arr);
            }
        }