Java 链表连接

一个名为concat的方法正在为分配和一个需求创建链表，该方法接受一个列表参数并将其附加到当前列表的末尾。这种方法没有必要使用递归，但我们的程序应该大量使用递归。我只是想知道是否有可能想出一个递归算法来解决这个问题。我们的列表类只有一个头节点，没有其他节点，并且它们没有双重链接

我当前的尝试只能递归地追加第一个值。我知道它做错了什么，但我想不出解决办法。第一个方法是在列表上实际调用的方法，该列表被传递到“连接”中。然后，我尝试找到列表的尾部，并将其传递给递归方法。这种“包装器”方法是递归方法的强制性要求。这是我的尝试，但显然失败了，因为一旦所有调用从堆栈中弹出，然后重新进入对concat的递归调用，我就很难将节点引用“pt”推进到列表中的下一个节点。如果这在递归中是可能的，您能告诉我如何在第一个列表中提升该值，并重新输入递归调用，或者可能是解决此问题的更好的一般方法吗？谢谢你抽出时间

public void concat(MyString list1) {
    CharacterNode tail = null, pt = list1.head;
    // Find the tail of the list
    if (pt == null) {
    } else if (pt.getNext() == null) {
        tail = pt;
    } else {
        while (pt.getNext() != null) {
            pt = pt.getNext();
        }
        tail = pt;
    }
    list1.head = concat(list1.head, tail, list1.head);
}
private static CharacterNode concat(CharacterNode lhead, CharacterNode tail, CharacterNode pt) {
    // Pass in smaller list every time
    // Head traverses down list till the end
    // Add new node with (pt's letter, null link)
    if (lhead == null) {
    // If head is null, we need to add the node
        lhead = new CharacterNode(pt.getCharacter(),null);
    } else if (tail.getNext() == lhead) {
    // If the head is past tail, stop   
    } else {
        // Call concat on a smaller list
        lhead.setNext(concat(lhead.getNext(),tail,pt));
    }
    return lhead;
}

以下是CharacterNode：

class CharacterNode {
    private char letter;
    private CharacterNode next;

    public CharacterNode(char ch, CharacterNode link) {
        letter = ch;
        next = link;
    }

    public void setCharacter(char ch) {
        this.letter = ch;
    }

    public char getCharacter() {
        return letter;
    }

    public void setNext(CharacterNode next) {
        this.next = next;
    }

    public CharacterNode getNext() {
        return next;
    }
}

MyString：

class MyString {
    // member variable pointing to the head of the linked list
    private CharacterNode head;

    // default constructor
    public MyString() {
    }

    // copy constructor
    public MyString(MyString l) {
    }

    // constructor from a String
    public MyString(String s) {
    }

    // for output purposes -- override Object version
    // no spaces between the characters, no line feeds/returns
    public String toString() {
    }

    // create a new node and add it to the head of the list
    public void addHead(char ch) {
    }

    // create a new node and add it to the tail of the list -- "wrapper"
    public void addTail(char ch) {
    }

    // Recursive method for addTail
    private static CharacterNode addTail(CharacterNode L, char letter) {
    }

    // modify the list so it is reversed
    public void reverse() {
    }

    // remove all occurrences of the character from the list -- "wrapper"
    public void removeChar(char ch) {
    }

    // Recursive removeChar method
    private static CharacterNode removeChar(CharacterNode n, char letter) {
    }

    // "wrapper" for recursive length()
    public int length() {
    }

    // Returns the length of the linked list
    private static int length(CharacterNode L) {
    }

    // concatenate a copy of list1 to the end of the list
    public void concat(MyString list1) {
    }

    // recursive method for concat
    private static CharacterNode concat(CharacterNode lhead, CharacterNode tail, CharacterNode pt) {
    }
}

---

要连接两个链表，必须使第一个列表的最后一个节点指向第二个列表的第一个节点

Node first_list = ...  // head node
Node second_list = ... // head node
...
Node last_node = first_list.getLastNode()
last_node.setNext(second_list)

---

现在集中精力实现

getLastNode（）

。可以非常简单地使用递归或迭代，确切地说是两行。

除非我们看到MyString和CharacterNode的定义，否则我们无法回答这个问题。作为旁注，因为递归是程序的一个关键概念（并且您会问在您的情况下是否可以使用递归），所以您可以迭代（使用循环）执行任何操作，您也可以递归执行，反之亦然。@Ingo为您添加了这两个选项@ajp15243谢谢，我不知道迭代解可以用递归做什么。很高兴知道！谢谢你这么快的回复！这似乎奏效了！：）