Question

我正在考虑为考试做准备的例子，坦率地说，我对递归或列表不是很了解，但特别是列表。

给出一个节点类，它将保存字符串（不是通用的）编写一个名为concat的递归java函数，该函数接受一个表示链表头部的节点，并返回表示列表中所有元素串联的字符串。列表是空的，字符串也应该是。

任何帮助都将不胜感激。

（以下是我在提出问题之前输入的内容：）

public static String FindConcat(Node head) {
    String s = "";
    if(head == null) return s;
    else if(head.next = null) {
        s += head.data;
        return s;
    }
    else {

    }

}

感谢回复。

Answer 1

在这种情况下，递归是找到基本情况以及如何将数据“分离”到这个基本情况。所以首先要定义你的“基础案例”。

基本情况：函数的参数为null
直到获得基本案例，追加节点文本并跳过第一个元素

这是你的方法：

public static String FindConcat(Node head) {
    if (head == null) 
        return ""; // base case

    // devide it down (run recursive FindConcat on the _next_ node)
    return head.data + FindConcat(head.next);
}

这个简单的例子将打印hello this is a linked list：

public class Test {
    // this is a very basic Node class
    static class Node {
        String text;
        Node next;

        public Node(String text) {
            this.text = text;
        }
        // used for building the list
        public Node add(String text) {
            next = new Node(text);
            return next;
        }
    }

    // this is the recursive method concat
    public static String concat(Node node) {
        if (node == null)
            return "";

        return node.text + " " + concat(node.next);
    }

    public static void main(String[] args) {
        // build the list
        Node head = new Node("hello");
        head.add("this").add("is").add("a").add("linked").add("list");

        // print the result of concat
        System.out.println(concat(head));
    }
}

Answer 2

如果您的节点为null，则返回一个空字符串。

否则，获取字符串，进行递归调用（以获取其余节点的连接结果），并将其附加到字符串并返回结果。

Answer 3

因为这听起来像是家庭作业，所以我会提出建议。

首先编写一个方法，如果列表只有一个元素（即没有下一个节点），它将起作用。使用它作为递归调用的基础。

Answer 4

链接列表的递归遍历通常看起来像是在列表的末尾（你得到的引用是null），如果你不是，那么做一些递归调用列表的下一个元素，如果你是，做基本情况的事情。假设节点从外面看起来像这样：

public class Node{
    public Node getNext();
    public String toString();
}

...你的方法看起来像这样（在你用来运行它的类中）：

public String concatList(Node head){
    if(head == null){
        return ""; //empty list is a null pointer: return empty string
    }
    return head.toString() + concatList(head.getNext());
}

列表的末尾，或根本没有列表，看起来是相同的 - 空指针 - 并返回指定的空字符串;其他所有内容都使用当前节点并将其连接到通过获取字符串的整个剩余部分的连接版本而创建的列表。

要小心：如果某些内容损坏了你的列表所以它实际上是一个循环，它没有检查它并将永远运行直到它耗尽堆栈内存，除非Java正确检测到这个递归函数的循环优化并且它将简单永远地跑。

Answer 5

这是一个非常完整的例子：

import java.util.Arrays;
import java.util.List;
import java.util.UUID;

public class RecurisveLinkedListExample
{
    public static String concat(final Node node)
    {
        if (node == null)
        {
            return "";
        }
        else
        {
            return node.getData() + concat(node.getNext());
        }
    }

    public static void main(String[] args)
    {
        final List<String> input = Arrays.asList("A", "B", "C", "D");
        final Node head = new Node(null, input.get(0));
        Node previous = head;
        for (int i = 1; i < input.size(); i++)
        {
            previous = previous.addNext(input.get(i));
        }

        System.out.println(concat(head));
    }

    public static class Node
    {
        private final UUID id;
        private final Node previous;
        private final String data;
        private Node next;

        public Node(final Node previous, final String data)
        {
            this.previous = previous;
            this.data = data;
            this.next = null;
            this.id = UUID.randomUUID();
        }

        public Node getPrevious()
        {
            return previous;
        }

        public String getData()
        {
            return data;
        }

        public Node addNext(final String data)
        {
            this.next = new Node(this, data);
            return this.next;
        }

        public Node getNext()
        {
            return next;
        }

        @Override
        public String toString()
        {
            return String.format("%s:%s:%s", 
                   this.previous == null ? "HEAD" : this.previous.id, 
                   this.data, 
                   this.next == null ? "TAIL" : this.next.id);
        }
    }
}

如何递归地连接字符串元素列表

5 个答案: