C# 将三个文件合并为一个大文件
假设我们有三个数组C# 将三个文件合并为一个大文件,c#,algorithm,C#,Algorithm,假设我们有三个数组 int a[]=new int[]{4,6,8,9,11,12}; int b[]=new int[]{3,5,7,13,14}; int c[]=new int[]{1,2,15,16,17}; 我们想把它合并成一个大的d数组,其中d.length=a.length+b.length+c.length 但是我们有内存问题,这意味着我们必须只使用这个d数组,我们应该合并这三个数组,当然我们可以使用合并排序,但是我们可以使用合并算法而不使用排序方法吗?就像两个排序的数组一样,
int a[]=new int[]{4,6,8,9,11,12};
int b[]=new int[]{3,5,7,13,14};
int c[]=new int[]{1,2,15,16,17};
我们想把它合并成一个大的d数组,其中d.length=a.length+b.length+c.length但是我们有内存问题,这意味着我们必须只使用这个d数组,我们应该合并这三个数组,当然我们可以使用合并排序,但是我们可以使用合并算法而不使用排序方法吗?就像两个排序的数组一样,我们可以合并到一个排序的数组中,那么三个或更多的数组呢?您的意思是将它们按升序放在一个数组中 您可以将它们全部复制,然后进行bubblesort或insertsort
如果它们已排序,则可以使用mergesort中使用的相同合并算法。每个数组都需要一个索引指针。在每个步骤中,在各自的索引处选择所有数组中的最小值,将其插入目标表,并增加源数组的索引。您的问题有点不清楚,但接下来是
- 如果可以合并2个数组,那么2个合并将把3个数组合并为1个数组李>
- 但是一次合并3个数组也不难李>
- 如果你的数组太大而无法存储在内存中,你将不得不使用外部排序算法和合并算法,谷歌搜索,你会发现大量的材料李>
- 您当然可以合并而不进行排序,但结果不会被排序
如有必要,请编辑您的问题,我会尽力提供更多帮助。合并排序与3个或更多数组同样有效。要构建d,请继续在a、b和c的开头添加最低值。拆下该元件,重复
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
int a[]=new int[]{4,6,8,9,11,12};
int b[]=new int[]{3,5,7,13,14};
int c[]=new int[]{1,2,15,16,17};
foreach (int element in a)
{
Console.WriteLine(element);
}
foreach (int element in b)
{
Console.WriteLine(element);
}
foreach (int element in c)
{
Console.WriteLine(element);
}
var list = new List<int>();
list.AddRange(a);
list.AddRange(b);
list.AddRange(c);
int[] d = list.ToArray();
foreach (int element in d)
{
Console.WriteLine(element);
}
}
使用系统;
使用System.Collections.Generic;
班级计划
{
静态void Main()
{
int a[]=新int[]{4,6,8,9,11,12};
int b[]=新int[]{3,5,7,13,14};
int c[]=新int[]{1,2,15,16,17};
foreach(a中的int元素)
{
控制台写入线(元素);
}
foreach(b中的int元素)
{
控制台写入线(元素);
}
foreach(c中的int元素)
{
控制台写入线(元素);
}
var list=新列表();
列表。添加范围(a);
列表。添加范围(b);
列表。添加范围(c);
int[]d=list.ToArray();
foreach(d中的int元素)
{
控制台写入线(元素);
}
}
如果您只想连接阵列,可以创建目标阵列并将数据复制到其中:
int[] d = new int[a.Length + b.Length + c.Length];
a.CopyTo(d, 0);
b.CopyTo(d, a.Length);
c.CopyTo(d, a.Length + b.Length);
这将具有最小的开销,因为只分配所需的大小。例如,如果您将项目添加到列表中
,它将随着阵列的增长而分配越来越大的阵列,并且最终容量将大于所需容量