Java整数链表创建、打印及长度计算优化方法咨询

原问题场景 #

作为从C#转Java学习编程挑战的开发者，当前通过带初始值参数的递归方法计算链表长度，调用时必须传入0作为初始长度，而C#中可选参数可以轻松避免这个问题，想了解Java的更优实现方式。

原代码实现：

// Simple linked list class
public class ListNode {
    int val;
    ListNode next;

    ListNode(int val) {
        this.val = val;
    }
}

// Build a linked list of ints of a given length
public static ListNode buildLinkedList(int length) {
    ListNode head = new ListNode(1);
    ListNode currNode = head;
    for (int i = 2; i <= length; i++) {
        System.out.println("i = " + i);
        currNode.next = new ListNode(i);
        currNode = currNode.next;
    }
    return head;
}

// Calculate the length
static int getLinkedListLength(ListNode head, int length) {
    if (head == null) {
        return length;
    }
    length++;
    return getLinkedListLength(head.next, length);
}

// Print the linked list
public static void printLinkedList(ListNode node) {
    System.out.print("Linked list = [");

    while (node.next != null) {
        System.out.print(node.val + ", ");
        node = node.next;
    }
    System.out.print(node.val);
    System.out.print("]");
    System.out.println();
}

// Test code
ListNode node = LinkedLists.buildLinkedList(5);
printLinkedList(node);
System.out.println("Length: " + getLinkedListLength(node, 0));

几种更优实现方案 #

1. 优化递归逻辑（无需初始参数） #

直接在递归中计算当前节点贡献的长度，无需外部传入初始值，调用更简洁：

static int getLinkedListLength(ListNode head) {
    // 基准情况：空链表长度为0
    if (head == null) {
        return 0;
    }
    // 当前节点占1个长度，加上后续链表的长度
    return 1 + getLinkedListLength(head.next);
}

调用时只需：

System.out.println("Length: " + getLinkedListLength(node));

2. 方法重载（兼容原有递归逻辑） #

如果想保留带参数的递归实现，可通过重载方法隐藏初始值的传递，对外提供简洁的调用入口：

// 对外公开的方法，无需传入初始值
public static int getLinkedListLength(ListNode head) {
    return getLinkedListLengthRecursive(head, 0);
}

// 私有递归方法，处理核心逻辑
private static int getLinkedListLengthRecursive(ListNode head, int length) {
    if (head == null) {
        return length;
    }
    return getLinkedListLengthRecursive(head.next, length + 1);
}

调用时同样只需传入head：getLinkedListLength(node)

3. 迭代实现（避免栈溢出风险） #

对于超长链表，递归可能引发StackOverflowError，迭代实现更稳定高效：

static int getLinkedListLength(ListNode head) {
    int length = 0;
    ListNode current = head;
    while (current != null) {
        length++;
        current = current.next;
    }
    return length;
}

补充说明 #

Java没有像C#那样的可选参数语法（Java 8+的接口默认方法不适用于这种场景），所以最常用的替代方式就是方法重载或者优化递归逻辑。另外，编程挑战中迭代实现往往更稳妥，因为递归深度受限（比如链表长度超过1万时，递归会触发栈溢出）。

内容的提问来源于stack exchange，提问作者wayne.blackmon