单向链表中的反向交替 K 节点 – 迭代解决方案

给定一个链表和一个整数K ，任务是反转每个交替的K 个节点。
例子：

Input: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> NULL, K = 3 
Output: 3 2 1 4 5 6 9 8 7
Input: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> NULL, K = 5 
Output: 5 4 3 2 1 6 7 8 9 
 

方法：我们已经在这里讨论了递归解决方案。在这篇文章中，我们将讨论上述问题的迭代解决方案。在遍历时，我们在一次迭代中处理 2k 个节点，并使用连接和尾指针跟踪给定链表中 k 节点组的第一个和最后一个节点。在反转链表的k个节点后，我们将反转链表的最后一个尾指针指向的节点与连接指针指向的原始链表的第一个节点连接起来。然后我们移动当前指针，直到我们跳过接下来的 k 个节点。
尾部现在成为普通列表的最后一个节点（由更新的尾部指针指向），连接指向反向列表的第一个，然后它们被连接起来。我们重复这个过程，直到所有节点都以相同的方式处理。
下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
 
// Link list node
class Node {
public:
    int data;
    Node* next;
};
 
/* Function to reverse alternate k nodes and
return the pointer to the new head node */
Node* kAltReverse(struct Node* head, int k)
{
    Node* prev = NULL;
    Node* curr = head;
    Node* temp = NULL;
    Node* tail = NULL;
    Node* newHead = NULL;
    Node* join = NULL;
    int t = 0;
 
    // Traverse till the end of the linked list
    while (curr) {
        t = k;
        join = curr;
        prev = NULL;
 
        /* Reverse alternative group of k nodes
        // of the given linked list */
        while (curr && t--) {
            temp = curr->next;
            curr->next = prev;
            prev = curr;
            curr = temp;
        }
 
        // Sets the new head of the input list
        if (!newHead)
            newHead = prev;
 
        /* Tail pointer keeps track of the last node
        of the k-reversed linked list. The tail pointer
        is then joined with the first node of the
        next k-nodes of the linked list */
        if (tail)
            tail->next = prev;
 
        tail = join;
        tail->next = curr;
 
        t = k;
 
        /* Traverse through the next k nodes
        which will not be reversed */
        while (curr && t--) {
            prev = curr;
            curr = curr->next;
        }
 
        /* Tail pointer keeps track of the last
        node of the k nodes traversed above */
        tail = prev;
    }
 
    // newHead is new head of the modified list
    return newHead;
}
 
// Function to insert a node at
// the head of the linked list
void push(Node** head_ref, int new_data)
{
    /* allocate node */
    Node* new_node = new Node();
 
    /* put in the data */
    new_node->data = new_data;
 
    /* link the old list off the new node */
    new_node->next = (*head_ref);
 
    /* move the head to point to the new node */
    (*head_ref) = new_node;
}
 
// Function to print the linked list
void printList(Node* node)
{
    int count = 0;
    while (node != NULL) {
        cout << node->data << " ";
        node = node->next;
        count++;
    }
}
 
// Driver code
int main(void)
{
 
    // Start with the empty list
    Node* head = NULL;
    int i;
 
    // Create a list 1->2->3->4->...->10
    for (i = 10; i > 0; i--)
        push(&head, i);
 
    int k = 3;
 
    cout << "Given linked list \n";
    printList(head);
    head = kAltReverse(head, k);
 
    cout << "\n Modified Linked list \n";
    printList(head);
 
    return (0);
}

Java

