用于剪切链接列表的一部分并将其附加到列表末尾的函数实现

Question

考虑以下函数：

void CustomAppender(int totalNodesToSkip, int totalNodesToCut);

这里totalNodesToSkip 和totalNodesToCut 都是给定的输入。所以需要从 totalNodesToSkip 编号的节点开始切割长度为 totalNodesToCut 的给定链表的一部分。

考虑以下列表：

List_1:a->b->c->d->e->f->g->h->i->j->k

函数的输入是CustomAppender(2,3)。

那么在第一遍中，列表应该变成：

List_2: a->b->f->g->h->i->j->k->c->d->e. 所以这里 c->d->e 部分移到了尾部。这个过程需要重复，直到我们到达给定列表的末尾。也就是说，当我们到达列表 1 的节点“k”时，我们需要停止。

解决这个问题的简单方法是根据给定的输入取要切割的部分： 在 *Marker 中保持一个标记到终点“k”。

1. *startPTR 指向节点 c.

2. *endPTR 指向节点 e。 （两者都可以使用给定的输入进行迭代。）

3. 点 b 节点下一个作为 endPTR 的下一个。

4. 'k' 节点的下一个指向 startPTR。

5. 最后 endPTR 指向 NULL。

6. 可以重复上述步骤，直到到达标记。

这工作正常。

但我的问题是无论如何以任何不同的方式实现它，以便我使用更少的指针和更快的方法。由于此过程需要 O(n^2) 运行时间。

请建议任何其他方式。

Answer 1

您可以在列表中一次性完成。

starting at the head of the list, move forward `(skip-1)` nodes. Call this `skip_ptr`.
start another pointer, call it `glue_ptr`. Move it forward `(cut-1)` nodes.

此时，skip_ptr 引用最后一个要跳过的节点，glue_ptr 引用最后一个要剪切的节点。

现在，将它们粘在一起并标记切割清单的结尾。

cut_ptr = skip_ptr.next;  // save c->d->e
skip_ptr.next = glue_ptr.next; // attach a->b to f->g ...
glue_ptr.next = null; // mark e as the end of the cut list

所以现在你有a->b->f->g->h->i->j->k，并且cut_ptr 指向c->d->e。

现在，如果您设置glue_ptr = skip_ptr.next 并将glue_ptr 向前移动到glue_ptr.next == null，那么您可以编写：

glue_ptr.next = cut_ptr;  // attaches the cut part to the end of the list

您只需要跟踪各个部分。但它一次完成操作：O(n)。

更新

如果你必须反复跳过并剪切到原来的列表：

a,b,c,d,e,f,g,h,i,j,k

变成

a,b,f,g,k,c,d,e,h,i,j

您仍然可以通过单次遍历列表来完成此操作。这是显示它是如何完成的 C# 代码。应该很容易转换为 C。

private void CustomAppender(LLNode list, int skip, int cut)
{
    LLNode skip_ptr = list;
    LLNode cut_list = null;
    LLNode cut_ptr = null;

    while (skip_ptr.Next != null)
    {
        // skip over 'skip' items
        for (int i = 1; i < skip && skip_ptr.Next != null; ++i)
        {
            skip_ptr = skip_ptr.Next;
        }

        // skip_ptr.next is the start of the next group we want to cut.
        // move forward to the last node to be cut.
        for (int i = 0; i < cut && skip_ptr.Next != null; ++i)
        {
            LLNode nodeToCut = skip_ptr.Next;
            skip_ptr.Next = nodeToCut.Next;
            nodeToCut.Next = null;
            if (cut_list == null)
            {
                cut_list = nodeToCut;
            }
            else
            {
                cut_ptr.Next = nodeToCut;
            }
            cut_ptr = nodeToCut;
        }
        if (skip_ptr.Next != null)
            skip_ptr = skip_ptr.Next;
    }
    // So now we have two lists.
    // skip_ptr points to the last node in the list.
    // Append cut_list to the end.
    skip_ptr.Next = cut_list;
}

Answer 2

i 首先计算元素的总数。因为我们必须将元素分成 3 个链。现在从总数中减去跳过的数字。作为分裂链，即

  a->b c->d->e->f-g->h->i->j->k

现在，我们还剩下号码。现在取剩余数的模数。如果模块为 0，则在计数后从最后一个拆分出来的数字什么也不做。

如上所述，您已经采取了 3，因此不需要任何操作来反转事物，但在 2 中，拆分为：

a->b c->d->e->f-g->h->i->j k

现在将最后一个元素链更改为第二个元素链：

 a->b k c->d->e->f-g->h->i->j

现在合并它们

 a->b->k->c->d->e->f-g->h->i->j