C#.NET实现字符串Quick Sort/Merge Sort的报错排查与代码优化

• 类型不匹配触发连锁报错：原有quicksort、partition方法定义的入参为string[]类型（存储多个独立字符串的数组），但主流程中userInput是单个string类型（用户输入的完整长文本），直接传参会触发类型不兼容报错。
• 遍历逻辑的类型不匹配：case "b"块中foreach (string s in userInput)的写法存在类型错误——遍历单个字符串时，逐元素得到的是char类型值，强行指定为string类型会直接报红。
• 排序方法的业务场景错配：原Quick Sort方法是为“对独立字符串集合排序”设计的，但当前业务需求是对单个输入字符串内的所有字符排序，方法的入参、比较逻辑完全不匹配场景。
• 全局类型修改的连锁问题：直接把userInput改成string[]类型时，Console.ReadLine()返回的单个string无法直接赋值给数组类型；同时原有Bubble Sort分支中调用的ToCharArray()是string类型的实例方法，数组类型没有这个方法，自然会报错。

using System;

namespace SortString
{
    class SortStringCategory
    {
        public static void Main(string[] args)
        {
            Console.Write("Enter a string: ");
            string userInput = Console.ReadLine() ?? string.Empty;
            char response;

            do
            {
                Console.WriteLine();
                Console.WriteLine("Choose between the two sorting strategies:");
                Console.WriteLine("	a) - Bubble Sort");
                Console.WriteLine("	b) - Quick Sort");
                Console.WriteLine("	q) - Exit");
                Console.WriteLine();
                Console.Write("Your option: ");

                var inputLine = Console.ReadLine();
                if (string.IsNullOrEmpty(inputLine))
                {
                    response = '\0';
                    continue;
                }
                response = char.ToLower(inputLine[0]);

                Console.WriteLine();

                switch (response)
                {
                    case 'a':
                    {
                        char temp;
                        char[] charStr = userInput.ToCharArray();
                        for (int i = 1; i < charStr.Length; i++)
                        {
                            for (int j = 0; j < charStr.Length - 1; j++)
                            {
                                if (charStr[j] > charStr[j + 1])
                                {
                                    temp = charStr[j];
                                    charStr[j] = charStr[j + 1];
                                    charStr[j + 1] = temp;
                                }
                            }
                        }
                        Console.Write("Bubble Sort Result: ");
                        Console.WriteLine(charStr);
                        break;
                    }
                    case 'b':
                    {
                        char[] charArr = userInput.ToCharArray();
                        QuickSort(charArr, 0, charArr.Length - 1);
                        Console.Write("Quick Sort Result: ");
                        foreach (char c in charArr)
                        {
                            Console.Write(c);
                        }
                        Console.WriteLine();
                        break;
                    }
                    case 'q':
                        return;
                    default:
                        Console.WriteLine("Invalid answer. Please enter a valid option.");
                        break;
                }
            } while (true);
        }

        static int Partition(char[] arr, int start, int end)
        {
            char pivot = arr[end];
            int i = start - 1;
            for (int j = start; j < end; j++)
            {
                if (arr[j] <= pivot)
                {
                    i++;
                    (arr[i], arr[j]) = (arr[j], arr[i]);
                }
            }
            (arr[i + 1], arr[end]) = (arr[end], arr[i + 1]);
            return i + 1;
        }

        static void QuickSort(char[] arr, int start, int end)
        {
            if (start < end)
            {
                int pivotIndex = Partition(arr, start, end);
                QuickSort(arr, start, pivotIndex - 1);
                QuickSort(arr, pivotIndex + 1, end);
            }
        }
    }
}

• 保留全局userInput为string类型，完全适配Console.ReadLine()的返回值，同时兼容原有Bubble Sort分支的ToCharArray()调用，从根源上避免改全局类型引发的连锁报错。
• 重写Quick Sort相关的Partition、QuickSort方法，入参调整为char[]字符数组类型，直接用字符值比较大小，适配字符排序的业务需求。
• 修正case "b"块的遍历逻辑，逐元素接收char类型值，彻底解决类型不匹配的报红问题。
• 替换原有双指针错位的Partition实现，修正原逻辑可能出现的排序错误，让Quick Sort的排序结果更稳定。
• 方法命名调整为C#推荐的PascalCase规范，可读性更强。
• 优化原循环逻辑的退出机制，新增q选项供用户主动退出，避免原逻辑输入有效排序选项就直接退出的不合理设计。

内容的提问来源于stack exchange，提问作者BugsBunny