1

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

编辑：更具体地说：我不仅会交换 2 个元素，还会更改可能n 个元素/列的顺序

我有这样的东西：具有 10k 行的 2d 数据结构（具有 10k 个元素的列表），每个元素又是一个具有 5 个元素的列表。（例如，字符串列表列表>>）。

  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 行：ABCDE 和交换后：CBADE

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

编辑：在我的业务逻辑中，二维数据结构将逐行循环，元素逐行循环，并且值将插入某处。所以我的想法不是循环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的链接

4

3 回答 3

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>）。

于 2012-07-17T09:34:12.857 回答
1

您需要一个能够执行此操作的数据结构。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!!
    }
}
于 2012-07-17T10:22:57.070 回答
0

您可能想对此进行基准测试以查看它是否更好，并且可以使用 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)
于 2012-08-16T10:58:05.630 回答