C# 使用联接计数数组在索引处查找项的有效方法

我有一个包含两个数组的对象，第一个是坡度数组：

double[] Slopes = new double[capacity];

下一个是包含各种坡度计数的数组：

int[] Counts = new int[capacity];

数组是相关的，因为当我向对象添加坡度时，如果在坡度数组中输入的最后一个元素与新项的坡度相同，则计数会增加，而不是将其作为新元素添加

i、 e.如果我有坡度15 15 12 4 15 15，我得到：

Slopes = { 15, 12, 4, 15 }
Counts = {  3,  1, 1,  2 }

有没有比用索引迭代

计数

并在

斜率

中查找相应索引更好的方法来查找斜率中的第i项

编辑：不确定我的问题是否不清楚。我需要能够访问出现的第I个斜率，因此从示例中，出现的零索引I=3斜率是12，问题是是否存在更有效的解决方案来查找新结构中的相应斜率

也许这有助于更好地理解这个问题：下面是我如何获得第I个元素的：

public double GetSlope(int index)
        int countIndex = 0;
        int countAccum = 0;
        foreach (int count in Counts)
        {
            countAccum += count;
            if (index - countAccum < 0)
            {
                return Slopes[countIndex];
            }
            else
            {
                countIndex++;
            }
        }
        return Slopes[Index];
}

public-double-GetSlope（int-index）
int countIndex=0；
int countAccum=0；
foreach（计数中的整数计数）
{
countAccum+=计数；
如果（索引-countAccum<0）
{
返回斜率[计数指数]；
}
其他的
{
countIndex++；
}
}
返回斜率[指数]；
}

---

我想知道是否有更有效的方法？

编辑：您可以使用字典，其中键是斜率，每个键的值是对应索引和计数的列表。比如：

class IndexCount
{
    public int Index { get; set; }
    public int Count { get; set; }
}

var slopes = new Dictionary<double, List<IndexCount>>();

class SlopeCount
{
    public int Slope { get; set; }
    public int Count { get; set; }
}

您的收集声明将类似于：

class IndexCount
{
    public int Index { get; set; }
    public int Count { get; set; }
}

var slopes = new Dictionary<double, List<IndexCount>>();

class SlopeCount
{
    public int Slope { get; set; }
    public int Count { get; set; }
}

然后：

var slopeCounts=new List（）；
//填写清单

编辑：您可以使用字典，其中键是斜率，每个键的值是对应索引和计数的列表。比如：

class IndexCount
{
    public int Index { get; set; }
    public int Count { get; set; }
}

var slopes = new Dictionary<double, List<IndexCount>>();

class SlopeCount
{
    public int Slope { get; set; }
    public int Count { get; set; }
}

您的收集声明将类似于：

class IndexCount
{
    public int Index { get; set; }
    public int Count { get; set; }
}

var slopes = new Dictionary<double, List<IndexCount>>();

class SlopeCount
{
    public int Slope { get; set; }
    public int Count { get; set; }
}

然后：

var slopeCounts=new List（）；
//填写清单

为什么不使用

字典

，其中

键

为斜率，

值

为计数

---

嗯，双倍？现在我需要一杯咖啡……

为什么不买一本

字典

，它的

键是斜坡，
值是计数

嗯，双倍？现在我需要一杯咖啡…
如果您一次加载坡度并执行许多这些“第I项”查找，那么使用第三个（或代替计数，取决于用于什么）数组和总数可能会有所帮助。对于您的示例，这将是
{0,3,4,5}
。然后，您不需要在每次查找时将它们相加，这只是一个“i在总计[x]和总计[x+1]之间”的问题。如果您希望有很少的坡度桶，或者如果在整个处理过程中添加坡度，或者如果您不进行很多这样的查找，那么它可能不会给您带来任何好处。本质上，这只是在前面一次添加所有这些内容。
如果您在一次加载坡度并执行许多此类“第i项”查找，则使用第三个（或代替计数，取决于用于什么）数组来查找总计可能会有所帮助。对于您的示例，这将是
{0,3,4,5}
。然后，您不需要在每次查找时将它们相加，这只是一个“i在总计[x]和总计[x+1]之间”的问题。如果您希望有很少的坡度桶，或者如果在整个处理过程中添加坡度，或者如果您不进行很多这样的查找，那么它可能不会给您带来任何好处。本质上，这只是在前面一次性进行所有这些添加。
您可以使用第三个数组来存储重复斜率的第一个索引

double[] Slopes = new double[capacity];
int[] Counts = new int[capacity]; 
int[] Indexes = new int[capacity]; 

与

现在，您可以在
索引中对serach应用二进制搜索，以查找小于或等于您要查找的索引

现在不再使用O（n）搜索性能，而是使用O（log（n））。
可以使用第三个数组来存储重复斜率的第一个索引

double[] Slopes = new double[capacity];
int[] Counts = new int[capacity]; 
int[] Indexes = new int[capacity]; 

与

现在，您可以在
索引中对serach应用二进制搜索，以查找小于或等于您要查找的索引

您现在没有了O（n）搜索性能，而是有了O（log（n））。
您可以始终将现有数组和另一个数组（称之为
OriginalSlopes
）包装到一个类中。添加到
坡度
时，也可以像添加普通数组一样添加到
原始坡度
。如果需要
i_th
坡度，请在
OriginalSlopes
中查找。O（1）全面开展业务

编辑添加示例数据：

Slopes = { 15, 12, 4, 15 }
Counts = {  3,  1, 1,  2 }
OriginalSlopes = { 15, 15, 15, 12, 4, 15, 15 }

您始终可以将现有数组和另一个数组（称之为
OriginalSlopes
）包装到一个类中。添加到
坡度
时，也可以像添加普通数组一样添加到
原始坡度
。如果需要
i_th
坡度，请在
OriginalSlopes
中查找。O（1）全面开展业务

编辑添加示例数据：

Slopes = { 15, 12, 4, 15 }
Counts = {  3,  1, 1,  2 }
OriginalSlopes = { 15, 15, 15, 12, 4, 15, 15 }

在counts对象（或基中的数组）中，添加一个变量，该变量具有迄今为止找到的
累积计数

使用二进制搜索和
比较器
方法比较
累积计数
可以在O（logn）时间内找到斜率

编辑

`Data = 15 15 15 12 4 15 15`
Slopes = { 15, 12, 4, 15 }
Counts = {  3,  1, 1,  2 }
Cumulative count = { 3, 4, 5, 7}

例如，如果您正在查找第6位的元素，当您搜索
累积计数
数据集并找到值5，并且知道下一个值是7时，您可以确保该索引处的元素也将具有第6位元素

使用二进制搜索查找日志（N）时间中的元素。
在counts对象（或基中的数组）中，添加一个变量，该变量具有所需的
累积计数