C# 在C中读取文本文件和排序的最佳方法#

如何从文本中读取一周中未排序天数的字符串数组，并将其转换为可用于排序算法的内容

我猜我每天都要用if语句来分配一个数字，但我一辈子都无法控制它

这是我已经做过的。 SH1文件正在按照我的要求运行。 文本文件只是一个长长的数字列表，因此我可以轻松地将它们转换为双精度

至于日子（和日期，但我还不在上面，所以忽略已经存在的东西，因为它不起作用），我不知道该怎么办

class Algorithm
{

    // Sorting Algorithms
    public static void Quick_Sort(double[] data, int left, int right)
    {
        double temp;
        int i, j;
        double pivot;
        i = left;
        j = right;
        pivot = data[(left + right) / 2];
        do
        {
            while ((data[i] < pivot) && (i < right)) i++;
            while ((pivot < data[j]) && (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()
    {

        //Read text files 

        string[] Day = System.IO.File.ReadAllLines("Day.txt");
        string[] Date = System.IO.File.ReadAllLines("Date.txt");
        string[] _Open = System.IO.File.ReadAllLines("SH1_Open.txt");
        string[] _Close = System.IO.File.ReadAllLines("SH1_Close.txt");
        string[] _Diff = System.IO.File.ReadAllLines("SH1_Diff.txt");
        string[] _Volume = System.IO.File.ReadAllLines("SH1_Volume.txt");

        //Convert to double Array

        //double[] Dates = Array.ConvertAll(Date, s => double.Parse(s));
        double[] SH1_Open = Array.ConvertAll(_Open, s => double.Parse(s));
        double[] SH1_Close = Array.ConvertAll(_Close, s => double.Parse(s));
        double[] SH1_Diff = Array.ConvertAll(_Diff, s => double.Parse(s));
        double[] SH1_Volume = Array.ConvertAll(_Volume, s => double.Parse(s));


        Console.WriteLine("\nWelcome to Shane Porter's Algorithms and Complexity Assingment!\n\nWhat would you like to do?");
        Console.WriteLine("\n1. Select an individual array to analyse\n\n2. View all of the files in decending order by Date\n\n3. Search for a Date\n\n4. Search for a Day\n        \n5. Sort an Array");

        int Choice = Convert.ToInt32(Console.ReadLine());



        //Option 1. Individual Array
        if (Choice == 1)

        Console.WriteLine("\nYou have chosen to select an individual array to analyse");
        Console.WriteLine("\nPlease select the array that you wish to analyse");
        Console.WriteLine("\n1. Day\n2. Date\n3. SH1_Open\n4. SH1_Close\n5. SH1_Diff\n6. SH1_Volume ");

        int ArrayChoice = Convert.ToInt32(Console.ReadLine());

        //Day
        if (ArrayChoice == 1)


        //Date
        if (ArrayChoice == 2)
        {

            DateTime[] dates = new DateTime[143];
            dates[0] = Convert.ToDateTime("12/01/2009");
            dates[1] = DateTime.Now;

            Console.WriteLine(Date);


        }

        //SH1_Open
        if (ArrayChoice == 3)
        {
            Quick_Sort(SH1_Open, 0, 143);
            for (int i = 0; i < SH1_Open.Length; i++)
            {
                Console.WriteLine(SH1_Open[i]);
            }

        }
        //SH1_Close
        if (ArrayChoice == 4)
        {
            Quick_Sort(SH1_Close, 0, 143);
            for (int i = 0; i < SH1_Close.Length; i++)
            {
                Console.WriteLine(SH1_Close[i]);
            }

            //SH1_Diff
            if (ArrayChoice == 5)
            {
                Quick_Sort(SH1_Diff, 0, 143);
                for (int i = 0; i < SH1_Diff.Length; i++)
                {
                    Console.WriteLine(SH1_Diff[i]);
                }
            }
        }

        //SH1_Volume
        if (ArrayChoice == 6)
        {
            Quick_Sort(SH1_Volume, 0, 143);
            for (int i = 0; i < SH1_Volume.Length; i++)
            {
                Console.WriteLine(SH1_Volume[i]);
            }
        }






    }
}

类算法
{
//排序算法
公共静态无效快速排序（双[]数据，左整数，右整数）
{
双温；
int i，j；
双支点；
i=左；
j=右；
枢轴=数据[（左+右）/2]；
做
{
而（（数据[i]left））j--；
如果（i.double.Parse（s））；
double[]SH1_Close=Array.ConvertAll（_Close，s=>double.Parse）；
double[]SH1_Diff=Array.ConvertAll（_Diff，s=>double.Parse）；
double[]SH1_Volume=Array.ConvertAll（_Volume，s=>double.Parse）；
Console.WriteLine（“\n欢迎来到Shane Porter的算法和复杂性分配！\n\n您想做什么？”）；
Console.WriteLine（“\n1.选择要分析的单个数组\n\n2.按日期按降序查看所有文件\n\n3.搜索日期\n\n4.搜索日期\n\n5.对数组排序”）；
int Choice=Convert.ToInt32（Console.ReadLine（））；
//选项1.单个阵列
如果（选项==1）
Console.WriteLine（“\n您已选择选择要分析的单个数组”）；
Console.WriteLine（“\n请选择要分析的数组”）；
Console.WriteLine（“\n1.Day\n2.Date\n3.SH1\u打开\n4.SH1\u关闭\n5.SH1\u差异\n6.SH1\u卷”）；
int ArrayChoice=Convert.ToInt32（Console.ReadLine（））；
//一天
如果（ArrayChoice==1）
//日期
如果（阵列选择==2）
{
DateTime[]日期=新日期时间[143]；
日期[0]=转换为当前时间（“12/01/2009”）；
dates[1]=DateTime.Now；
控制台写入线（日期）；
}
//SH1_开放
如果（阵列选择==3）
{
快速排序（SH1打开，0，143）；
对于（int i=0；i

}

我希望输出如下： 星期一 星期一 星期一 星期二 星期二 星期二等

非常感谢您的帮助！

---

谢谢。

这看起来像是一个家庭作业：）在C#中有内置的快速排序算法实现-

Array.Sort（）

-您可能会注意到本机快速排序算法是通用的-也就是说，只要您的元素实现接口

i可比较

，它就可以工作-因此您可能会从中获得灵感，将双精度快速排序重写为通用快速排序（扰流板-下面的完整代码）

至于每周的分拣天数；现在，当您拥有quick sort的通用版本时，您可以使用system enum

DayOfWeek

：

var days = Array.ConvertAll(Day, s => (DayOfWeek)Enum.Parse(typeof(DayOfWeek), s));
Quick_Sort(days, 0, days.Length - 1);

注：

DayOfWeek

使用英文日历顺序（星期日为一周的第一天）；如果您想要不同的顺序，您必须创建自己的枚举，并在那里指定正确的值。比如：

public enum MyDayOfWeek : int {
  Monday = 0,
  Tuesday = 1, // etc
}

通用快速排序：

public static void Quick_Sort<T>(T[] data, int left, int right) where T : IComparable {
  T temp;
  int i, j;
  T pivot;
  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);
}

publicstaticvoid快速排序（T[]data，int left，int right），其中T:IComparable{
温度；
int i，j；
T轴；
i=左；
j=右；
枢轴=数据[（左+右）/2]；
做{
while（（数据[i].CompareTo（pivot）<0）和&（ileft））j--；
如果（i根据您的示例，在我看来最简单的方法是将数据映射到
double
类型，对其排序，然后映射回。类似于以下内容：

Dictionary<string, double> dayToDouble = new Dictionary<string, double>()
{
    { "Monday", 0.0 },
    { "Tuesday", 1.0 },
    { "Wednesday", 2.0 },
    { "Thursday", 3.0 },
    { "Friday", 4.0 },
    { "Saturday", 5.0 },
    { "Sunday", 6.0 }
};
Dictionary<double, string> doubleToDay =
    dayToDouble.ToDictionary(kvp => kvp.Value, kvp => kvp.Key);

double[] Days = Day.Select(day => dayToDouble[day]).ToArray();

public static void Quick_Sort<T>(T[] data, int left, int right)
    where T : IComparable<T>
{
    T temp;
    int i, j;
    T pivot;
    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);
}



我认为上述内容应该满足您的具体要求，即使用
Quick_sort（）
方法对一周中的几天进行排序。但是，请注意，要使用这种方法，您必须有一种方法将所有数据映射到
double
和back。这可能可行，也可能不可行，或者至少不方便

虽然一周中的几天没有可比较的表示形式（即，您总是必须以某种方式将它们映射到可比较的数据类型），但除了
double
double之外，还有许多其他类型都有。如果必须始终映射数据值，以便对它们进行排序，那将是一种耻辱

幸运的是，.NET（和许多其他框架）通过具有相互“可比较”的数据类型的概念，优雅地处理了这一点。在.NET中，这是通过使用接口来实现的，这些接口类型包括
字符串
、
日期时间
、数字类型等都实现了

要使用此方法，您需要将
Quick_Sort（）
方法设置为泛型，在
IComparable
so的type参数上指定一个约束
public static void Quick_Sort<T>(T[] data, int left, int right)
    where T : IComparable<T>
{
    T temp;
    int i, j;
    T pivot;
    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);
}

double[] Dates = Array.ConvertAll(Date, s => DateTime.Parse(s));

Quick_Sort(Dates, 0, Dates.Length);