如何在java中反转附加对象的序列

我的马车对象有两个变量，Nextwagon和Previouswagon。这些货车可以使用下一个和上一个货车变量相互连接。例如，如果我有4辆货车，则通过将第一辆货车的下一个边声明为货车2，将货车2连接到第一辆货车，并将第三辆货车连接到第二辆货车，依此类推

因此，我的顺序是1,2,3,4。我的问题是,；我想借助一个递归方法（结果应该是4,3,2,1。）来反转这个序列，我该如何实现呢

 /**
 * reverses the order in the sequence of wagons from this Wagon until its final successor.
 * The reversed sequence is attached again to the predecessor of this Wagon, if any.
 * no action if this Wagon has no succeeding next wagon attached.
 * @return the new start Wagon of the reversed sequence (with is the former last Wagon of the original sequence)
 */
public Wagon reverseSequence() {
    // TODO provide a recursive implementation


    return null;
}

如果我的方法正确，那么下面的代码应该通过测试

@Test
public void T05_WholeSequenceOfFourShouldBeReversed() {
    passengerWagon2.attachTo(passengerWagon1);
    passengerWagon3.attachTo(passengerWagon2);
    passengerWagon4.attachTo(passengerWagon3);

    // reverse full sequence
    Wagon rev = passengerWagon1.reverseSequence();

    assertEquals(4, rev.getSequenceLength());
    assertEquals(passengerWagon4, rev);
    assertEquals(passengerWagon3, rev.getNextWagon());
    assertFalse(rev.hasPreviousWagon());

    assertEquals(passengerWagon2, passengerWagon3.getNextWagon());
    assertEquals(passengerWagon4, passengerWagon3.getPreviousWagon());

    assertEquals(passengerWagon1, passengerWagon2.getNextWagon());
    assertEquals(passengerWagon3, passengerWagon2.getPreviousWagon());

    assertFalse(passengerWagon1.hasNextWagon());
    assertEquals(passengerWagon2, passengerWagon1.getPreviousWagon());
}

以下测试也应通过

@Test
public void T05_PartiallyReverseASequenceOfFour() {
    passengerWagon2.attachTo(passengerWagon1);
    passengerWagon3.attachTo(passengerWagon2);
    passengerWagon4.attachTo(passengerWagon3);

    // reverse part of the sequence
    Wagon rev = passengerWagon3.reverseSequence();
    assertEquals(2, rev.getSequenceLength());
    assertEquals(passengerWagon4, rev);

    assertEquals(passengerWagon3, rev.getNextWagon());
    assertEquals(passengerWagon2, rev.getPreviousWagon());

    assertFalse(passengerWagon3.hasNextWagon());
    assertEquals(passengerWagon4, passengerWagon3.getPreviousWagon());

    assertEquals(4, passengerWagon1.getSequenceLength());
    assertFalse(passengerWagon1.hasPreviousWagon());
    assertEquals(passengerWagon2, passengerWagon1.getNextWagon());

    assertEquals(passengerWagon1, passengerWagon2.getPreviousWagon());
    assertEquals(passengerWagon4, passengerWagon2.getNextWagon());
}

你可以看到这里发生了两件事：首先，我们开车到货车的尽头，挑选最后一辆货车。然后，我们把它拖到前面，每辆马车都连接到先前连接到它的马车上。瞧，货车倒过来了

---

（请注意，我不知道

.getNextWagon（）

和

.attachTo（）

实际上是什么，因为我无法访问您的源代码-我正在进行一个有根据的猜测，因此希望如果我错了，您可以意识到并纠正它，以获得您自己的解决方案）

我可能会迟到，但我有答案给您。但是，我不能用密码回答这个问题。因为这项作业是一个年级的作业，将在明年使用，是的，我来自同一所学校。：）

解决方案： 您必须从中获取最后一辆马车（GetLastWagonatached（）），并将此马车与其前辈（detachFromPrevious（））分离。如果最后一辆货车与当前货车相同，则必须自行返回

分离当前递归的最后一辆马车后，将其连接到被调用的递归的最后一辆马车（注意：每个递归都发生在同一辆马车上），然后返回当前递归的最后一辆马车

---

现在你已经颠倒了顺序。但未连接到列车的非反向部分。（注意：如果货车上有一个先前的序列）因此，由于您调用了同一货车上的递归，您可以将其附加到其原始的先前货车上。

这里基本上有一个链接列表。一个简单的搜索如何扭转链表将给你答案。虽然可以递归进行，但迭代进行要简单得多。我是提供这门课程的老师，我同意这条信息。

public Wagon reverseSequence() {
    // first, get the next wagon in the sequence
    Wagon nextWagon = this.getNextWagon();
    // if it is the last wagon in the train, then it should be the first wagon
    // in the new sequence. Return it. This is the recursive base case.
    if (nextWagon == null) {
        return this;
    }
    // otherwise, do three things:
    // (1) reverse the part of the wagon train after this
    // (2) attach this wagon to _after_ what was previously the next wagon,
    //       since after being reversed it will be at the end of the train
    //       before this wagon
    // (3) return the front of that wagon train
    Wagon front = nextWagon.reverseSequence();
    this.attachTo(nextWagon);
    return front;
}