C# 二进制搜索在程序中的应用

我目前有一个程序，我在其中读取文件并使用冒泡排序进行排序。但是，我需要实现一个函数，允许我在任何文件中搜索一个值。我想使用的算法是二进制搜索，但我不确定如何实现这一点

我如何才能选择一个文件来搜索我输入的值

用于读入文件并允许排序的代码（无需排序帮助）：

以上部分是本文的主要研究方法

public class FileData
{
    public int File1Value { get; set; }
    public decimal File2Value { get; set; }
    public int File3Value { get; set; }
    public decimal File4Value { get; set; }
    public decimal File5Value { get; set; }
    public decimal File6Value { get; set; }
    public string File7Value { get; set; }
    public string File8Value { get; set; }
    public float File9Value { get; set; }
    public int File10Value { get; set; }
    public int File11Value { get; set; }

    public override string ToString()
    {
        return String.Format($"{File1Value}|{File2Value}|{File3Value}|{File4Value}|{File5Value}|{File6Value}|{File7Value}|{File8Value}|{File9Value}|{File10Value}|{File11Value}");
    }
}

public static FileData[] GetFileData(string firstFilePath, string secondFilePath, 
    string thirdFilePath, string fourthFilePath, string fifthFilePath, 
    string sixthFilePath, string seventhFilePath, string eigthFilePath, 
    string ninthFilePath, string tenthFilePath, string eleventhFilePath)
{

    int intHolder = 0;
    decimal decHolder = 0;
    float time = 0;

    // Get a list of ints from the first file
    var fileOneValues = File
        .ReadAllLines(firstFilePath)
        .Where(line => int.TryParse(line, out intHolder))
        .Select(v => intHolder)
        .ToArray();

    // Get a list of decimals from the second file
    var fileTwoValues = File
        .ReadAllLines(secondFilePath)
        .Where(line => decimal.TryParse(line, out decHolder))
        .Select(v => decHolder)
        .ToArray();

    var fileThreeValues = File
        .ReadAllLines(thirdFilePath)
        .Where(line => int.TryParse(line, out intHolder))
        .Select(v => intHolder)
        .ToArray();

    var fileFourValues = File
        .ReadAllLines(fourthFilePath)
        .Where(line => decimal.TryParse(line, out decHolder))
        .Select(v => decHolder)
        .ToArray();

    var fileFiveValues = File
        .ReadAllLines(fifthFilePath)
        .Where(line => decimal.TryParse(line, out decHolder))
        .Select(v => decHolder)
        .ToArray();

    var fileSixValues = File
       .ReadAllLines(sixthFilePath)
       .Where(line => decimal.TryParse(line, out decHolder))
       .Select(v => decHolder)
       .ToArray();

    var fileSevenValues = File
        .ReadAllLines(seventhFilePath)
        .ToArray();

    var fileEightValues = File
        .ReadAllLines(eigthFilePath)
        .ToArray();

    var fileNineValues = File
        .ReadAllLines(ninthFilePath)
        .Where(line => float.TryParse(line, out time))
        .Select(v => time)
        .ToArray();

    var fileTenValues = File
        .ReadAllLines(tenthFilePath)
        .Where(line => int.TryParse(line, out intHolder))
        .Select(v => intHolder)
        .ToArray();

    var fileElevenValues = File
        .ReadAllLines(eleventhFilePath)
        .Where(line => int.TryParse(line, out intHolder))
        .Select(v => intHolder)
        .ToArray();

    // I guess the file lengths should match, but in case they don't, 
    // use the size of the smaller one so we have matches for all items
    var numItems = Math.Min(fileOneValues.Count(), fileTwoValues.Count());

    // Populate an array of new FileData objects
    var fileData = new FileData[numItems];
    for (var index = 0; index < numItems; index++)
    {
        fileData[index] = new FileData
        {
            File1Value = fileOneValues[index],
            File2Value = fileTwoValues[index],
            File3Value = fileThreeValues[index],
            File4Value = fileFourValues[index],
            File5Value = fileFiveValues[index],
            File6Value = fileSixValues[index],
            File7Value = fileSevenValues[index],
            File8Value = fileEightValues[index],
            //File9Value = fileNineValues[index],
            File10Value = fileTenValues[index],
            File11Value = fileElevenValues[index]
        };
    }

    return fileData;
}

