如何讓我的快速排序算法按升序和降序對數組進行排序？

Question

目前我的快速排序算法在情況1中按照升序對數組進行排序，但是我希望使用戶選擇選項2（情況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); 
    } 

Answer 1

你可以改變你快速排序的方法來接受IComparer<T> comparer，和然後用它來進行比較。

然後，如果您需要默認比較訂單，則可以使用Comparer<T>.Default，或者您可以使用Comparer<T>.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); 
     } 
    } 
} 

這有兩個好處：

1. 類型T並不需要實現IComparable<T>。您可以傳入進行比較的IComparer<T>對象。
2. 您可以通過傳遞不同的自定義IComparer<T>對象以多種方式對相同的數據進行排序。

這是由一些LINQ的IEnumerable的擴展所採用的方法，例如Enumerable.OrderBy()

Answer 2

添加參數，允許改變比較的結果

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

一個簡單的方法：參數descending +1/-1和使用

data[i].CompareTo(pivot) * descending < 0 

Answer 3

只是平添幾分奶油對@Matthew沃森回答。在閱讀@Illimar的文章後，他想讓用戶選擇以升序模式還是降序模式對數組進行排序。我剛纔編輯@Matthew工作拿出了以下內容：

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); 
    } 

    } 

    } 

所以在用戶上面給出要分類爲輸入數字，然後選擇如何排序應該怎麼辦？