单向链表求长度java

单向链表是一种重要的数据结构，它的存储空间是不连续的。单向链表的长度可以通过遍历链表的方式进行求解。我们可以从头结点开始，依次遍历链表的每个节点，并在遍历的过程中累计计数器的值，直到遍历到链表的末尾节点为止。最后所得的计数器的值就是单向链表的长度。

下面是一个示例代码来实现求解单向链表长度的功能：

public int getLength() {
    int count = 0;
    ListNode<T> cur = head; // 从头结点开始
    while (cur != null) { // 遍历链表，直到遍历到末尾节点
        count++; // 计数器加一
        cur = cur.next; // 继续遍历下一个节点
    }
    return count; // 返回链表的长度
}

相关问题

fun计算带有头结点的单向链表

在计算机编程中，特别是涉及到数据结构的时候，"fun计算带有头结点的单向链表"通常是指计算链表的一些特定值，比如长度、和、最大值等。链表是一种线性数据结构，每个节点包含两个部分：存储的数据和指向下一个节点的指针。对于带头结点的链表，头结点通常是一个特殊的节点，它既没有前驱也没有数据。

例如，如果你有一个`ListNode`类型的链表，你可以定义一个名为`funCompute`的方法来实现：

1. **计算链表长度**：

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

2. **计算链表和**：

   int sum(ListNode head) {
       int total = 0;
       ListNode temp = head;
       while (temp != null) {
           total += temp.val;
           temp = temp.next;
       }
       return total;
   }

3. **找到最大值**：

   int max(ListNode head) {
       if (head == null || head.next == null) {
           return head.val;
       }
       int maxVal = head.val;
       ListNode curr = head.next;
       while (curr != null) {
           if (curr.val > maxVal) {
               maxVal = curr.val;
           }
           curr = curr.next;
       }
       return maxVal;
   }

用链表解决约瑟夫问题Java代码

约瑟夫环问题是这样的：在一个有n个人的圈子里，从第一个人开始报数，每个人报到k后出圈，然后下一个人继续，直到最后剩下的人赢得游戏。你可以使用Java的链表来模拟这个过程，每个节点代表一个人，并维护一个指向下一个节点的引用。

以下是一个简单的Java代码示例，使用单向链表实现约瑟夫环问题：

public class JosephusRing {
    static class Node {
        int value;
        Node next;

        public Node(int value) {
            this.value = value;
            this.next = null;
        }
    }

    public static Node josephusProblem(int n, int k) {
        if (n <= 0 || k <= 0) {
            throw new IllegalArgumentException("Invalid input: n and k must be positive integers");
        }

        // 创建一个长度为n的环形链表
        Node[] nodes = new Node[n];
        for (int i = 0; i < n; i++) {
            nodes[i] = new Node(i + 1);
            if (i != 0) {
                nodes[i - 1].next = nodes[i];
            } else {
                nodes[n - 1].next = nodes[0]; // 给最后一个节点指向前一个节点形成环
            }
        }

        // 开始计数并删除节点
        Node current = nodes[0];
        while (nodes.length > 1) {
            current = current.next;
            current = current.next % k == 0 ? current : current.next; // 报数达到k就跳过当前节点
        }

        return current;
    }

    public static void main(String[] args) {
        int n = 7; // 人数
        int k = 3; // 报数步长
        System.out.println(josephusProblem(n, k).value); // 输出最后幸存者的位置
    }
}

在这个代码中，`josephusProblem`函数创建了一个环形链表，然后通过循环移除节点，直到只剩下一个。当找到的节点需要跳过k个位置时，它会直接跳到下一个节点，直到找到第一个不需要跳过的节点，这就是幸存者。