C#算法——排序（冒泡排序、选择排序、快速排序、特殊条件排序）

将数组里的数字进行排序的几种方法

目录

1、冒泡排序

2、选择排序

3、快速排序

4、特殊条件排序

---

1、冒泡排序

思想是相邻的元素两两比较，较大的数下沉，较小的数冒起来，这样一趟比较下来，最大(小)值就会排列在一端。整个过程如同气泡冒起，因此被称作冒泡排序。
冒泡排序的步骤是比较固定的：

1>比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2>每趟从第一对相邻元素开始，对每一对相邻元素作同样的工作，直到最后一对。
3>针对所有的元素重复以上的步骤，除了已排序过的元素(每趟排序后的最后一个元素)，直到没有任何一对数字需要比较。

————————————————
原文链接：https://blog.csdn.net/m0_37741420/article/details/106981276 

代码：

            Console.WriteLine("\n冒泡排序");

            int[] arr = new int[5] { 2, 5, 8, 4, 0 };

            for (int k = 0; k < arr.Length; k++)
            {
                for (int j = 0; j < arr.Length - 1; j++)
                {
                    for (int i = 0; i < arr.Length - 1 - j; i++)
                    {
                        if (arr[i] > arr[i + 1])
                        {
                            int temp1 = arr[i];
                            arr[i] = arr[i + 1];
                            arr[i + 1] = temp1;
                        }
                    }
                }
                Console.Write(" " + arr[k]);
            }

2、选择排序

选择排序的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，继续放在起始位置直到未排序元素个数为0。

选择排序的步骤：

1>首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
2>再从剩余未排序元素中继续寻找最小（大）元素，然后放到未排序序列的起始位置。
3>重复第二步，直到所有元素均排序完毕。

————————————————
原文链接：https://blog.csdn.net/m0_37741420/article/details/106981276 

代码：

           Console.WriteLine("\n选择排序");

            int[] arr2 =  { 2, 5, 8, 4, 0 };

            for (int j = 0; j < arr2.Length; j++)
            {
                int minNum = arr2[j], minIndex = j;
                for (int i = j; i < arr2.Length; i++)
                {
                    if (arr2[i] < minNum)
                    {
                        minNum = arr2[i];
                        minIndex = i;
                    }
                    int temp1 = arr2[j];
                    arr2[j] = arr2[minIndex];
                    arr2[minIndex] = temp1;
                }
            }
            for (int i = 0; i < arr2.Length; i++)
            {
                Console.Write(" " + arr2[i]);
            }

3、快速排序

快速排序的思想是：每趟排序时选出一个基准值，然后将所有元素与该基准值比较，并按大小分成左右两堆，然后递归执行该过程，直到所有元素都完成排序。

快速排序的步骤如下：

1>先从数列中取出一个数作为基准数。
2>分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3>再对左右区间重复第二步，直到各区间只有一个数。
————————————————
原文链接：https://blog.csdn.net/m0_37741420/article/details/106981276

 代码：

        //快速排序
        int[] array = { 1, 3, 2, 8, 5 };

        private void QuickSort(int[] array, int begin, int end)
        {
            if (begin > end)
            {
                return;
            }

            int temp = array[begin]; //选定基准数
            int i = begin; //头索引
            int j = end; //尾索引
            while (i != j) //在头索引不等于尾索引时
            {
                while (array[j] >= temp && j > i)
                {
                    j--;
                } //从尾部开始找到比基准数小的数为止

                while (array[i] <= temp && j > i)
                {
                    i++;
                } //从头部开始找到比基准数大的数为止

                if (j > i)
                {
                    (array[i], array[j]) = (array[j], array[i]); //交换找到的两个数的位置
                }
            }

            //再把基准数换到中间来，
            array[begin] = array[i];
            array[i] = temp;
            //这样就做到了，比基准数大的数全放到它的右边，小于它的数全放到它的左边（升序）。
            
            //最后把已经分好的两部分，递归上述过程
            QuickSort(array, begin, i - 1);
            QuickSort(array, i + 1, end);
        }
    }

4、特殊条件排序

     条件：按照扑克牌顺序排序（2最大，1第二大，3~13依次排）

     要求：把数字放进一个ArrayList数组，1~13数字不能重复，写一个方法来排序。

    class Program
    {
        static void Main(string[] args)
        {                       
            Random r = new Random();
            ArrayList al = new ArrayList();

            int k = 0;
            do
            {
                k = r.Next(1, 14);
                if (!al.Contains(k))
                {
                    al.Add(k);
                }
            } while (al.Count < 13); //随机数字放进数组

            Console.WriteLine("排序前");

            foreach (object item in al)
            {
                Console.Write(" " + item);
            }//排序前把ArrayList里的数字都打印出来

            Sort(al);//调用方法进行排序
        }


        public static void Sort(ArrayList al)
        {
            Console.WriteLine("\n升序排序后");

            for (int j = 0; j < al.Count - 1; j++)
            {
                for (int i = 0; i < al.Count - 1 - j; i++)
                {
                    if (Collation((int)al[i],(int)al[i + 1])) 
                    //调Collation用方法进行排序，这里是升序；如果要降序，把参数互换即可

                    //这里因为用了ArrayList 进行比较的时候需要进行强制转换
                    //当把 值类型 数据放进 ArrayList 会有一个拆装箱的过程，浪费性能
                    //我这里是正好学到ArrayList,就用一下
                    //这里最好应该用 List<int>泛型容器 就不会有拆装箱的问题了
                    {
                        int temp = (int)al[i];
                        al[i] = (int)al[i + 1];
                        al[i + 1] = temp;
                    }
                }
            } //这里用到的是冒泡排序
            for (int i = 0; i < al.Count; i++)
            {
                Console.Write(" " + al[i]);
            }//打印结果
        }


        public static bool Collation(int a,int b) //collation 排序规则
        {
            if (a == 2)
            {
                return true;
            }
            else if (b == 2)
            {
                return false;
            }
            else if (a == 1)
            {
                return true;
            }
            else if(b == 1)
            {
                return false;
            }
            return a > b;
        } //按要求逐层排序，2和1最大

    }