// Java implementation of the approach
class GFG
{
 
// Link list node
static class Node
{
    int data;
    Node next;
};
static Node head;
 
/* Function to reverse alternate k nodes and
return the pointer to the new head node */
static Node kAltReverse(Node head, int k)
{
    Node prev = null;
    Node curr = head;
    Node temp = null;
    Node tail = null;
    Node newHead = null;
    Node join = null;
    int t = 0;
 
    // Traverse till the end of the linked list
    while (curr != null)
    {
        t = k;
        join = curr;
        prev = null;
 
        /* Reverse alternative group of k nodes
        // of the given linked list */
        while (curr != null && t-- >0)
        {
            temp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = temp;
        }
 
        // Sets the new head of the input list
        if (newHead == null)
            newHead = prev;
 
        /* Tail pointer keeps track of the last node
        of the k-reversed linked list. The tail pointer
        is then joined with the first node of the
        next k-nodes of the linked list */
        if (tail != null)
            tail.next = prev;
 
        tail = join;
        tail.next = curr;
 
        t = k;
 
        /* Traverse through the next k nodes
        which will not be reversed */
        while (curr != null && t-- >0)
        {
            prev = curr;
            curr = curr.next;
        }
 
        /* Tail pointer keeps track of the last
        node of the k nodes traversed above */
        tail = prev;
    }
 
    // newHead is new head of the modified list
    return newHead;
}
 
// Function to insert a node at
// the head of the linked list
static void push(Node head_ref, int new_data)
{
    /* allocate node */
    Node new_node = new Node();
 
    /* put in the data */
    new_node.data = new_data;
 
    /* link the old list off the new node */
    new_node.next = head_ref;
 
    /* move the head to point to the new node */
    head_ref = new_node;
    head = head_ref;
}
 
// Function to print the linked list
static void printList(Node node)
{
    int count = 0;
    while (node != null)
    {
        System.out.print(node.data + " ");
        node = node.next;
        count++;
    }
}
 
// Driver code
public static void main(String[] args)
{
    // Start with the empty list
    head = null;
    int i;
 
    // Create a list 1->2->3->4->...->10
    for (i = 10; i > 0; i--)
        push(head, i);
 
    int k = 3;
 
    System.out.print("Given linked list \n");
    printList(head);
    head = kAltReverse(head, k);
 
    System.out.print("\n Modified Linked list \n");
    printList(head);
}
}
 
// This code is contributed by Rajput-Ji

Python

# Python implementation of the approach
 
# Node class
class Node:
     
    # Function to initialise the node object
    def __init__(self, data):
        self.data = data # Assign data
        self.next = None
         
head = None
 
# Function to reverse alternate k nodes and
# return the pointer to the new head node
def kAltReverse(head, k):
     
    prev = None
    curr = head
    temp = None
    tail = None
    newHead = None
    join = None
    t = 0
 
    # Traverse till the end of the linked list
    while (curr != None) :
     
        t = k
        join = curr
        prev = None
 
        # Reverse alternative group of k nodes
        # of the given linked list
        while (curr != None and t > 0):
             
            t = t - 1
            temp = curr.next
            curr.next = prev
            prev = curr
            curr = temp
         
        # Sets the new head of the input list
        if (newHead == None):
            newHead = prev
 
        # Tail pointer keeps track of the last node
        # of the k-reversed linked list. The tail pointer
        # is then joined with the first node of the
        # next k-nodes of the linked list
        if (tail != None):
            tail.next = prev
 
        tail = join
        tail.next = curr
 
        t = k
 
        # Traverse through the next k nodes
        # which will not be reversed
        while (curr != None and t > 0):
            t = t - 1
            prev = curr
            curr = curr.next
         
        # Tail pointer keeps track of the last
        # node of the k nodes traversed above
        tail = prev
     
    # newHead is new head of the modified list
    return newHead
 
# Function to insert a node at
# the head of the linked list
def push(head_ref, new_data):
     
    global head
     
    # allocate node
    new_node = Node(0)
 
    # put in the data
    new_node.data = new_data
 
    # link the old list off the new node
    new_node.next = head_ref
 
    # move the head to point to the new node
    head_ref = new_node
    head = head_ref
 
# Function to print the linked list
def printList(node):
 
    count = 0
    while (node != None):
     
        print(node.data ,end= " ")
        node = node.next
        count = count + 1
     
# Driver code
 
# Start with the empty list
head = None
i = 10
 
# Create a list 1->2->3->4->...->10
while ( i > 0 ):
    push(head, i)
    i = i - 1
 
k = 3
 
print("Given linked list ")
printList(head)
head = kAltReverse(head, k)
 
print("\n Modified Linked list ")
printList(head)
 
# This code is contributed by Arnab Kundu

C#

// C# implementation of the approach
using System;
 
