C#数据结构与算法学习笔记快速排序_随机化三向切分-优快云博客

本文链接：https://blog.youkuaiyun.com/Mr_Tfos/article/details/117438898

本文是关于C#中快速排序的学习笔记，包括基本的快速排序算法、随机化快速排序以防止有序数组导致的栈溢出问题，以及三向切分的随机化快速排序来应对数据分布不均匀和重复数据的排序挑战。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

快速排序

1．先从数列中取出一个数作为基准数。
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3．再对左右区间重复第二步，直到各区间只有一个数。

    class QuickSort1
    {
        public static void Sort(int[] arr)
        {
            int n = arr.Length;
            Sort(arr, 0, n - 1);
        }

        private static void Sort(int[] arr,int l,int r)
        {
            //对小规模的数组使用插入排序，避免频繁的递归调用
            if (r - l + 1 <= 15)
            {
                InsertSort.Sort1(arr, l, r);
                return;
            }

            int v = arr[l]; //标定元素v

            int j = l; // arr[l+1...j] < v  arr[j+1...i-1] > v

            //往对应区间填充元素
            for (int i = l+1; i <= r; i++)
            {
                if(arr[i] < v)
                {
                    j++;
                    Swap(arr, i, j);
                }
            }

            //将标定元素放到合适的位置
            Swap(arr, l, j);

            Sort(arr, l, j - 1);  //将左半边arr[l...j-1]排序
            Sort(arr, j + 1, r);  //将右半边arr[j+1...r]排序
        }

        private static void Swap(int[] arr,int i,int j)
        {
            int e = arr[i];
            arr[i] = arr[j];
            arr[j] = e;
        }
    }

对比测试：

    class Program
    {
        static void Main(string[] args)
        {
            int N = 1000000;
			
            Console.WriteLine("测试随机数组：");
            int[] a = TestHelper.RandomArray(N, N);
            int[] b = TestHelper.CopyArray(a);

            TestHelper.TestSort("MergeSort2", a);
            TestHelper.TestSort("QuickSort1", b);

            Console.Read();
        }
    }

随机化快速排序

对于有序数组，快速排序的算法会导致计算的时间复杂度为O(n²)，计算深度太深，从而导致栈溢出。所以需要对数组进行随机化处理：

    //随机化的快速排序 O（nlogn）
    class QuickSort2
    {
        //随机类全局变量，不能写在方法内作为局部变量。
        private static Random rd = new Random();

        public static void Sort(int[] arr)
        {
            int n = arr.Length;
            Sort(arr, 0, n - 1);
        }

        private static void Sort(int[] arr, int l, int r)
        {
            if (r - l + 1 <= 15)
            {
                InsertSort.Sort1(arr, l, r);
                return;
            }

            //在[l...r]的范围随机一个位置
            int p =l + rd.Next(r - l + 1);

            //和第一个元素交换作为标定元素，这一步对有序性很强的数组排序有很好的优化。
            Swap(arr, l, p);

            int v = arr[l];

            int j = l; // arr[l+1...j] < v  arr[j+1...i-1] > v

            for (int i = l + 1; i <= r; i++)
            {
                if (arr[i] < v)
                {
                    j++;
                    Swap(arr, i, j);
                }
            }

            Swap(arr, l, j);
            Sort(arr, l, j - 1);
            Sort(arr, j + 1, r);
        }

        private static void Swap(int[] arr, int i, int j)
        {
            int e = arr[i];
            arr[i] = arr[j];
            arr[j] = e;
        }
    }

对比测试：

    class Program
    {
        static void Main(string[] args)
        {
            int N = 1000000;

            Console.WriteLine("测试随机数组：");
            int[] a = TestHelper.RandomArray(N, N);
            int[] b = TestHelper.NearlyOrderedArray(N,100);

            TestHelper.TestSort("QuickSort2", a);
            TestHelper.TestSort("QuickSort2", b);

            Console.Read();
        }
    }

三向切分的随机化快速排序

对于左右分布不均匀的快速排序，递归的深度必然很深，所以很容易造成栈溢出。

例如测试0~10范围的数，随机生成100万个：

    class Program
    {
        static void Main(string[] args)
        {
            int N = 1000000;

            int[] a = TestHelper.RandomArray(N, 10);

            TestHelper.TestSort("QuickSort2", a);

            Console.Read();
        }
    }

结果抛出栈溢出：

可以使用三向切分快速排序完成重复数据过多的排序：
在这里插入图片描述

    //三向切分的快速排序
    class QuickSort3
    {
        private static Random rd = new Random();

        public static void Sort(int[] arr)
        {
            int n = arr.Length;
            Sort(arr, 0, n - 1);
        }

        private static void Sort(int[] arr,int l ,int r)
        {
            //对小规模的数组使用插入排序，避免频繁的递归调用
            if (r - l + 1 <= 15)
            {
                InsertSort.Sort1(arr, l, r);
                return;
            }

            //随机化处理，对排序有序性很强的数组会得到很大的优化
            int p = l + rd.Next(r - l + 1);

            Swap(arr, l, p);

            int v = arr[l];    //标定元素v

            int lt = l;        // arr[l+1...lt] < v
            int gt = r + 1;    // arr[gt...r] > v
            int i = l + 1;     // arr[lt+1...i-1] == v

            //往三个区间填充元素
            while(i < gt)
            {
                if(arr[i] < v)
                {
                    lt++;
                    Swap(arr, i, lt);
                    i++;
                }
                else if(arr[i] > v)
                {
                    gt--;
                    Swap(arr, i, gt);
                }
                else //arr[i]==v
                {
                    i++;
                }
            }

            //跳出while循环填充完毕后，把标定元素放到合适位置
            Swap(arr, l, lt);

            Sort(arr, l, lt - 1);  //将左半部分arr[l...lt-1]排序
            Sort(arr, gt, r);      //将右半部分arr[gt...r]排序

        }

        private static void Swap(int[] arr,int i,int j)
        {
            int e = arr[i];
            arr[i] = arr[j];
            arr[j] = e;
        }
    }

对比测试：

    class Program
    {
        static void Main(string[] args)
        {
            int N = 1000000;

            Console.WriteLine("测试随机数组： ");
            int[] a = TestHelper.RandomArray(N, N);
            int[] b = TestHelper.CopyArray(a);
            int[] c = TestHelper.CopyArray(a);
            int[] d = TestHelper.CopyArray(a);
            TestHelper.TestSort("QuickSort1", a);
            TestHelper.TestSort("QuickSort2", b);
            TestHelper.TestSort("QuickSort3", c);
            TestHelper.TestSort("MergeSort2", d);
            Console.WriteLine();

            Console.WriteLine("测试近乎有序数组： ");
            a = TestHelper.NearlyOrderedArray(N, 100);
            b = TestHelper.CopyArray(a);
            c = TestHelper.CopyArray(a);
            TestHelper.TestSort("QuickSort2", a);
            TestHelper.TestSort("QuickSort3", b);
            TestHelper.TestSort("MergeSort2", c);
            Console.WriteLine();

            Console.WriteLine("测试大量重复元素数组： ");
            a = TestHelper.RandomArray(N, 10);
            b = TestHelper.CopyArray(a);
            TestHelper.TestSort("QuickSort3", a);
            TestHelper.TestSort("MergeSort2", b);

            Console.Read();
        }
    }