打印给定索引指定的给定链接列表的子列表

给定一个链表和两个索引A和B ，任务是打印一个从A开始到B结束的子列表。

例子：

Input: list = 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> 10 -> NULL, A = 3, B = 9 
Output: 3 4 5 6 7 8 9

Input: list = 1 -> 3 -> 4 -> 10 -> NULL, A = 2, B = 2 
Output: 3 

方法：
请按照以下步骤解决问题：

1. 创建三个实例变量：
   1. 当前：给定链表的头
   2. subcurrent：子列表的头
   3. subend：子列表的尾部。
2. 遍历链表并初始化一个index_count变量，该变量在每次迭代后递增。
3. 当index_count的值等于A时，将subcurrent设置为当前指向的节点。
4. 如果index_count等于B，则将subend分配给被引用的当前节点。将subend.next指向NULL表示子列表的末尾。
5. 将列表内容从subcurrent打印到subend 。

下面的代码是上述方法的实现：

Java

// Java Program to find the
// subList in a linked list
 
import java.util.Scanner;
 
// Class representing the
// structure of a Linked List
public class LinkedListSublist {
    Node head;
    class Node {
        int data;
        Node next = null;
        Node(int new_data)
        {
            data = new_data;
        }
    }
 
    // Function to push node
    // at beginning of a
    // Linked List
    public void pushNode(int new_data)
    {
        Node new_node = new Node(new_data);
        new_node.next = head;
        head = new_node;
    }
 
    // Function to find sublist
    public Node subList(Node head,
                        int A,
                        int B)
    {
        Node subcurrent = null;
        Node subend = null;
        Node current = head;
        int i = 1;
 
        // traverse between indices
        while (current != null
               && i <= B) {
 
            // If the starting index
            // of the sublist is found
            if (i == A) {
                subcurrent = current;
            }
 
            // If the ending index of
            // the sublist is found
            if (i == B) {
                subend = current;
                subend.next = null;
            }
 
            // Move to next node
            current = current.next;
            i++;
        }
 
        // Return the head
        // of the sublist
        return subcurrent;
    }
 
    // Function to print
    // the linked list
    public void traversing()
    {
        Node current = head;
        while (current != null) {
            System.out.print(current.data
                             + " -> ");
            current = current.next;
        }
    }
 
    // Driver Program
    public static void main(String args[])
    {
 
        LinkedListSublist list
            = new LinkedListSublist();
        int N = 1;
        int value = 10;
 
        while (N < 11) {
            list.pushNode(value--);
            N++;
        }
 
        // Starting index
        int A = 3;
 
        // Ending index
        int B = 9;
 
        list.head
            = list.subList(
                list.head, A, B);
        list.traversing();
    }
}

Python3

# Python3 program to find the
# subList in a linked list
class Node:
     
    def __init__(self, data):
         
        self.data = data
        self.next = None
  
# Class representing the
# structure of a Linked List
class LinkedListSublist:
     
    def __init__(self):
         
        self.head = None
     
    # Function to push node
    # at beginning of a
    # Linked List
    def pushNode(self, new_data):
         
        new_node = Node(new_data)
        new_node.next = self.head
        self.head = new_node
     
    # Function to find sublist
    def subList(self, head, A, B):
         
        subcurrent = None
        subend = None
        current = self.head
        i = 1
  
        # Traverse between indices
        while (current != None and i <= B):
  
            # If the starting index
            # of the sublist is found
            if (i == A):
                subcurrent = current
  
            # If the ending index of
            # the sublist is found
            if (i == B):
                subend = current
                subend.next = None
  
            # Move to next node
            current = current.next
            i += 1
  
        # Return the head
        # of the sublist
        return subcurrent
         
    # Function to print
    # the linked list
    def traversing(self):
     
        current = self.head
         
        while (current != None):
            print(current.data, end = " -> ")
            current = current.next
  
# Driver Code
if __name__=='__main__':
     
    list = LinkedListSublist()
  
    N = 1
    value = 10
 
    while (N < 11):
        list.pushNode(value)
        value -= 1
        N += 1
 
    # Starting index
    A = 3
 
    # Ending index
    B = 9
 
    list.head = list.subList(list.head, A, B)
    list.traversing()
     
# This code is contributed by pratham76

C#

// C# Program to find the
// subList in a linked list
using System;
 
// Class representing the
// structure of a Linked List
public class LinkedListSublist
{
     
    public Node head;
    public class Node
    {
        public int data;
        public Node next = null;
        public Node(int new_data)
        {
            data = new_data;
        }
    }
  
    // Function to push node
    // at beginning of a
    // Linked List
    public void pushNode(int new_data)
    {
        Node new_node = new Node(new_data);
        new_node.next = head;
        head = new_node;
    }
  
    // Function to find sublist
    public Node subList(Node head,
                        int A,
                        int B)
    {
        Node subcurrent = null;
        Node subend = null;
        Node current = head;
        int i = 1;
  
        // traverse between indices
        while (current != null
               && i <= B)
        {
  
            // If the starting index
            // of the sublist is found
            if (i == A)
            {
                subcurrent = current;
            }
  
            // If the ending index of
            // the sublist is found
            if (i == B)
            {
                subend = current;
                subend.next = null;
            }
  
            // Move to next node
            current = current.next;
            i++;
        }
  
        // Return the head
        // of the sublist
        return subcurrent;
    }
  
    // Function to print
    // the linked list
    public void traversing()
    {
        Node current = head;
        while (current != null)
        {
            Console.Write(current.data
                             + " -> ");
            current = current.next;
        }
    }
  
    // Driver Program
    public static void Main(string []args)
    {
  
        LinkedListSublist list
            = new LinkedListSublist();
        int N = 1;
        int value = 10;
  
        while (N < 11)
        {
            list.pushNode(value--);
            N++;
        }
  
        // Starting index
        int A = 3;
  
        // Ending index
        int B = 9;
  
        list.head
            = list.subList(
                list.head, A, B);
        list.traversing();
    }
}
 
// This code is contributed by rutvik_56

输出：

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

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