旋转链表

/*
 * Problem: Rotate a linked list to the right by k positions using Java Streams.
 * Note: As Java Streams are typically used for collections, not linked lists, this solution
 * manually collects the list elements and then uses Streams for rotation.
 * Approach:
 * 1. Convert the linked list to a List.
 * 2. Calculate the effective rotations needed (k % length).
 * 3. Use Java Streams to manipulate the list.
 * 4. Reconstruct the linked list from the rotated list.
 */
 
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
 
class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}
 
public class RotateListStream {
    public ListNode rotateRight(ListNode head, int k) {
        if (head == null || k == 0) return head;
 
        // Convert linked list to list
        List<ListNode> nodes = new ArrayList<>();
        ListNode current = head;
        while (current != null) {
            nodes.add(current);
            current = current.next;
        }
 
        // Calculate effective rotations needed
        int length = nodes.size();
        k %= length;
        if (k == 0) return head;
 
        // Rotate the list using Streams
        List<ListNode> rotated = IntStream.concat(
                IntStream.range(length - k, length),
                IntStream.range(0, length - k))
                .mapToObj(nodes::get)
                .collect(Collectors.toList());
 
        // Reconstruct the linked list from rotated list
        for (int i = 0; i < rotated.size() - 1; i++) {
            rotated.get(i).next = rotated.get(i + 1);
        }
        rotated.get(rotated.size() - 1).next = null;
 
        return rotated.get(0);
    }
}