C# 如何使快速排序算法按升序和降序对数组进行排序？

目前，我的快速排序算法在案例1中按升序对数组进行排序，但我希望这样，当用户选择选项2（案例2）时，它会按降序对数组进行排序。我是否必须为每种情况创建两个单独的算法？还是有更简单、更有效的方法

谢谢你的帮助

  static void Main(string[] args)
    {
        Console.WriteLine("Analysis of Seismic Data.\n");



        Console.WriteLine("Selection of Arrays:");
        //Display all the options.
        Console.WriteLine("1-Year");
        Console.WriteLine("2-Month");
        Console.WriteLine("3-Day");
        Console.WriteLine("4-Time");
        Console.WriteLine("5-Magnitude");
        Console.WriteLine("6-Latitude");
        Console.WriteLine("7-Longitude");
        Console.WriteLine("8-Depth");
        Console.WriteLine("9-Region");
        Console.WriteLine("10-IRIS_ID");
        Console.WriteLine("11-Timestamp\n\n");

        Console.WriteLine("Use numbers to select options.");
        //Read in user's decision.
        Console.Write("Select which array is to be analysed:");
            int userDecision = Convert.ToInt32(Console.ReadLine());

        //Selected which array is to be analyzed
            switch (userDecision)
            {
                case 1:
                    Console.WriteLine("\nWould you like to sort the Array in Ascending or Descending order?");
                    Console.WriteLine("1-Ascending");
                    Console.WriteLine("2-Descending");
                    //Create another switch statement to select either ascending or descending sort.
                    int userDecision2 = Convert.ToInt32(Console.ReadLine());
                    switch (userDecision2)
                    {
                        case 1:
                        //Here algorithm sorts my array in ascending order by default.
                        QuickSort(Years);
                        Console.WriteLine("Contents of the Ascending Year array: ");
                        foreach (var year in Years)
                        {
                            Console.WriteLine(year);
                        }
                        break;
                        case 2:
                        //How do I sort the same array in Descending order when Option 2 is selected?
                        //QuickSort(Years) Descendingly.
                            Console.WriteLine("Contents of the Descending Year array: ");
                            foreach (var year in Years)
                            {
                                Console.WriteLine(year);
                            }
                            break;

                    }
                    break;
                case 2:
                    Console.WriteLine("\nWould you like to sort the Array in Ascending or Descending order?");
                    Console.WriteLine("1-Ascending");
                    Console.WriteLine("2-Descending");
                    //Create another switch statement to select either ascending or descending sort.
                    int userDecision3 = Convert.ToInt32(Console.ReadLine());
                    switch (userDecision3)
                    {
                        case 1:
                        QuickSort(Years);
                        Console.WriteLine("Contents of the Ascending Month array: ");
                        foreach (var month in Months)
                        {
                            Console.WriteLine(month);
                        }
                        break;
                        case 2:
                        //Same problem, how do I sort it in descending order?
                            Console.WriteLine("Contents of the Descending month array: ");
                        foreach (var month in Months)
                        {
                            Console.WriteLine();
                        }
                        break;
                    }
                    break;


        }

    }
    public static void QuickSort<T>(T[] data) where T : IComparable<T>
    {
        Quick_Sort(data, 0, data.Length - 1);
    }

    public static void Quick_Sort<T>(T[] data, int left, int right) where T : IComparable<T>
    {
        int i, j;
        T pivot, temp;
        i = left;
        j = right;
        pivot = data[(left + right) / 2];
        do
        {
            while ((data[i].CompareTo(pivot) < 0) && (i < right)) i++;
            while ((pivot.CompareTo(data[j]) < 0) && (j > left)) j--;
            if (i <= j)
            {
                temp = data[i];
                data[i] = data[j];
                data[j] = temp;
                i++;
                j--;
            }
        } while (i <= j);
        if (left < j) Quick_Sort(data, left, j);
        if (i < right) Quick_Sort(data, i, right);
    }

