C#快速排序算法

对10个数字用快速排序算法排序

算法思想： 二分法 + 递归调用

• 第一趟：用第一个数作为基准，从最后一个数往前找一个数a，从基准数之后往后找一个数b，如果后面的数比基准数小，前面的数比基准数大，就将a和b交换。否则继续往前往后找，直到两个数相遇，把这个数和基准数调换，旧的基准数将数列一分为二。相遇的数成为新的基准数。
• 第二趟：在分段之后的数列中继续第一趟的操作，新的基准数又将新的数列分段。
• 第三趟：以此类推，直到第一次二分法之后的左边数字都排列好，再排列好右边的部分。。。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ArithmeticFastSort
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> mylist = new List<int>();
            mylist.Add(6);
            mylist.Add(1);
            mylist.Add(2);
            mylist.Add(7);
            mylist.Add(9);
            mylist.Add(3);
            mylist.Add(4);
            mylist.Add(5);
            mylist.Add(10);
            mylist.Add(8);

            for (int i = 0; i < mylist.Count; i++)
            {
                Console.Write(mylist[i] + " ");
            }

            Console.WriteLine();
            Console.WriteLine("输出快速排序后的：");
            FastSortFuc(mylist,0,mylist.Count-1);
            for (int i = 0; i < mylist.Count; i++)
            {
                Console.Write(mylist[i] + " ");
            }
            
            Console.ReadKey();
        }

        
        public static void FastSortFuc(List<int> list, int first, int last)    //放一个Array进去，输出一个排序好的数组   需要输入这个数列的首位元素
        {
         //   int middle = (first + last) / 2;
            int key = list[first];             //first  last都是下标
            int i = first;
            int j = last;
            //list[0];                      //6 1 2 7 9 3 4 5 10 8       6 1 2 5 4 3 9 7 10 8   3 1 2 5 4 6 9 7 10 8

            if (first >= last)              //2 1 3 5 4 6 9 7 10 8      1 2 3 5 4 6 9 7 10 8   1 2 3 4 5 6 9 7 10 8
            {
                return;                     //1 2 3 4 5 6 9 7 8 10    1 2 3 4 5 6 8 7 9 10   1 2 3 4 5 6 7 8 9 10
            }
            while (i < j)
            {
                while (i < j && key < list[j])
                {
                    j--;
                }

                if (i >= j)
                {
                    list[i] = key;
                    break;
                }

                list[i] = list[j];

                while (i < j && key >= list[i])
                {
                    i++;
                }
                if (i >= j)
                {
                    list[i] = key;
                    break;
                }

                list[j] = list[i];
            }

            list[i] = key;

            //递归调用
            FastSortFuc(list, first, i - 1);
            FastSortFuc(list, i + 1, last);
        }
    }
}

输出结果：