C# 在c中查找两个列表之间的重叠#

我有一个计算两个列表重叠的matlab代码。事实上，它检查一个列表H是否在另一个列表U中，并将列表U的窗口保持在列表H所在的位置（至少一次）。实际上，U，H是Nx2大小的索引列表，其中在每个点上有两个值，分别表示窗口的起始索引和窗口的结束索引。我在matlab中的代码是：

function W = getwindowsspecial(U,H)
W = [];
for i = 1:size(U,1)
  if any(H(:,1)>=U(i,1) & H(:,1)<=U(i,2))
    W = [W;U(i,:)];
  end
end

H可以是：

54  86
112 217
292 325
402 451
628 664

129 214
297 321
406 447
637 664

结果是：

112 217
292 325
402 451

我想把代码转换成c。我的列表U、H为列表>>。我对应的函数如下所示：

 static List<int> getWindows(List<List<int>> list1, List<List<int>> list2)
    {
        List<int> list3 = new List<int>();

        for (int index = 0; index < list1[0].Count; index++) { 

        }

            return list3;
    }

静态列表getWindows（列表1、列表2）
{
List list3=新列表（）；
对于（int index=0；index

我应该填写什么样的函数才能作为Matlab函数工作

编辑：在这段代码中，我为第一个和第二个列表添加了限制。如何将这些限制添加到元组而不是列表列表中

        List<List<int>> first = new List<List<int>>();
        List<List<int>> second = new List<List<int>>();
        first.Add(upFirst); first.Add(downFirst);
        second.Add(upSecond); second.Add(downSecond);

        getWindows(first, second);

List first=新列表（）；
第二个列表=新列表（）；
首先，添加（upFirst）；first.Add（downFirst）；
第二，添加（上升秒）；第二，添加（下降秒）；
getWindows（第一，第二）；

upFirst和upSecond包含第一个和第二个列表的所有左侧限制，downFirst和downSecond包含第一个和第二个列表的所有右侧限制。我尝试使用以下代码来完成我的工作：

 for (int index = 0; index < upFirst.Count; index++){

            first.Add(new List<int> { upFirst[index], downFirst[index] });

 }

 for (int index = 0; index < upSecond.Count; index++){

           second.Add(new List<int> { upSecond[index], downSecond[index]});

  }
  List<List<int>> lista = GetWindows(first, second);

for（int index=0；index

这就是我试图添加为元组的内容。然而，作为

---

@M.NasserJavaID结果为空。我提供的第一个和第二个列表的输入是：

您可以通过对这两个列表进行一些LINQ查询来实现这一点。为了便于阅读，我假设您有元组列表，即

List

s，而不是列表列表

var W = U.Where(u => H.Any(h => h.Item1 >= u.Item1 && h.Item1 <= u.Item2));

根据您从哪里获取数据，这应该不会很麻烦。但是，如果您已经将数据设置为

列表

s，则可以轻松地将条件更改为使用

h[0]

而不是

h.Item1

等

---

我建议使用元组的主要原因是它们将更加有效，特别是如果矩阵中有许多行

U

和

H

，您可以通过对这两个列表进行一些LINQ查询来实现这一点。为了便于阅读，我假设您有元组列表，即

List

s，而不是列表列表

var W = U.Where(u => H.Any(h => h.Item1 >= u.Item1 && h.Item1 <= u.Item2));

根据您从哪里获取数据，这应该不会很麻烦。但是，如果您已经将数据设置为

列表

s，则可以轻松地将条件更改为使用

h[0]

而不是

h.Item1

等

---

我建议使用元组的主要原因是它们会更有效，特别是如果矩阵中有许多行

U

和

H

，请试试这个。根据给定的场景，我们需要U的数字在H的范围内，所以它们是

public void Test()
    {
        var listU = new List<List<int>>
        {
            new List<int> {54, 86},
            new List<int> {112, 217},
            new List<int> {292, 325},
            new List<int> {402, 451},
            new List<int> {628, 664}
        };
        var listH = new List<List<int>>
        {
            new List<int> {129, 214},
            new List<int> {297, 321},
            new List<int> {406, 447},
            new List<int> {637, 664}
        };
        GetWindows(listU, listH);
    }

static List<List<int>> GetWindows(List<List<int>> listU, List<List<int>> listH)
    {
        List<List<int>> list3 = new List<List<int>>();
        var startingOfH = listH.First()[0];
        var endOfH = listH.Last()[listH.Last().Count - 1];
        foreach (var num in listU)
        {
            var initial = num[0];
            var final = num[num.Count - 1];
            if (initial > startingOfH && final < endOfH)
            {
                list3.Add(num);
            }
        }
        return list3;
    }

公共无效测试（）
{
var listU=新列表
{
新名单{54,86}，
新名单{112217}，
新名单{292325}，
新名单{402451}，
新名单{628664}
};
var listH=新列表
{
新名单{129，214}，
新名单{297321}，
新名单{406447}，
新名单{637664}
};
GetWindows（listU、listH）；
}
静态列表GetWindows（列表列表、列表）
{
List list3=新列表（）；
var startingOfH=listH.First（）[0]；
var endOfH=listH.Last（）[listH.Last（）.Count-1]；
foreach（列表中的var num）
{
var initial=num[0]；
var final=num[num.Count-1]；
如果（初始>开始和最终<结束）
{
列表3.Add（num）；
}
}
返回列表3；
}

编辑： 如果您想使用as Linq，请使用此

static List<List<int>> GetWindows(List<List<int>> listU, List<List<int>> listH)
    {
        var startingOfH = listH.First()[0];
        var endOfH = listH.Last()[listH.Last().Count - 1];
        return (from num in listU 
                let initial = num[0] 
                let final = num[num.Count - 1] 
                where initial > startingOfH && final < endOfH 
                select num).ToList();
    }

static List GetWindows（List listU，List listH）
{
var startingOfH=listH.First（）[0]；
var endOfH=listH.Last（）[listH.Last（）.Count-1]；
返回（从列表中的num返回）
让initial=num[0]
让final=num[num.Count-1]
其中初始值>起始值和最终值<结束值
选择num.ToList（）；
}

编辑2： 忽略初始值

static List<List<int>> GetWindows(List<List<int>> listU, List<List<int>> listH)
    {
        List<List<int>> list3 = new List<List<int>>();
        var startingOfH = listH.First()[0];
        var endOfH = listH.Last()[listH.Last().Count - 1];
        foreach (var num in listH)
        {
            var final = num[num.Count - 1];
            if (final > startingOfH && final < endOfH)
            {
                list3.Add(num);
            }
        }
        return list3;
    }

static List GetWindows（List listU，List listH）
{
List list3=新列表（）；
var startingOfH=listH.First（）[0]；
var endOfH=listH.Last（）[listH.Last（）.Count-1]；
foreach（列表中的var num）
{
var final=num[num.Count-1]；
如果（最终>开始和最终<结束）
{
列表3.Add（num）；
}
}
返回列表3；
}

如果你喜欢林克的话

static List<List<int>> GetWindows(List<List<int>> listU, List<List<int>> listH)
    {
        var startingOfH = listH.First()[0];
        var endOfH = listH.Last()[listH.Last().Count - 1];
        return (from num in listH 
                let final = num[num.Count - 1] 
                where final > startingOfH && final < endOfH 
                select num).ToList();
    }

static List GetWindows（List listU，List listH）
{
var startingOfH=listH.First（）[0]；
var endOfH=listH.Last（）[listH.Last（）.Count-1]；
返回（从列表中的num返回）
让final=num[num.Count-1]
其中final>startingof H和&final

请试试这个。根据给定的场景，我们需要U的数字在H的范围内，所以它们是

public void Test()
    {
        var listU = new List<List<int>>
        {
            new List<int> {54, 86},
            new List<int> {112, 217},
            new List<int> {292, 325},
            new List<int> {402, 451},
            new List<int> {628, 664}
        };
        var listH = new List<List<int>>
        {
            new List<int> {129, 214},
            new List<int> {297, 321},
            new List<int> {406, 447},
            new List<int> {637, 664}
        };
        GetWindows(listU, listH);
    }

static List<List<int>> GetWindows(List<List<int>> listU, List<List<int>> listH)
    {
        List<List<int>> list3 = new List<List<int>>();
        var startingOfH = listH.First()[0];
        var endOfH = listH.Last()[listH.Last().Count - 1];
        foreach (var num in listU)
        {
            var initial = num[0];
            var final = num[num.Count - 1];
            if (initial > startingOfH && final < endOfH)
            {
                list3.Add(num);
            }
        }
        return list3;
    }

公共无效测试（）
{
var listU=新列表
{
新名单{54,86}，
新名单{112217}，
新名单{292325}，
新名单{402451}，
新名单{628664}
};
var listH=新列表
{
新名单{129，2