static void Main（字符串[]args）
{
Console.WriteLine（“地震数据分析”。\n”）；
Console.WriteLine（“数组的选择：”）；
//显示所有选项。
Console.WriteLine（“1年”）；
Console.WriteLine（“2个月”）；
Console.WriteLine（“3天”）；
控制台写入线（“4次”）；
控制台写入线（“5级”）；
控制台写入线（“6纬度”）；
控制台写入线（“7-经度”）；
控制台写入线（“8深度”）；
控制台写入线（“9区域”）；
控制台写入线（“10-IRIS_ID”）；
Console.WriteLine（“11时间戳\n\n”）；
WriteLine（“使用数字选择选项”）；
//阅读用户的决定。
Write（“选择要分析的数组：”）；
int userDecision=Convert.ToInt32（Console.ReadLine（））；
//选择要分析的阵列
开关（用户决策）
{
案例1：
Console.WriteLine（“\n是否要按升序或降序对数组排序？”）；
控制台写入线（“1-上升”）；
控制台写入线（“2-下降”）；
//创建另一个switch语句以选择升序或降序排序。
int userDecision2=Convert.ToInt32（Console.ReadLine（））；
开关（用户决策2）
{
案例1：
//这里，默认情况下，算法按升序对数组进行排序。
快速排序（年）；
Console.WriteLine（“升序年数组的内容：”）；
foreach（var年，以年为单位）
{
控制台写入线（年）；
}
打破
案例2：
//选择选项2时，如何按降序对同一数组排序？
//快速排序（年）递减。
Console.WriteLine（“递减年份数组的内容：”）；
foreach（var年，以年为单位）
{
控制台写入线（年）；
}
打破
}
打破
案例2：
Console.WriteLine（“\n是否要按升序或降序对数组排序？”）；
控制台写入线（“1-上升”）；
控制台写入线（“2-下降”）；
//创建另一个switch语句以选择升序或降序排序。
int userDecision3=Convert.ToInt32（Console.ReadLine（））；
开关（用户决策3）
{
案例1：
快速排序（年）；
WriteLine（“升序月数组的内容：”）；
foreach（var月，以月为单位）
{
控制台写入线（月）；
}
打破
案例2：
//同样的问题，我如何按降序排序？
WriteLine（“降序月数组的内容：”）；
foreach（var月，以月为单位）
{
Console.WriteLine（）；
}
打破
}
打破
}
}
公共静态void快速排序（T[]数据），其中T:IComparable
{
快速排序（数据，0，数据长度-1）；
}
公共静态void Quick_Sort（T[]数据，int left，int right），其中T:IComparable
{
int i，j；
T轴，温度；
i=左；
j=右；
枢轴=数据[（左+右）/2]；
做
{
while（（数据[i].CompareTo（pivot）<0）和&（ileft））j--；
如果（i添加允许更改比较结果的参数

(data[i].CompareTo(pivot) < 0) 
and 
(pivot.CompareTo(data[j]) < 0)

您可以将快速排序方法更改为接受
IComparer比较器
，然后使用该比较器进行比较

然后，如果需要默认比较顺序，可以使用
Comparer.Default
，也可以使用
Comparer.Create（）
创建自定义（例如反向）比较

可编译示例：

using System;
using System.Collections.Generic;

namespace ConsoleApp1
{
    class Program
    {
        static void Main()
        {
            int[] data = {6, 7, 2, 3, 8, 1, 9, 0, 5, 4};

            QuickSort(data);

            Console.WriteLine(string.Join(", ", data)); // Prints 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

            QuickSort(data, Comparer<int>.Create((a, b) => b.CompareTo(a)));

            Console.WriteLine(string.Join(", ", data)); // Prints 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
        }

        public static void QuickSort<T>(T[] data)
        {
            Quick_Sort(data, 0, data.Length - 1, Comparer<T>.Default);
        }

        public static void QuickSort<T>(T[] data, IComparer<T> comparer)
        {
            Quick_Sort(data, 0, data.Length - 1, comparer);
        }

        public static void Quick_Sort<T>(T[] data, int left, int right, IComparer<T> comparer)
        {
            int i, j;
            T pivot, temp;
            i = left;
            j = right;
            pivot = data[(left + right) / 2];
            do
            {
                while ( (comparer.Compare(data[i], pivot) < 0) && (i < right)) i++;
                while ( (comparer.Compare(pivot, data[j]) < 0) && (j > left)) j--;
                if (i <= j)
                {
                    temp = data[i];
                    data[i] = data[j];
                    data[j] = temp;
                    i++;
                    j--;
                }
            } while (i <= j);
            if (left < j) Quick_Sort(data, left, j, comparer);
            if (i < right) Quick_Sort(data, i, right, comparer);
        }
    }
}

使用系统；
使用System.Collections.Generic；
名称空间控制台EAPP1
{
班级计划
{
静态void Main（）
{
int[]数据={6,7,2,3,8,1,9,0,5,4}；
快速排序（数据）；
Console.WriteLine（string.Join（“，”，data））；//打印0、1、2、3、4、5、6、7、8、9
快速排序（数据，Comparer.Create（（a，b）=>b.CompareTo（a））；
Console.WriteLine（string.Join（“，”，data））；//打印9,8,7,6,5,4,3,2,1,0
}
公共静态void快速排序（T[]数据）
{
快速排序（data，0，data.Length-1，Comparer.Default）；
}
公共静态无效快速排序（T[]数据，IComparer比较器）
{
快速排序（数据，0，数据长度-1，比较器）；
}
公共静态void快速排序（T[]数据、左整数、右整数、IComparer比较器）
{
int i，j；
T轴，温度；
using System;
using System.Collections.Generic;

namespace ConsoleApp1
{
    class Program
    {
        static void Main()
        {
            int[] data = {6, 7, 2, 3, 8, 1, 9, 0, 5, 4};

            QuickSort(data);

            Console.WriteLine(string.Join(", ", data)); // Prints 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

            QuickSort(data, Comparer<int>.Create((a, b) => b.CompareTo(a)));

            Console.WriteLine(string.Join(", ", data)); // Prints 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
        }

        public static void QuickSort<T>(T[] data)
        {
            Quick_Sort(data, 0, data.Length - 1, Comparer<T>.Default);
        }

        public static void QuickSort<T>(T[] data, IComparer<T> comparer)
        {
            Quick_Sort(data, 0, data.Length - 1, comparer);
        }

        public static void Quick_Sort<T>(T[] data, int left, int right, IComparer<T> comparer)
        {
            int i, j;
            T pivot, temp;
            i = left;
            j = right;
            pivot = data[(left + right) / 2];
            do
            {
                while ( (comparer.Compare(data[i], pivot) < 0) && (i < right)) i++;
                while ( (comparer.Compare(pivot, data[j]) < 0) && (j > left)) j--;
                if (i <= j)
                {
                    temp = data[i];
                    data[i] = data[j];
                    data[j] = temp;
                    i++;
                    j--;
                }
            } while (i <= j);
            if (left < j) Quick_Sort(data, left, j, comparer);
            if (i < right) Quick_Sort(data, i, right, comparer);
        }
    }
}

    using System;
    using System.Collections.Generic;
    using System.Threading;

   namespace Test1
     {

            class Program
   {
    static void Main(string[] args)
    {
        MySorter();
    }

    static void MySorter()

    {
        int[] data = MyArray();
        Console.WriteLine();
        Console.WriteLine("Chose 1 to sort Ascending or 2 to sort Descending:");
        //int choice = Console.Read();
        ConsoleKeyInfo choice = Console.ReadKey();
        Console.WriteLine();
        if (choice.Key == ConsoleKey.D1 || choice.Key == ConsoleKey.NumPad1)
        {
            QuickSort(data);
            string result = string.Join(", ", data);
            Console.WriteLine(result);
            Thread.Sleep(4000);
        }
        else if (choice.Key == ConsoleKey.D2 || choice.Key == ConsoleKey.NumPad2)
        {
            QuickSort(data, Comparer<int>.Create((a, b) => b.CompareTo(a)));
            Console.WriteLine(string.Join(", ", data));
            Thread.Sleep(4000);
        }
        else
        {
            Console.WriteLine("wrong input.");
            Thread.Sleep(2000);
            Environment.Exit(0);
        }
    }

    public static int[] MyArray()
    {
        Console.WriteLine("Enter a total of 10 numbers to be sorted: ");
        int[] InputData = new int[10];
        for (int i = 0; i < InputData.Length; i++)
        {
            var pressedkey = Console.ReadKey();
            int number;
            bool result = int.TryParse(pressedkey.KeyChar.ToString(), out number);
            if (result)
            {
                InputData[i] = number;
            }

        }

        return InputData;
    }

    public static void QuickSort<T>(T[] data)
    {
        Quick_Sort(data, 0, data.Length - 1, Comparer<T>.Default);
    }

    public static void QuickSort<T>(T[] data, IComparer<T> comparer)
    {
        Quick_Sort(data, 0, data.Length - 1, comparer);
    }

    public static void Quick_Sort<T>(T[] data, int left, int right, IComparer<T> comparer)
    {
        int i, j;
        T pivot, temp;
        i = left;
        j = right;
        pivot = data[(left + right) / 2];
        do
        {
            while ((comparer.Compare(data[i], pivot) < 0) && (i < right)) i++;
            while ((comparer.Compare(pivot, data[j]) < 0) && (j > left)) j--;
            if (i <= j)
            {
                temp = data[i];
                data[i] = data[j];
                data[j] = temp;
                i++;
                j--;
            }
        } while (i <= j);
        if (left < j) Quick_Sort(data, left, j, comparer);
        if (i < right) Quick_Sort(data, i, right, comparer);
     }

     }

    }