Question

有没有办法在2维列表中使用内置快速方法“自动和快速”交换元素，c＃中的数组或字典？

编辑：更具体一点：我不会只交换2个元素，而是改变 n 元素/列的顺序

我有这样的事情：一个2k数据断裂，10k行（列表有10k个元素），每个元素都是一个包含5个元素的列表。（例如，字符串列表＆gt;＆gt;）。

  0 1 2 3 4 
0 A B C D E
1 A A A A A
2 d d c k x
3 ...
.
.
10000 ...

有没有办法交换索引为0和2的元素/列的所有10k行？

起初我会在第0行：A B C D E和交换之后：C B A D E

或者我是否必须遍历所有行并自行交换索引为0和2的元素/列？

编辑：在我的businesslogic中，2d数据结构将成为行和元素元素的循环行，值将插入某处。所以我的想法不是循环foreach元素，而是按特定顺序循环每一行和元素。因为我不想访问0,1,2,3,4但2,1,0,3,4中的元素。任何以特定顺序而不是foreach访问侦听的问题方式会慢吗？性能较差？

编辑：有一个指向java Collections.swap http://www.java-examples.com/swap-elements-java-arraylist-example

的链接

Answer 1

我认为没有内置功能，但您可以轻松创建自己的扩展程序：

public static class ListExtensions
{
    public static void Swap<T>(this IList<T> list, int index1, int index2)
    {
        T temp = list[index1];
        list[index1] = list[index2];
        list[index2] = temp;
    }
}

（基于Reeds Copseys方法：https://stackoverflow.com/a/1111039/284240）

以下是一些示例数据：

var rnd = new Random();
var hugeList = new List<List<int>>();
for (int i = 0; i < 10000; i++)
{
    var innerList = new List<int>();
    for (int ii = 0; ii < 5; ii++)
    {
        innerList.Add(rnd.Next(1,100000));
    }
    hugeList.Add(innerList);
}

交换所有内部列表的索引0和2：

foreach (var innerList in hugeList)
{ 
    innerList.Swap(0, 2);
}

请注意，它适用于任何类型的列表和数组（因为它们都实现了IList<T>）。

Answer 2

您需要一个能够执行此操作的数据结构。我使用List<T>和Dictionary的混合物实现了它。

这样，您可以在一个位置更改列的顺序，这会影响所有内容。

public class Order
{
    public Order(int number)
    {
        Number = number;
    }

    public int Number { get; set; }
}

public class Item
{
    // ... whatever your item is 
}

public class Program
{
    static void Main()
    {
        var list = new List<Dictionary<Order, Item>>();
        var orders = new List<Order>()
                        {
                            new Order(1),
                            new Order(2),
                            new Order(3),
                            new Order(4),
                            new Order(5)
                        };

        for (int i = 0; i < 10000; i++)
        {
            list.Add( new Dictionary<Order, Item>()
                        {
                            {orders[0], new Item()},
                            {orders[1], new Item()},
                            {orders[2], new Item()},
                            {orders[3], new Item()},
                            {orders[4], new Item()}
                        });
        }

        // Now access items in order 

        var item = list[100][orders[1]];

        // now you can swap the orders: replace 2 and 4
        var temp = orders[1];
        orders[1] = orders[3];
        orders[3] = temp;

        var item = list[100][orders[1]]; // now points to previously 4th item!!
    }
}

Answer 3

您可能希望对此进行基准测试以确定它是否更好，并且可以使用10K元素。

Sudocode，不在PC附近：

New temp array of size to copy
Array.Copy(from firstblock to temp)
Array.Copy(from secondblock to firstblock)
Array.Copy(from temp to secondblock)

如何交换c＃lists / array / dictionary中的元素/列

3 个答案: