在链表中偶数位置节点的末尾反向追加奇数位置节点

给定一个链表。任务是以奇数位置节点出现在偶数位置节点之前的方式分离其偶数和奇数位置节点，所有偶数位置节点必须按相反顺序排列。
例子：

Input: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> NULL 
Output : 1 -> 3 -> 5 -> 6 -> 4 -> 2 -> NULL
Input : 1 -> 2 -> 3 -> 4 -> 5 -> NULL 
Output : 1 -> 3 -> 5 -> 4 -> 2 -> NULL 
 

资料来源：微软专访

方法：在给定的链接中已经讨论了类似的问题，但是偶数部分没有颠倒。分别为奇数和偶数位置的当前节点维护两个指针奇数和偶数。此外，存储偶数链表的第一个节点，以便在所有奇数和偶数节点连接到两个不同的列表中后，我们可以将偶数列表附加到奇数列表的末尾。一旦偶数列表被分离，我们只需要反转它。可以在此处找到反转链表。一旦偶数链表反转，将其附加到奇数链表。
下面是上述方法的实现：

C++

// C++ program to Append odd position nodes
// in reverse at the end of even
// positioned nodes in a Linked List
#include 
using namespace std;
 
// Linked List Node
struct Node {
    int data;
    struct Node* next;
};
 
// A utility function to create a new node
Node* newNode(int key)
{
    Node* temp = new Node;
    temp->data = key;
    temp->next = NULL;
    return temp;
}
 
// Rearranges given linked list such that all even
// positioned nodes are before odd positioned
// in a reverse
Node* rearrangeEvenOdd(Node* head)
{
    // Corner case
    if (head == NULL)
        return NULL;
 
    // Initialize first nodes of even and
    // odd lists
    Node* odd = head;
    Node* even = head->next;
 
    // Remember the first node of even list so
    // that we can connect the even list at the
    // end of odd list.
    Node* evenFirst = even;
 
    while (1) {
 
        // If there are no more nodes, then connect
        // first node of even list to the last node
        // of odd list
        if (!odd || !even || !(even->next)) {
            break;
        }
 
        // Connecting odd nodes
        odd->next = even->next;
        odd = even->next;
 
        // If there are NO more even nodes after
        // current odd.
        if (odd->next == NULL) {
            even->next = NULL;
            break;
        }
 
        // Connecting evenevenFirs nodes
        even->next = odd->next;
        even = odd->next;
    }
 
    // Reversal of even linked list
    Node* current = evenFirst;
    Node* prev = NULL;
    Node* front = NULL;
 
    // Iterate in the complete linked list
    while (current != NULL) {
        front = current->next;
        current->next = prev;
        prev = current;
        current = front;
    }
 
    evenFirst = prev;
 
    // Attach the reversed even linked
    // list to odd linked list
    odd->next = evenFirst;
    return head;
}
 
// A utility function to print a linked list
void printlist(Node* node)
{
    while (node != NULL) {
        cout << node->data << " -> ";
        node = node->next;
    }
    cout << "NULL" << endl;
}
 
// Driver code
int main(void)
{
    Node* head = newNode(1);
    head->next = newNode(2);
    head->next->next = newNode(3);
    head->next->next->next = newNode(4);
    head->next->next->next->next = newNode(5);
    head->next->next->next->next->next = newNode(6);
 
    head = rearrangeEvenOdd(head);
 
    printlist(head);
 
    return 0;
}

Java

// Java program to Append odd position nodes
// in reverse at the end of even
// positioned nodes in a Linked List
class sol
{
 
// Linked List Node
static class Node
{
    int data;
    Node next;
};
 
// A utility function to create a new node
static Node newNode(int key)
{
    Node temp = new Node();
    temp.data = key;
    temp.next = null;
    return temp;
}
 
// Rearranges given linked list such that all even
// positioned nodes are before odd positioned
// in a reverse
static Node rearrangeEvenOdd(Node head)
{
    // Corner case
    if (head == null)
        return null;
 
    // Initialize first nodes of even and
    // odd lists
    Node odd = head;
    Node even = head.next;
 
    // Remember the first node of even list so
    // that we can connect the even list at the
    // end of odd list.
    Node evenFirst = even;
 
    while (true)
    {
 
        // If there are no more nodes, then connect
        // first node of even list to the last node
        // of odd list
        if (odd == null || even == null || (even.next) == null)
        {
            break;
        }
 
        // Connecting odd nodes
        odd.next = even.next;
        odd = even.next;
 
        // If there are NO more even nodes after
        // current odd.
        if (odd.next == null)
        {
            even.next = null;
            break;
        }
 
        // Connecting evenevenFirs nodes
        even.next = odd.next;
        even = odd.next;
    }
 
    // Reversal of even linked list
    Node current = evenFirst;
    Node prev = null;
    Node front = null;
 
    // Iterate in the complete linked list
    while (current != null)
    {
        front = current.next;
        current.next = prev;
        prev = current;
        current = front;
    }
 
    evenFirst = prev;
 
    // Attach the reversed even linked
    // list to odd linked list
    odd.next = evenFirst;
    return head;
}
 
// A utility function to print a linked list
static void printlist(Node node)
{
    while (node != null)
    {
        System.out.print( node.data + " -> ");
        node = node.next;
    }
    System.out.println( "null" );
}
 
// Driver code
public static void main(String args[])
{
    Node head = newNode(1);
    head.next = newNode(2);
    head.next.next = newNode(3);
    head.next.next.next = newNode(4);
    head.next.next.next.next = newNode(5);
    head.next.next.next.next.next = newNode(6);
 
    head = rearrangeEvenOdd(head);
 
    printlist(head);
 
}
}
 
// This code is contributed by Arnab Kundu

Python3

# Python3 program to Append odd position nodes
# in reverse at the end of even
# positioned nodes in a Linked List
import math
 
# Linked List Node
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
 
# A utility function to create a new node
def newNode(key):
    temp = Node(key)
    temp.data = key
    temp.next = None
    return temp
 
# Rearranges given linked list such that
# all even positioned nodes are before
# odd positioned in a reverse
def rearrangeEvenOdd(head):
     
    # Corner case
    if (head == None):
        return None
 
    # Initialize first nodes of even and
    # odd lists
    odd = head
    even = head.next
 
    # Remember the first node of even list so
    # that we can connect the even list at the
    # end of odd list.
    evenFirst = even
 
    while True:
 
        # If there are no more nodes,
        # then connect first node of
        # even list to the last node
        # of odd list
        if (odd == None or even == None or
                    (even.next) == None):
            break
     
        # Connecting odd nodes
        odd.next = even.next
        odd = even.next
 
        # If there are NO more even nodes after
        # current odd.
        if (odd.next == None):
            even.next = None
            break
         
        # Connecting evenevenFirs nodes
        even.next = odd.next
        even = odd.next
     
    # Reversal of even linked list
    current = evenFirst
    prev = None
    front = None
 
    # Iterate in the complete linked list
    while (current != None):
        front = current.next
        current.next = prev
        prev = current
        current = front
     
    evenFirst = prev
 
    # Attach the reversed even linked
    # list to odd linked list
    odd.next = evenFirst
    return head
 
# A utility function to print a linked list
def printlist(node):
    while (node != None) :
        print(node.data, end = "->")
        node = node.next
     
    print("NULL")
 
# Driver code
if __name__=='__main__':
    head = newNode(1)
    head.next = newNode(2)
    head.next.next = newNode(3)
    head.next.next.next = newNode(4)
    head.next.next.next.next = newNode(5)
    head.next.next.next.next.next = newNode(6)
 
    head = rearrangeEvenOdd(head)
 
    printlist(head)
 
# This code is contributed by Srathore

C#

// C# program to Append odd position nodes
// in reverse at the end of even
// positioned nodes in a Linked List
using System;
     
class GFG
{
 
// Linked List Node
public class Node
{
    public int data;
    public Node next;
};
 
// A utility function to create a new node
static Node newNode(int key)
{
    Node temp = new Node();
    temp.data = key;
    temp.next = null;
    return temp;
}
 
// Rearranges given linked list such that
// all even positioned nodes are before
// odd positioned in a reverse
static Node rearrangeEvenOdd(Node head)
{
    // Corner case
    if (head == null)
        return null;
 
    // Initialize first nodes of even and
    // odd lists
    Node odd = head;
    Node even = head.next;
 
    // Remember the first node of even list so
    // that we can connect the even list at the
    // end of odd list.
    Node evenFirst = even;
 
    while (true)
    {
 
        // If there are no more nodes, 
        // then connect first node of
        // even list to the last node
        // of odd list
        if (odd == null || even == null ||
                          (even.next) == null)
        {
            break;
        }
 
        // Connecting odd nodes
        odd.next = even.next;
        odd = even.next;
 
        // If there are NO more even nodes after
        // current odd.
        if (odd.next == null)
        {
            even.next = null;
            break;
        }
 
        // Connecting evenevenFirs nodes
        even.next = odd.next;
        even = odd.next;
    }
 
    // Reversal of even linked list
    Node current = evenFirst;
    Node prev = null;
    Node front = null;
 
    // Iterate in the complete linked list
    while (current != null)
    {
        front = current.next;
        current.next = prev;
        prev = current;
        current = front;
    }
 
    evenFirst = prev;
 
    // Attach the reversed even linked
    // list to odd linked list
    odd.next = evenFirst;
    return head;
}
 
// A utility function to print a linked list
static void printlist(Node node)
{
    while (node != null)
    {
        Console.Write( node.data + " -> ");
        node = node.next;
    }
    Console.WriteLine( "null" );
}
 
// Driver code
public static void Main(String []args)
{
    Node head = newNode(1);
    head.next = newNode(2);
    head.next.next = newNode(3);
    head.next.next.next = newNode(4);
    head.next.next.next.next = newNode(5);
    head.next.next.next.next.next = newNode(6);
 
    head = rearrangeEvenOdd(head);
 
    printlist(head);
}
}
 
// This code is contributed by PrinciRaj1992

Javascript

 
// JavaScript program to Append odd position nodes
// in reverse at the end of even
// positioned nodes in a Linked List
 
    // Linked List Node
    class Node {
        constructor() {
            this.data = 0;
            this.next = null;
        }
    }
    // A utility function to create a new node
    function newNode(key) {
    var temp = new Node();
        temp.data = key;
        temp.next = null;
        return temp;
    }
 
    // Rearranges given linked list such that all even
    // positioned nodes are before odd positioned
    // in a reverse
    function rearrangeEvenOdd(head) {
        // Corner case
        if (head == null)
            return null;
 
        // Initialize first nodes of even and
        // odd lists
        var odd = head;
        var even = head.next;
 
        // Remember the first node of even list so
        // that we can connect the even list at the
        // end of odd list.
        var evenFirst = even;
 
        while (true) {
 
            // If there are no more nodes, then connect
            // first node of even list to the last node
            // of odd list
            if (odd == null || even == null ||
            (even.next) == null)
            {
                break;
            }
 
            // Connecting odd nodes
            odd.next = even.next;
            odd = even.next;
 
            // If there are NO more even nodes after
            // current odd.
            if (odd.next == null) {
                even.next = null;
                break;
            }
 
            // Connecting evenevenFirs nodes
            even.next = odd.next;
            even = odd.next;
        }
 
        // Reversal of even linked list
        var current = evenFirst;
        var prev = null;
        var front = null;
 
        // Iterate in the complete linked list
        while (current != null) {
            front = current.next;
            current.next = prev;
            prev = current;
            current = front;
        }
 
        evenFirst = prev;
 
        // Attach the reversed even linked
        // list to odd linked list
        odd.next = evenFirst;
        return head;
    }
 
    // A utility function to print a linked list
    function printlist(node) {
        while (node != null) {
            document.write(node.data + " -> ");
            node = node.next;
        }
        document.write("Null");
    }
 
    // Driver code
     
        var head = newNode(1);
        head.next = newNode(2);
        head.next.next = newNode(3);
        head.next.next.next = newNode(4);
        head.next.next.next.next = newNode(5);
        head.next.next.next.next.next = newNode(6);
 
        head = rearrangeEvenOdd(head);
 
        printlist(head);
 
// This code is contributed by todaysgaurav
 

输出：

1 -> 3 -> 5 -> 6 -> 4 -> 2 -> NULL

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