在特定给定大小的组中反转给定的链接列表

给定链表和大小为N的数组arr[] ，任务是一次反转列表的每个arr[i]节点(0 ≤ i < N) 。

注意：如果列表中的节点数大于数组的总和，则其余节点将保持原样。

例子：

Input: head = 1->2->3->4->5->6->7->8->9, arr[] = {2, 3, 3}
Output: 2->1->5->4->3->8->7->6->9
Explanation: The first group of size 2 is 1->2. Upon reversing it becomes 2->1.
The next group of size 3 is 3->4->5 which on reversing becomes 5->4->3.
The last group of size 3 is 6->7->8 which on reversing becomes 8->7->6.

Input: head = 6->8->7, arr[] = {1, 2}
Output: 6->7->8

方法：该问题的解决方案是基于选择arr[i]大小的节点组并将每个子列表视为单独的链表并使用反转链表的概念的想法。

请按照下图更好地理解：

插图：

反向（头，arr，n，索引）

按照下面提到的步骤来实现这个想法：

• 从i = 0 到 N遍历数组：
  • 反转大小arr[i]的子列表。
    • 在反转子列表时，对于每个节点，交换指向下一个节点和前一个节点的指针。
• 如果到达数组的末尾，则停止迭代并返回最终列表的头指针。

下面是上述方法的实现。

C#

// C# code to implement the approach
  
using System;
using System.Linq;
public class LinkedList {
    Node head;
  
    // Node Class
    class Node {
        public int data;
        public Node next;
        public Node(int d)
        {
            data = d;
            next = null;
        }
    }
  
    // Function to reverse a node
    Node reverse(Node head, int[] arr, 
                 int size, int index)
    {
        if (head == null)
            return null;
  
        Node current = head;
        Node next = null;
        Node prev = null;
  
        int count = 0;
        while (current != null 
               && index < size
               && count < arr[index]) {
            next = current.next;
            current.next = prev;
            prev = current;
            current = next;
            count++;
        }
  
        if (index >= size) {
            while (current != null) {
                next = current.next;
                current.next = prev;
                prev = current;
                current = next;
                count++;
            }
        }
  
        if (next != null) {
            head.next 
                = reverse(next, arr, 
                          size, index + 1);
        }
  
        return prev;
    }
  
    // Function to push a node
    public void push(int new_data)
    {
        Node new_node = new Node(new_data);
        new_node.next = head;
        head = new_node;
    }
  
    // Function to print list
    void printList()
    {
        Node temp = head;
        while (temp != null) {
            Console.Write(temp.data + "->");
            temp = temp.next;
        }
        Console.WriteLine();
    }
  
    // Driver code
    static void Main()
    {
        LinkedList llist = new LinkedList();
        int[] arr = { 2, 3, 3 };
        int size = arr.Count();
  
        llist.push(9);
        llist.push(8);
        llist.push(7);
        llist.push(6);
        llist.push(5);
        llist.push(4);
        llist.push(3);
        llist.push(2);
        llist.push(1);
  
        llist.head
            = llist.reverse(llist.head, 
                            arr, size, 0);
  
        llist.printList();
    }
}

输出

2->1->5->4->3->8->7->6->9->

时间复杂度： O(N)
辅助空间： O(1)