class GFG
{
 
// Link list node
public class Node
{
    public int data;
    public Node next;
};
static Node head;
 
/* Function to reverse alternate k nodes and
return the pointer to the new head node */
static Node kAltReverse(Node head, int k)
{
    Node prev = null;
    Node curr = head;
    Node temp = null;
    Node tail = null;
    Node newHead = null;
    Node join = null;
    int t = 0;
 
    // Traverse till the end of the linked list
    while (curr != null)
    {
        t = k;
        join = curr;
        prev = null;
 
        /* Reverse alternative group of k nodes
        // of the given linked list */
        while (curr != null && t-- >0)
        {
            temp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = temp;
        }
 
        // Sets the new head of the input list
        if (newHead == null)
            newHead = prev;
 
        /* Tail pointer keeps track of the last node
        of the k-reversed linked list. The tail pointer
        is then joined with the first node of the
        next k-nodes of the linked list */
        if (tail != null)
            tail.next = prev;
 
        tail = join;
        tail.next = curr;
 
        t = k;
 
        /* Traverse through the next k nodes
        which will not be reversed */
        while (curr != null && t-- >0)
        {
            prev = curr;
            curr = curr.next;
        }
 
        /* Tail pointer keeps track of the last
        node of the k nodes traversed above */
        tail = prev;
    }
 
    // newHead is new head of the modified list
    return newHead;
}
 
// Function to insert a node at
// the head of the linked list
static void push(Node head_ref, int new_data)
{
    /* allocate node */
    Node new_node = new Node();
 
    /* put in the data */
    new_node.data = new_data;
 
    /* link the old list off the new node */
    new_node.next = head_ref;
 
    /* move the head to point to the new node */
    head_ref = new_node;
    head = head_ref;
}
 
// Function to print the linked list
static void printList(Node node)
{
    int count = 0;
    while (node != null)
    {
        Console.Write(node.data + " ");
        node = node.next;
        count++;
    }
}
 
// Driver code
public static void Main(String[] args)
{
    // Start with the empty list
    head = null;
    int i;
 
    // Create a list 1->2->3->4->...->10
    for (i = 10; i > 0; i--)
        push(head, i);
 
    int k = 3;
 
    Console.Write("Given linked list \n");
    printList(head);
    head = kAltReverse(head, k);
 
    Console.Write("\nModified Linked list \n");
    printList(head);
}
}
 
// This code is contributed by Rajput-Ji

Javascript

// javascript implementation of the approach    // Link list node
class Node {
    constructor(val) {
        this.data = val;
        this.next = null;
    }
}
 
    var head;
 
    /*
     * Function to reverse alternate k nodes and return the pointer to the new head
     * node
     */
    function kAltReverse(head , k) {
var prev = null;
var curr = head;
var temp = null;
var tail = null;
var newHead = null;
var join = null;
        var t = 0;
 
        // Traverse till the end of the linked list
        while (curr != null) {
            t = k;
            join = curr;
            prev = null;
 
            /*
             * Reverse alternative group of k nodes // of the given linked list
             */
            while (curr != null && t-- > 0) {
                temp = curr.next;
                curr.next = prev;
                prev = curr;
                curr = temp;
            }
 
            // Sets the new head of the input list
            if (newHead == null)
                newHead = prev;
 
            /*
             * Tail pointer keeps track of the last node of the k-reversed linked list. The
             * tail pointer is then joined with the first node of the next k-nodes of the
             * linked list
             */
            if (tail != null)
                tail.next = prev;
 
            tail = join;
            tail.next = curr;
 
            t = k;
 
            /*
             * Traverse through the next k nodes which will not be reversed
             */
            while (curr != null && t-- > 0) {
                prev = curr;
                curr = curr.next;
            }
 
            /*
             * Tail pointer keeps track of the last node of the k nodes traversed above
             */
            tail = prev;
        }
 
        // newHead is new head of the modified list
        return newHead;
    }
 
    // Function to insert a node at
    // the head of the linked list
    function push(head_ref , new_data) {
        /* allocate node */
var new_node = new Node();
 
        /* put in the data */
        new_node.data = new_data;
 
        /* link the old list off the new node */
        new_node.next = head_ref;
 
        /* move the head to povar to the new node */
        head_ref = new_node;
        head = head_ref;
    }
 
    // Function to prvar the linked list
    function printList(node) {
        var count = 0;
        while (node != null) {
            document.write(node.data + " ");
            node = node.next;
            count++;
        }
    }
 
    // Driver code
     
        // Start with the empty list
        head = null;
        var i;
 
        // Create a list 1->2->3->4->...->10
        for (i = 10; i > 0; i--)
            push(head, i);
 
        var k = 3;
 
        document.write("Given linked list <br/>");
        printList(head);
        head = kAltReverse(head, k);
 
        document.write("<br/>Modified Linked list <br/>");
        printList(head);
 
// This code contributed by gauravrajput1

输出：

Given linked list 
1 2 3 4 5 6 7 8 9 10 
 Modified Linked list 
3 2 1 4 5 6 9 8 7 10

时间复杂度： O(n)
空间复杂度： O(1)

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