公共类文件数据
{
public int File1Value{get；set；}
公共十进制文件2value{get；set；}
public int File3Value{get；set；}
公共十进制文件4value{get；set；}
公共十进制文件5value{get；set；}
公共十进制文件6value{get；set；}
公共字符串File7Value{get；set；}
公共字符串File8Value{get；set；}
公共浮点文件9value{get；set；}
public int File10Value{get；set；}
public int File11Value{get；set；}
公共重写字符串ToString（）
{
返回字符串.Format（$“{File1Value}{File2Value}{File3Value}}{File4Value}}{File5Value}}{File6Value}{File7Value}{File8Value}{File9Value}{File10Value}{File11Value}”）；
}
}
公共静态文件数据[]GetFileData（字符串firstFilePath、字符串secondFilePath、，
字符串thirdFilePath、字符串fourthFilePath、字符串fifthFilePath、，
字符串第六个文件路径、字符串第七个文件路径、字符串eigthFilePath、，
字符串ninthFilePath、字符串tenthFilePath、字符串eleventhFilePath）
{
intHolder=0；
十进制十进制数=0；
浮动时间=0；
//从第一个文件中获取int的列表
var fileOneValues=File
.ReadAllLines（firstFilePath）
.Where（line=>int.TryParse（line，out intHolder））
.选择（v=>intHolder）
.ToArray（）；
//从第二个文件中获取小数列表
var fileTwoValues=File
.ReadAllLines（第二个文件路径）
.Where（line=>decimal.TryParse（line，out-deccholder））
.选择（v=>decHolder）
.ToArray（）；
var fileThreeValues=File
.ReadAllLines（第三条路径）
.Where（line=>int.TryParse（line，out intHolder））
.选择（v=>intHolder）
.ToArray（）；
var fileFourValues=File
.ReadAllLines（第四个文件路径）
.Where（line=>decimal.TryParse（line，out-deccholder））
.选择（v=>decHolder）
.ToArray（）；
var fileFiveValues=File
.ReadAllLines（第五个文件路径）
.Where（line=>decimal.TryParse（line，out-deccholder））
.选择（v=>decHolder）
.ToArray（）；
var fileSixValues=File
.ReadAllLines（第六个文件路径）
.Where（line=>decimal.TryParse（line，out-deccholder））
.选择（v=>decHolder）
.ToArray（）；
var fileSevenValues=File
.ReadAllLines（第七个文件路径）
.ToArray（）；
var fileEightValues=File
.ReadAllLines（eigthFilePath）
.ToArray（）；
var fileNineValues=File
.ReadAllLines（第九文件路径）
.Where（line=>float.TryParse（line，out time））
.选择（v=>时间）
.ToArray（）；
var fileTenValues=File
.ReadAllLines（tenthFilePath）
.Where（line=>int.TryParse（line，out intHolder））
.选择（v=>intHolder）
.ToArray（）；
var fileElevenValues=File
.ReadAllLines（eleventhFilePath）
.Where（line=>int.TryParse（line，out intHolder））
.选择（v=>intHolder）
.ToArray（）；
//我想文件长度应该匹配，但万一不匹配，
//使用较小的尺寸，以便所有项目都匹配
var numItems=Math.Min（fileOneValues.Count（），filetwowalues.Count（））；
//填充新FileData对象的数组
var fileData=newfiledata[numItems]；
对于（变量索引=0；索引

二进制搜索代码：

  static int BinarySearch_R(int key, FileData[] fileData, int low, int high)
{
    if (low > high) return -1;
    int mid = (low + high) / 2;
    if (key == fileData[mid])
    {

        return mid;
    }
    if (key < fileData[mid])
    {
        return BinarySearch_R(key, fileData, low, mid - 1);
    }
    else
    {

        return BinarySearch_R(key, fileData, mid + 1, high);
    }
}

static int-BinarySearch\R（int-key，FileData[]FileData，int-low，int-high）
{
如果（低>高）返回-1；
int mid=（低+高）/2；
if（key==fileData[mid]）
{
中途返回；
}
如果（键<文件数据[mid]）
{
返回BinarySearch_R（key，fileData，low，mid-1）；
}
其他的
{
返回BinarySearch\R（键，文件数据，中+1，高）；
}
}

听起来您正在寻找一种方法，使您的BinarySearch方法具有通用性，以便它可以处理不同类型的对象

下面我将您发布的第一个更改为泛型，其中类型

T

被限制为实现

IComparable

的类型（因为我们需要能够将

键

与方法内部的

输入阵列

中的项进行比较）

这适用于您为文件定义的类型（

int

、

decimal

、

string

、和

float

所有实现

IComparable

）

//
///返回inputArray中与键的值匹配的项的索引
/// 
///数组中对象的类型
///要搜索的项目数组
///要搜索的关键项值
///与项匹配的项的索引，如果未找到匹配项，则为-1
公共静态int-BinarySearchIterative（T[]输入阵列，T键）
其中T:i可比较
{
int min=inputArray.GetLowerBound（0）；
int max=inpu
  static int BinarySearch_R(int key, FileData[] fileData, int low, int high)
{
    if (low > high) return -1;
    int mid = (low + high) / 2;
    if (key == fileData[mid])
    {

        return mid;
    }
    if (key < fileData[mid])
    {
        return BinarySearch_R(key, fileData, low, mid - 1);
    }
    else
    {

        return BinarySearch_R(key, fileData, mid + 1, high);
    }
}

/// <summary>
/// Returns the index of an item in inputArray that matches the value of key
/// </summary>
/// <typeparam name="T">The type of objects in the array</typeparam>
/// <param name="inputArray">An array of items to search</param>
/// <param name="key">A key item value to search for</param>
/// <returns>The index of an item that matches key, or -1 if no match is found</returns>
public static int BinarySearchIterative<T>(T[] inputArray, T key) 
    where T : IComparable<T>
{
    int min = inputArray.GetLowerBound(0);
    int max = inputArray.GetUpperBound(0);

    while (min <= max)
    {
        int mid = (min + max) / 2;
        int comparison = key.CompareTo(inputArray[mid]);

        if (comparison == 0)
        {
            return mid;
        }
        else if (comparison < 0)
        {
            max = mid - 1;
        }
        else
        {
            min = mid + 1;
        }
    }

    return -1;
}