class SortArrange    {        public struct SqlList        {           public int[] data;           public int length;        }        private static void Swap(ref SqlList L, int i, int j)        {            int temp = L.data[i];            L.data[i] = L.data[j];            L.data[j] = temp;        }        /// <summary>        /// 最基础的排序算法，效率最差，不算标准的冒泡排序算法，不满足“两两相邻要素比较”，只是让每一个关键字比较交换得出；        /// </summary>        /// <param name="L"></param>        public static int BubbleSortBase(SqlList L)        {            int count = 0;            for(int i=0;i<L.length;i++)            {                for (int j = i + 1; j < L.length; j++)                {                    if (L.data[i] > L.data[j])                    {                        Swap(ref L, i, j);                        count++;                    }                }            }            return count;        }        /// <summary>        /// 标准的冒泡排序，实现两两比较互换，效率高于基础排序算法        /// </summary>        /// <param name="L">排序数组</param>        public static int BubbleSortStandard(SqlList L)        {            int count = 0;            for (int i = 0; i < L.length; i++)            {                for (int j = L.length - 2; j >= i; j--)                {                    if (L.data[j] > L.data[j + 1])                    {                        Swap(ref L, j, j + 1);                        count++;                    }                }            }            return count;        }        /// <summary>        /// 用flag标志判断在已经有序的情况下进行不需要的判断        /// </summary>        /// <param name="L">排序数组</param>        public static int BubbleSortImprove(SqlList L)        {            int count = 0;            bool flag = true;            for (int i = 0; i < L.length&&flag; i++)            {                flag = false;                for (int j = L.length - 2; j >= i; j--)                {                    if (L.data[j] > L.data[j + 1])                    {                        Swap(ref L, j, j + 1);                        flag = true;                        count++;                    }               }            }            return count;        }        /// <summary>        /// 简单选择排序，算法类似基础排序算法，减少了交换次数，尽管没提高比较次数，但是减少了多余的交换        /// 性能上略优于冒泡排序，时间复杂度为O(n2)        /// </summary>        /// <param name="L"></param>        public static int SelectSort(SqlList L)        {            int i, j, min,count=0;            for (i = 0; i < L.length; i++)            {                min = i;                for (j = i + 1; j < L.length; j++)                {                    if (L.data[min] > L.data[j])                    {                        min = j;                    }                }                if (min != i)                {                    Swap(ref L, i, min);                    count++;                }            }            return count;        }        /// <summary>        /// 直接插入排序，默认第一个数是排序好的，只是插入有序数列的左右边选择问题，性能优于冒泡排序和选择排序        /// 需要比较次数：(n+2)(n-1)/2，移动的次数：(n+4)(n-1)/2，时间复杂度为O(n2)        /// </summary>        /// <param name="L"></param>        public static int StraightInsertSort(SqlList L)        {            int i, j,temp,count=0;            for (i = 1; i < L.length; i++)            {                if (L.data[i] < L.data[i - 1])                {                    temp = L.data[i];                    for (j = i - 1; j >= 0 && L.data[j] > temp; j--)                    {                        L.data[j + 1] = L.data[j];                        count++;                    }                    L.data[j + 1] = temp;                }            }            return count;        }    }