c# - c# 将 1 个列表切成 3 个？

Question

我有一个大小为 85160 的动态列表（但它可以改变）。我想把它分成 3 个大小相等的列表。

我正在考虑获取列表的大小。所以那就是：

int count = rawData.count;

然后我可以将它除以 3；但我不确定如何将第一组粘贴到一个列表中，然后是下一个等等。

最好的方法？

Answer 1

这应该有效。

var items = rawData.Count / 3;
var first = rawData.Take(items).ToList();
var second = rawData.Skip(items).Take(items).ToList();
var third = rawDate.Skip(2 * items).ToList();

Answer 2

如果您不关心集合中项目的排序，请尝试此代码。

static IEnumerable<IEnumerable<int>> Split(IList<int> source, int count)
    {
        return source
            .Select((value, index) => new { Index = index % count, Value = value })
            .GroupBy(pair => pair.Index)
            .Select(grp => grp.Select(g => g.Value));
    }

使用示例

static void Main()
{
   var arrays = Split(new[]{1,2,3,4,5,6,7,8,9,0}, 3);

   foreach(var array in arrays)
   {
        foreach(var item in array)
            Console.WriteLine(item);
        Console.WriteLine("---------------");
   }
}

会给你

1 4 7 0

---

2 5 8

---

3 6 9

Answer 3

可能会，List.GetRange(int index, int count)会有帮助吗？

Answer 4

var lists = new List<List<YourObject>>();
int chunkCount = 3;
int chunk = rawData / chunkCount;
for (int i = 0; i < chunkCount; i++)
{
    var data = rawData.Skip(i * chunk);

    if (i < chunkCount - 1)
        data = data.Take(chunk);

    lists.Add(data.ToList());
}

什么时候i == chunkCount - 1（最后一次迭代）我没有Take用来确保我把所有东西都带到最后。

Answer 5

好吧，您通常可以IEnumerables使用这样的扩展名来为所有人做这件事。

public static IEnumerable<IEnumerable<T>> Chop<T>(
    this IEnumerable<T> source,
    int chopCount)
{
    var chops = new IList<T>[chopCount];

    for (i = 0; i < chops.Length; i++)
    {
        chops[i] = new List<T>();
    }

    var nextChop = 0;
    foreach (T item in source)
    {
        chop[nextChop].Add(item);
        nextChop = nextChop == chopCount - 1 ? 0 : nextChop + 1;
    }

    for (i = 0; i < chops.Length; i++)
    {
        yield return chops[i];
    }   
}

你可以这样使用

var chops = rawData.Chop(3);

Answer 6

这是一个使用 IEnumerable 扩展的解决方案，它将序列划分为多个子序列：

using System;
using System.Collections.Generic;
using System.Linq;

namespace Demo
{
    class Program
    {
        static void Main(string[] args)
        {
            int count = 85160;
            var someNumbers = Enumerable.Range(0, count).ToList();
            var lists = PartitionToEqualSizedLists(someNumbers, 3);

            foreach (var list in lists)
            {
                Console.WriteLine("List length = " + list.Count);
            }

            Console.WriteLine("\nDone.");
            Console.ReadLine();
        }

        public static List<List<T>> PartitionToEqualSizedLists<T>(List<T> input, int numPartitions)
        {
            int blockSize = (input.Count + numPartitions - 1)/numPartitions;
            return input.Partition(blockSize).Select(partition => partition.ToList()).ToList();
        }
    }

    public static class EnumerableExt
    {
        public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> input, int blockSize)
        {
            var enumerator = input.GetEnumerator();

            while (enumerator.MoveNext())
            {
                yield return nextPartition(enumerator, blockSize);
            }
        }

        private static IEnumerable<T> nextPartition<T>(IEnumerator<T> enumerator, int blockSize)
        {
            do
            {
                yield return enumerator.Current;
            }
            while (--blockSize > 0 && enumerator.MoveNext());
        }
    }
}