【转载】C# 改良后的冒泡排序、快速排序

        /// <summary>
        /// 原始冒泡方法，逐个比较
        /// </summary>
        /// <param name="nums"></param>
        /// <param name="total"></param>
        /// <returns></returns>
        public static int[] OrderNum(int[] nums, ref int total)
        {
            //原始冒泡法
            for (int i = 0; i < nums.Length; i++)
            {
                for (int j = 0; j < nums.Length - 1 - i; j++)
                {
                    if (nums[j] < nums[j + 1])
                    {
                        int tempNum = nums[j];
                        nums[j] = nums[j + 1];
                        nums[j + 1] = tempNum;
                    }
                    total++;
                }
            }

            return nums;
        }


        /// <summary>
        /// 改良后的冒泡排序，如果没有任何交换时，表示数据已经是按顺序
        /// </summary>
        /// <param name="nums"></param>
        /// <param name="total"></param>
        /// <returns></returns>
        public static int[] OrderNumNew(int[] numsNew, ref int totalNew)
        {
            //改良冒泡法
            for (int i = 0; i < numsNew.Length; i++)
            {
                bool flag = false;
                for (int j = 0; j < numsNew.Length - 1 - i; j++)
                {
                    if (numsNew[j] < numsNew[j + 1])
                    {
                        int tempNum = numsNew[j];
                        numsNew[j] = numsNew[j + 1];
                        numsNew[j + 1] = tempNum;
                        flag = true;    //如果发生交换，就标识一下
                    }
                    totalNew++;
                }

                if (flag == false) { break; }
            }
            return numsNew;
        }
    }

 https://www.cnblogs.com/pettyColorcat/p/10861302.html

快速排序算法说明：

原始数组L1，从中任意选择一个基准数F（一般选择第1个），小于F的数据放在F的左边记为数组minList，大于F的数据放在F的右边记为数组maxList。那么

L1=minList+F+maxList

然后对minList和maxList再做这样的操作，直到minList和maxList中的元素个数为1或者0的时候停止

public class Extend :List<int>
    {
        private static Extend k = new Extend();
        
        public static Extend operator +(Extend L1, Extend L2)
        {
            if (L1.Count == 1) k.Add(L1[0]);
            if (L2.Count == 1) k.Add(L2[0]);
            return k;
        }
    }

        static Extend QuickSort2(Extend nums)
        {
            if (nums.Count < 2)
            {
                return nums;
            }
            else
            {
                Extend minList = new Extend();//小于基准数的集合
                Extend maxList = new Extend();//大于基准数的集合
                int f = nums[0];
                for (int i = 1; i < nums.Count; i++)
                {
                    if (nums[i] <= f) minList.Add(nums[i]);
                    else maxList.Add(nums[i]);
                }
                return QuickSort2(minList) + new Extend() { f} + QuickSort2(maxList);//递归，并且使用+运算符
            }
        }

 

转载于:https://www.cnblogs.com/slyzly/articles/7985880.html