反转链表的子列表

我们得到一个链表和位置 m 和 n。我们需要将链表从位置 m 反转到 n。

例子：

Input : 10->20->30->40->50->60->70->NULL
        m = 3, n = 6
Output : 10->20->60->50->40->30->70->NULL

Input :  1->2->3->4->5->6->NULL 
         m = 2, n = 4
Output : 1->4->3->2->5->6->NULL

为了将链表从位置 m 反转到 n，我们通过运行循环找到链表的开始和结束位置的地址，然后我们将这部分与链表的其余部分取消链接，然后使用正常的链表反转函数前面我们用过反转完整链表，用它来反转链表中需要反转的部分。反转后，我们再次将反转的部分附加到主列表中。

C++

// C++ program to reverse a linked list
// from position m to position n
#include 
#include 
 
// Linked list node
struct Node {
    int data;
    struct Node* next;
};
 
// the standard reverse function used
// to reverse a linked list
struct Node* reverse(struct Node* head)
{
    struct Node* prev = NULL;   
    struct Node* curr = head;
 
    while (curr) {
        struct Node* next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}
 
// function used to reverse a linked list
// from position m to n which uses reverse
// function
Node* reverseBetween(Node* head, int m, int n)
{
    if (m == n)
        return head;
 
    // revs and revend is start and end respectively
    // of the portion of the linked list which
    // need to be reversed. revs_prev is previous
    // of starting position and revend_next is next
    // of end of list to be reversed.
    Node* revs = NULL, *revs_prev = NULL;
    Node* revend = NULL, *revend_next = NULL;
 
    // Find values of above pointers.
    int i = 1;
    Node* curr = head;
    while (curr && i <= n) {
        if (i < m)
            revs_prev = curr;
 
        if (i == m)
            revs = curr;
 
        if (i == n) {
            revend = curr;
            revend_next = curr->next;
        }
 
        curr = curr->next;
        i++;
    }
    revend->next = NULL;
 
    // Reverse linked list starting with
    // revs.
    revend = reverse(revs);
 
    // If starting position was not head
    if (revs_prev)
        revs_prev->next = revend;
 
    // If starting position was head
    else
        head = revend;
 
    revs->next = revend_next;
    return head;
}
 
void print(struct Node* head)
{
    while (head != NULL) {
        printf("%d ", head->data);
        head = head->next;
    }
    printf("\n");
}
 
// function to add a new node at the
// beginning of the list
void push(struct Node** head_ref, int new_data)
{
    struct Node* new_node = new Node;
    new_node->data = new_data;
    new_node->next = (*head_ref);
    (*head_ref) = new_node;
}
 
// Driver code
int main()
{
    struct Node* head = NULL;
    push(&head, 70);
    push(&head, 60);
    push(&head, 50);
    push(&head, 40);
    push(&head, 30);
    push(&head, 20);
    push(&head, 10);
    reverseBetween(head, 3, 6);
    print(head);
    return 0;
}

Python3

# Python3 program to reverse a linked list
# from position m to position n
  
# Linked list node
class Node:
     
    def __init__(self, data):
         
        self.data = data
        self.next = None
 
# The standard reverse function used
# to reverse a linked list
def reverse(head):
 
    prev = None  
    curr = head
  
    while (curr):
        next = curr.next
        curr.next = prev
        prev = curr
        curr = next
     
    return prev
  
# Function used to reverse a linked list
# from position m to n which uses reverse
# function
def reverseBetween(head, m, n):
 
    if (m == n):
        return head
         
    # revs and revend is start and end respectively
    # of the portion of the linked list which
    # need to be reversed. revs_prev is previous
    # of starting position and revend_next is next
    # of end of list to be reversed.
    revs = None
    revs_prev = None
    revend = None
    revend_next = None
  
    # Find values of above pointers.
    i = 1
    curr = head
     
    while (curr and i <= n):
        if (i < m):
            revs_prev = curr
  
        if (i == m):
            revs = curr
  
        if (i == n):
            revend = curr
            revend_next = curr.next
  
        curr = curr.next
        i += 1
 
    revend.next = None
  
    # Reverse linked list starting with
    # revs.
    revend = reverse(revs)
  
    # If starting position was not head
    if (revs_prev):
        revs_prev.next = revend
  
    # If starting position was head
    else:
        head = revend
  
    revs.next = revend_next
    return head
 
def prints(head):
 
    while (head != None):
        print(head.data, end = ' ')
        head = head.next
         
    print()
 
# Function to add a new node at the
# beginning of the list
def push(head_ref, new_data):
 
    new_node = Node(new_data)
    new_node.data = new_data
    new_node.next = (head_ref)
    (head_ref) = new_node
    return head_ref
 
# Driver code
if __name__=='__main__':
     
    head = None
    head = push(head, 70)
    head = push(head, 60)
    head = push(head, 50)
    head = push(head, 40)
    head = push(head, 30)
    head = push(head, 20)
    head = push(head, 10)
     
    reverseBetween(head, 3, 6)
     
    prints(head)
     
# This code is contributed by rutvik_56

输出：

10 20 60 50 40 30 70

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。