LINQ将列交换为行

本文关键字：交换 LINQ | 更新日期: 2023-09-27 18:04:46

是否有一个奇特的LINQ表达式可以让我以更简单的方式执行以下操作。我有一个List<List<double>>，假设List是2d矩阵中的列，我想将列列表交换为行列表。我有以下明显的解决方案：

int columns = 5;
var values; // assume initialised as List<List<double>>()
var listOfRows = new List<List<double>>();
for (int i = 0; i < columns ; i++)
{
    List<double> newRow = new List<double>();
    foreach (List<double> value in values)
    {
        newRow.Add(value[i]);
    }
    listOfRows.Add(newRow);
}

LINQ将列交换为行

您可以很容易地LINQify内部循环：

vector.AddRange(values.Select(value => value[i]));

是否提高可读性完全取决于您！

这里有一个Linq表达式，它可以做你想做的事情-从外观上看，我个人会坚持使用嵌套的foreach循环-更容易阅读：

var columnList= new  List<List<double>>();
columnList.Add(new List<double>() { 1, 2, 3 });
columnList.Add(new List<double>() { 4, 5, 6 });
columnList.Add(new List<double>() { 7, 8, 9 });
columnList.Add(new List<double>() { 10, 11, 12 });
int columnCount = columnList[0].Count;
var rowList = columnList.SelectMany(x => x)
                        .Select((x, i) => new { V = x, Index = i })
                        .GroupBy(x => (x.Index + 1) % columnCount)
                        .Select(g => g.Select( x=> x.V).ToList())
                        .ToList();

这个例子也只适用于列数固定的矩阵。基本上，它是将矩阵扁平化为一个列表，然后通过列表中元素的索引对列计数进行分组来创建行列表。

编辑：

一种不同的方法，更接近于嵌套循环，除了开销之外，性能可能相似。

int columnCount = columnList[0].Count;
int rowCount = columnList.Count;
var rowList =  Enumerable.Range(0, columnCount)
                         .Select( x => Enumerable.Range(0, rowCount)
                                                 .Select(y => columnList[y][x])
                                                 .ToList())
                         .ToList();

var inverted = Enumerable.Range(0, columnCount)
               .Select(index => columnList.Select(list => list[index]));

简而言之，我们从一个范围中枚举列索引，并使用它来收集每个列表的第n个元素。

请注意，您需要检查每个列表的列数是否相同。

这里有一个适用于矩形(非粗糙(矩阵的矩阵。这里的C#代码可以剪切粘贴到LinqPad中，这是一个免费的交互式C#编程工具。

我定义了一个后缀运算符(即，一个扩展方法("Transpose。"使用如下运算符：

    var rand = new Random();
    var xss = new [] {
        new [] {rand.NextDouble(), rand.NextDouble()},
        new [] {rand.NextDouble(), rand.NextDouble()},
        new [] {rand.NextDouble(), rand.NextDouble()},
    };
    xss.Dump("Original");
    xss.Transpose().Dump("Transpose");

结果是这样的：

Original
0.843094345109116
0.981432441613373
0.649207864724662
0.00594645645746331
0.378864820291691
0.336915332515219

Transpose
0.843094345109116
0.649207864724662
0.378864820291691
0.981432441613373
0.00594645645746331
0.336915332515219

该操作员实现的要点是以下

    public static IEnumerable<IEnumerable<T>> Transpose<T>(this IEnumerable<IEnumerable<T>> xss)
    {
        var heads = xss.Heads();
        var tails = xss.Tails();
        var empt = new List<IEnumerable<T>>();
        if (heads.IsEmpty())
            return empt;
        empt.Add(heads);
        return empt.Concat(tails.Transpose());
    }

以下是完整的实现，注释掉了一些行，您可以取消注释以监视函数的工作方式。

void Main()
{
    var rand = new Random();
    var xss = new [] {
        new [] {rand.NextDouble(), rand.NextDouble()},
        new [] {rand.NextDouble(), rand.NextDouble()},
        new [] {rand.NextDouble(), rand.NextDouble()},
    };
    xss.Dump("Original");
    xss.Transpose().Dump("Transpose");
}
public static class Extensions
{
    public static IEnumerable<T> Heads<T>(this IEnumerable<IEnumerable<T>> xss)
    {
        Debug.Assert(xss != null);
        if (xss.Any(xs => xs.IsEmpty()))
            return new List<T>();
        return xss.Select(xs => xs.First());
    }
    public static bool IsEmpty<T>(this IEnumerable<T> xs)
    {
        return xs.Count() == 0;
    }
    public static IEnumerable<IEnumerable<T>> Tails<T>(this IEnumerable<IEnumerable<T>> xss)
    {
        return xss.Select(xs => xs.Skip(1));
    }
    public static IEnumerable<IEnumerable<T>> Transpose<T>(this IEnumerable<IEnumerable<T>> xss)
    {
//      xss.Dump("xss in Transpose");
        var heads = xss.Heads()
//          .Dump("heads in Transpose")
            ;
        var tails = xss.Tails()
//          .Dump("tails in Transpose")
            ;
        var empt = new List<IEnumerable<T>>();
        if (heads.IsEmpty())
            return empt;
        empt.Add(heads);
        return empt.Concat(tails.Transpose())
//          .Dump("empt")
            ;
    }
}

我正在组合上面的一些答案，这些答案有时会将列和行从原始答案倒置，或者根据我习惯的惯例：行指第一个索引，列指内部(第二个(索引。例如值[行][列]

    public static List<List<T>> Transpose<T>(this List<List<T>> values)
    {
        if (values.Count == 0 || values[0].Count == 0)
        {
            return new List<List<T>>();
        }
        int ColumnCount = values[0].Count;
        var listByColumns = new List<List<T>>();
        foreach (int columnIndex in Enumerable.Range(0, ColumnCount))
        {
            List<T> valuesByColumn = values.Select(value => value[columnIndex]).ToList();
            listByColumns.Add(valuesByColumn);
        }
        return listByColumns;
    }

事实上，行和列这个词只是我们思考行和列中数据的惯例，有时会比解决这些问题更混乱。

实际上，我们只是将内部索引交换为外部索引。(或翻转索引(。因此，也可以定义以下扩展方法。我再次借鉴了上面的解决方案，只是把它放在我觉得可读且相当紧凑的东西中。

需要检查内部列表的大小是否相等。

    public static List<List<T>> InsideOutFlip<T>(this List<List<T>> values)
    {
        if (values.Count == 0 || values[0].Count == 0)
        {
            return new List<List<T>>();
        }
        int innerCount = values[0].Count;
        var flippedList = new List<List<T>>();
        foreach (int innerIndex in Enumerable.Range(0, innerCount))
        {
            List<T> valuesByOneInner = values.Select(value => value[innerIndex]).ToList();
            flippedList.Add(valuesByOneInner);
        }
        return flippedList;
    }
相关文章：