c# - 如何在保持内部顺序的同时将2个已排序的列表合并到一个混洗列表中

Question

我想生成一个混杂的合并列表，以保持列表的内部顺序。

例如：

列表 A：11 22 33

列表 B：6 7 8

有效结果： 11 22 6 33 7 8

无效结果：22 11 7 6 33 8

Answer 1

只需随机选择一个列表（例如，如果<0.5列表A，则生成0到1之间的随机数，否则生成列表B），然后从该列表中获取元素并将其添加到新列表中。 重复直到每个列表中都没有元素。

Answer 2

在区间[0， B.Length ）中生成A.Length随机整数。 对随机数进行排序，然后从0..A.Length将A[i]加到B位置r[i]+i迭代i 。 +i是因为当您从A插入值时，您正在将B的原始值向右移动。

这将与您的RNG一样随机。

Answer 3

原始答案：

static IEnumerable<T> MergeShuffle<T>(IEnumerable<T> lista, IEnumerable<T> listb)
{
    var first = lista.GetEnumerator();
    var second = listb.GetEnumerator();

    var rand = new Random();
    bool exhaustedA = false;
    bool exhaustedB = false;
    while (!(exhaustedA && exhaustedB))
    {
        bool found = false;
        if (!exhaustedB && (exhaustedA || rand.Next(0, 2) == 0))
        {
             exhaustedB = !(found = second.MoveNext());
            if (found)
                yield return second.Current;
        }
        if (!found && !exhaustedA)
        {
            exhaustedA = !(found = first.MoveNext());
            if (found)
                yield return first.Current;
        }
    }                
}

基于marcog的答案的第二个答案

    static IEnumerable<T> MergeShuffle<T>(IEnumerable<T> lista, IEnumerable<T> listb)
    {
        int total = lista.Count() + listb.Count();
        var random = new Random();
        var indexes = Enumerable.Range(0, total-1)
                                .OrderBy(_=>random.NextDouble())
                                .Take(lista.Count())
                                .OrderBy(x=>x)
                                .ToList();

        var first = lista.GetEnumerator();
        var second = listb.GetEnumerator();

        for (int i = 0; i < total; i++)
            if (indexes.Contains(i))
            {
                first.MoveNext();
                yield return first.Current;
            }
            else
            {
                second.MoveNext();
                yield return second.Current;
            }
    }

Answer 4

如果您需要将输出均匀分布，则此页面中提供的答案均无效。

为了说明我的示例，假设我们要合并两个列表A=[1,2,3] ， B=[a,b,c]

在大多数答案中提到的方法中（即，将两个列表合并为la mergesort，但每次都随机选择一个列表头），输出[1 a 2 b 3 c]可能性远小于[1 2 3 abc] 。 直观上，发生这种情况是因为当列表中的元素用完时，另一个列表中的元素会附加在末尾。 因此，第一种情况的概率为0.5*0.5*0.5 = 0.5^3 = 0.125 ，但是在第二种情况下，存在更多的随机事件，因为必须随机选择5次头部，而不仅仅是3次，剩下的概率为0.5^5 = 0.03125 。 经验评估也可以轻松地验证这些结果。

@marcog建议的答案几乎是正确的。 但是，存在对r进行排序后r的分布不均匀的问题。 发生这种情况是因为原始列表[0,1,2] ， [2,1,0]和[2,1,0]都被排序为[0,1,2]，这使得排序后的r比例如， [0,0,0]仅有一种可能性。

有一种巧妙的方式来生成列表r ，使其均匀分布，如以下Math StackExchange问​​题所示： https ://math.stackexchange.com/questions/3218854/randomly-generate-a-sorted- 设置有均匀的分布

要总结该问题的答案，必须采样| B |。 集合{0,1,..|A|+|B|-1}元素（均匀，随机且无重复），对结果进行排序，然后将其索引减去此新列表中的每个元素。 结果是列表r ，可用于替换@marcog的答案。

Answer 5

除了生成索引列表之外，还可以根据每个列表中剩余的元素数来调整概率，从而完成此操作。 在每次迭代中，A将剩余A_size个元素，B将剩余B_size个元素。 从1 ..（A_size + B_size）中选择一个随机数R。 如果R <= A_size，则使用A中的元素作为输出中的下一个元素。 否则，请使用B中的元素。

int A[] = {11, 22, 33}, A_pos = 0, A_remaining = 3;
int B[] = {6, 7, 8}, B_pos = 0, B_remaining = 3;

while (A_remaining || B_remaining) {
  int r = rand() % (A_remaining + B_remaining);

  if (r < A_remaining) {
    printf("%d ", A[A_pos++]);
    A_remaining--;
  } else {
    printf("%d ", B[B_pos++]);
    B_remaining--;
  }
}

printf("\n");

随着列表变小，从中选择元素的可能性会降低。

可以缩放到多个列表。 例如，给定列表A，B和C的大小分别为A_size，B_size和C_size，请在1 ..（A_size + B_size + C_size）中选择R。 如果R <= A_size，则使用A中的元素。否则，如果R <= A_size + B_size，则使用B中的元素。否则，C。

Answer 6

这是一个确保输出均匀分布的解决方案，并且很容易说明原因。 首先想到的是生成令牌列表，其中每个令牌代表特定列表的一个元素，而不是特定元素。 例如，对于两个具有3个元素的列表，我们生成以下令牌列表：0、0、0、1、1、1。然后，对令牌进行洗牌。 最后，我们为每个令牌生成一个元素，然后从相应的原始列表中选择下一个元素。

public static IEnumerable<T> MergeShufflePreservingOrder<T>(
    params IEnumerable<T>[] sources)
{
    var random = new Random();
    var queues = sources
        .Select(source => new Queue<T>(source))
        .ToArray();
    var tokens = queues
        .SelectMany((queue, i) => Enumerable.Repeat(i, queue.Count))
        .ToArray();
    Shuffle(tokens);
    return tokens.Select(token => queues[token].Dequeue());

    void Shuffle(int[] array)
    {
        for (int i = 0; i < array.Length; i++)
        {
            int j = random.Next(i, array.Length);
            if (i == j) continue;
            if (array[i] == array[j]) continue;
            var temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    }
}

用法示例：

var list1 = "ABCDEFGHIJKL".ToCharArray();
var list2 = "abcd".ToCharArray();
var list3 = "@".ToCharArray();
var merged = MergeShufflePreservingOrder(list1, list2, list3);
Console.WriteLine(String.Join("", merged));

输出：

ABCDaEFGHIb @ cJKLd

Answer 7

这可能更容易，假设您有一个包含三个值的列表，以便匹配另一个表中的 3 个值。 您还可以使用身份 (1,2) 对身份进行排序

Create TABLE #tmp1 (ID int identity(1,1),firstvalue char(2),secondvalue char(2))
Create TABLE #tmp2 (ID int identity(1,1),firstvalue char(2),secondvalue char(2))

Insert into #tmp1(firstvalue,secondvalue) Select firstvalue,null secondvalue from firsttable

Insert into #tmp2(firstvalue,secondvalue) Select null firstvalue,secondvalue from secondtable

Select a.firstvalue,b.secondvalue from #tmp1 a join #tmp2 b on a.id=b.id

DROP TABLE #tmp1
DROP TABLE #tmp2