Combine Nodes impares y pares colocados de dos listas enlazadas alternativamente

Dadas dos listas enlazadas L1 y L2 , la tarea es imprimir una nueva lista obtenida al fusionar los Nodes de posición impar de L1 con los Nodes de posición par de L2 alternativamente.

Ejemplos:

Entrada: L1 = 8->5->3->2->10->NULL, L2 = 11->13->1->6->9->NULL
Salida: 8->13->3-> 6->10->NULL 
Explicación:
Los Nodes de posición impar de L1 son {8, 3, 10} y los Nodes de posición par L2 son {13, 6}. 
Combinarlos alternativamente genera la lista enlazada 8->13->3->6->10->NULL

Entrada: L1 = 1->5->10->12->13->19->6->NULL, L2 = 2->7->9->NULL  Salida: 1->7->10-> 13->6->NULL Explicación: Los Nodes de posición impar de L1 son {1, 10, 13, 6} y el Node de posición par de L2 es {7}. Combinarlos alternativamente genera la lista enlazada 1->7->10->13->6->NULL 

 Enfoque: siga los pasos a continuación para resolver el problema:

• Comience a atravesar desde el primer Node de L1 y para el segundo Node de L2 simultáneamente.
• Agregue el primer Node de L1 a la lista resultante y conéctelo con el segundo Node de L2 y muévase al siguiente Node impar en L1 . De manera similar, agregue conecte el segundo Node de L2 al Node impar actual de L1 y muévase al siguiente Node par en L2.
• Repita el paso anterior hasta llegar al final de una de las listas.
• Recorra la otra lista y siga agregando los Nodes requeridos de esa lista a la lista resultante.
• Finalmente, imprima la lista resultante.

 A continuación se muestra la implementación del enfoque anterior:

// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Structure of a Node
class node {
public:
    int data;
    node* next;
    node(int d)
    {
        data = d;
        next = NULL;
    }
};
 
// Function to insert the node
// at the head of the linkedlist
void insert_at_head(node*& head, int data)
{
    node* n = new node(data);
    n->next = head;
    head = n;
    return;
}
 
// Function to print the linked list
void print(node* head)
{
    while (head != NULL) {
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
    return;
}
 
// Function to merge the odd and
// even positioned nodes of two
// given linked lists alternately
node* merge_alternate(node* head1, node* head2)
{
    // Traverse from the second
    // node of second linked list
    if (head2)
        head2 = head2->next;
 
    // Stores the head of
    // the resultant list
    node* head3 = NULL;
 
    // Stores the current node
    node* cur = NULL;
 
    // Store the first node of
    // first list in the result
    if (head1)
        head3 = head1;
 
    // Otherwise
    else
        head3 = head2;
 
    // Traverse until end of a
    // one of the list is reached
    while (head1 != NULL && head2 != NULL) {
 
        // If there is a previous node then
        // connect that with the current node
        if (cur)
            cur->next = head1;
 
        // Update the current node
        cur = head1;
 
        // If next odd node exists
        if (head1->next != NULL)
 
            // Store the next odd node
            head1 = head1->next->next;
 
        // Otherwise
        else
 
            // Reach end of list
            head1 = NULL;
 
        // Connect the first node
        // with the second node
        cur->next = head2;
 
        // Update the current node
        cur = head2;
 
        // If next even node exists
        if (head2->next != NULL)
 
            // Store the next even node
            head2 = head2->next->next;
 
        // Otherwise
        else
 
            // Reach the end of the list
            head2 = NULL;
    }
 
    // If end of the second
    // list has been reached
    while (head1 != NULL) {
 
        // Connect with the
        // previous node
        if (cur)
            cur->next = head1;
 
        // Update the current node
        cur = head1;
 
        // If next odd node exists
        if (head1->next != NULL)
 
            // Store the next odd node
            head1 = head1->next->next;
 
        // Otherwise
        else
 
            // Reach end of list
            head1 = NULL;
    }
 
    // If end of second list
    // has been reached
    while (head2 != NULL) {
 
        // Connect with the
        // previous node
        if (cur)
            cur->next = head2;
 
        // Update the current node
        cur = head2;
 
        // If next even node exists
        if (head2->next != NULL)
 
            // Store the next odd node
            head2 = head2->next->next;
 
        // Otherwise
        else
 
            // Reach end of list
            head2 = NULL;
    }
 
    // End of the resultant list
    if (cur)
        cur->next = NULL;
 
    // Returning the head of
    // the resultant node
    return head3;
}
 
// Driver Code
int main()
{
    node *head1 = NULL, *head2 = NULL;
 
    // Create linked list
    insert_at_head(head1, 6);
    insert_at_head(head1, 19);
    insert_at_head(head1, 13);
    insert_at_head(head1, 12);
    insert_at_head(head1, 10);
    insert_at_head(head1, 5);
    insert_at_head(head1, 1);
 
    insert_at_head(head2, 9);
    insert_at_head(head2, 7);
    insert_at_head(head2, 2);
 
    // Merging the linked lists
    head1 = merge_alternate(head1, head2);
 
    print(head1);
}

// Java program to implement
// the above approach
import java.util.*;
class GFG{
 
// Structure of a Node
static class node
{
  public int data;
  node next;
  node(int d)
  {
    data = d;
    next = null;
  }
};
 
// Function to insert the node
// at the head of the linkedlist
static node insert_at_head(node head,
                           int data)
{
  node n = new node(data);
  n.next = head;
  head = n;
  return head;
}
 
// Function to print the linked list
static void print(node head)
{
  while (head != null)
  {
    System.out.print(head.data + " ");
    head = head.next;
  }
  System.out.println();
  return;
}
 
// Function to merge the odd and
// even positioned nodes of two
// given linked lists alternately
static node merge_alternate(node head1,
                            node head2)
{
  // Traverse from the second
  // node of second linked list
  if (head2 != null)
    head2 = head2.next;
 
  // Stores the head of
  // the resultant list
  node head3 = null;
 
  // Stores the current node
  node cur = null;
 
  // Store the first node of
  // first list in the result
  if (head1 != null)
    head3 = head1;
 
  // Otherwise
  else
    head3 = head2;
 
  // Traverse until end of a
  // one of the list is reached
  while (head1 != null && head2 != null)
  {
    // If there is a previous node then
    // connect that with the current node
    if (cur != null)
      cur.next = head1;
 
    // Update the current node
    cur = head1;
 
    // If next odd node exists
    if (head1.next != null)
 
      // Store the next odd node
      head1 = head1.next.next;
 
    // Otherwise
    else
 
      // Reach end of list
      head1 = null;
 
    // Connect the first node
    // with the second node
    cur.next = head2;
 
    // Update the current node
    cur = head2;
 
    // If next even node exists
    if (head2.next != null)
 
      // Store the next even node
      head2 = head2.next.next;
 
    // Otherwise
    else
 
      // Reach the end of the list
      head2 = null;
  }
 
  // If end of the second
  // list has been reached
  while (head1 != null)
  {
    // Connect with the
    // previous node
    if (cur != null)
      cur.next = head1;
 
    // Update the current node
    cur = head1;
 
    // If next odd node exists
    if (head1.next != null)
 
      // Store the next odd node
      head1 = head1.next.next;
 
    // Otherwise
    else
 
      // Reach end of list
      head1 = null;
  }
 
  // If end of second list
  // has been reached
  while (head2 != null)
  {
    // Connect with the
    // previous node
    if (cur != null)
      cur.next = head2;
 
    // Update the current node
    cur = head2;
 
    // If next even node exists
    if (head2.next != null)
 
      // Store the next odd node
      head2 = head2.next.next;
 
    // Otherwise
    else
 
      // Reach end of list
      head2 = null;
  }
 
  // End of the resultant list
  if (cur != null)
    cur.next = null;
 
  // Returning the head of
  // the resultant node
  return head3;
}
 
// Driver Code
public static void main(String[] args)
{
  node head1 = null, head2 = null;
 
  // Create linked list
  head1 = insert_at_head(head1, 6);
  head1 = insert_at_head(head1, 19);
  head1 = insert_at_head(head1, 13);
  head1 = insert_at_head(head1, 12);
  head1 = insert_at_head(head1, 10);
  head1 = insert_at_head(head1, 5);
  head1 = insert_at_head(head1, 1);
 
  head2 = insert_at_head(head2, 9);
  head2 = insert_at_head(head2, 7);
  head2 = insert_at_head(head2, 2);
 
  // Merging the linked lists
  head1 = merge_alternate(head1, head2);
 
  print(head1);
}
}
 
// This code is contributed by gauravrajput1

# Python3 program to implement
# the above approach
  
# Structure of a Node
class node:
     
    def __init__(self, d):
     
        self.data = d;
        self.next = None;
     
# Function to insert the node
# at the head of the linkedlist
def insert_at_head(head, data):
 
    n = node(data);
    n.next = head;
    head = n;
    return head;
  
# Function to print the linked list
def printx(head):
 
    while (head != None):
        print(head.data, end = ' ')
        head = head.next;
     
    print()
     
    return;
  
# Function to merge the odd and
# even positioned nodes of two
# given linked lists alternately
def merge_alternate(head1, head2):
 
    # Traverse from the second
    # node of second linked list
    if (head2):
        head2 = head2.next;
  
    # Stores the head of
    # the resultant list
    head3 = None;
  
    # Stores the current node
    cur = None;
  
    # Store the first node of
    # first list in the result
    if (head1):
        head3 = head1;
  
    # Otherwise
    else:
        head3 = head2;
  
    # Traverse until end of a
    # one of the list is reached
    while (head1 != None and head2 != None):
  
        # If there is a previous node then
        # connect that with the current node
        if (cur):
            cur.next = head1;
  
        # Update the current node
        cur = head1;
  
        # If next odd node exists
        if (head1.next != None):
  
            # Store the next odd node
            head1 = head1.next.next;
  
        # Otherwise
        else:
  
            # Reach end of list
            head1 = None;
  
        # Connect the first node
        # with the second node
        cur.next = head2;
  
        # Update the current node
        cur = head2;
  
        # If next even node exists
        if (head2.next != None):
  
            # Store the next even node
            head2 = head2.next.next;
  
        # Otherwise
        else:
  
            # Reach the end of the list
            head2 = None;
     
  
    # If end of the second
    # list has been reached
    while (head1 != None):
  
        # Connect with the
        # previous node
        if (cur):
            cur.next = head1;
  
        # Update the current node
        cur = head1;
  
        # If next odd node exists
        if (head1.next != None):
  
            # Store the next odd node
            head1 = head1.next.next;
  
        # Otherwise
        else:  
  
            # Reach end of list
            head1 = None;
  
    # If end of second list
    # has been reached
    while (head2 != None):
  
        # Connect with the
        # previous node
        if (cur):
            cur.next = head2;
  
        # Update the current node
        cur = head2;
  
        # If next even node exists
        if (head2.next != None):
  
            # Store the next odd node
            head2 = head2.next.next;
  
        # Otherwise
        else:
  
            # Reach end of list
            head2 = None;
  
    # End of the resultant list
    if (cur):
        cur.next = None;
  
    # Returning the head of
    # the resultant node
    return head3;
 
  
# Driver Code
if __name__=='__main__':
     
    head1 = None
    head2 = None;
  
    # Create linked list
    head1 = insert_at_head(head1, 6);
    head1 = insert_at_head(head1, 19);
    head1 = insert_at_head(head1, 13);
    head1 = insert_at_head(head1, 12);
    head1 = insert_at_head(head1, 10);
    head1 = insert_at_head(head1, 5);
    head1 = insert_at_head(head1, 1);
  
    head2 = insert_at_head(head2, 9);
    head2 = insert_at_head(head2, 7);
    head2 = insert_at_head(head2, 2)
  
    # Merging the linked lists
    head1 = merge_alternate(head1, head2);
  
    printx(head1);
 
  # This code is contributed by rutvik_56

// C# program to implement
// the above approach
using System;
class GFG{
 
// Structure of a Node
class node
{
  public int data;
  public node next;
  public node(int d)
  {
    data = d;
    next = null;
  }
};
 
// Function to insert the node
// at the head of the linkedlist
static node insert_at_head(node head,
                           int data)
{
  node n = new node(data);
  n.next = head;
  head = n;
  return head;
}
 
// Function to print the linked list
static void print(node head)
{
  while (head != null)
  {
    Console.Write(head.data + " ");
    head = head.next;
  }
   
  Console.WriteLine();
  return;
}
 
// Function to merge the odd and
// even positioned nodes of two
// given linked lists alternately
static node merge_alternate(node head1,
                            node head2)
{
  // Traverse from the second
  // node of second linked list
  if (head2 != null)
    head2 = head2.next;
 
  // Stores the head of
  // the resultant list
  node head3 = null;
 
  // Stores the current node
  node cur = null;
 
  // Store the first node of
  // first list in the result
  if (head1 != null)
    head3 = head1;
 
  // Otherwise
  else
    head3 = head2;
 
  // Traverse until end of a
  // one of the list is reached
  while (head1 != null &&
         head2 != null)
  {
    // If there is a previous
    // node then connect that
    // with the current node
    if (cur != null)
      cur.next = head1;
 
    // Update the current node
    cur = head1;
 
    // If next odd node exists
    if (head1.next != null)
 
      // Store the next odd node
      head1 = head1.next.next;
 
    // Otherwise
    else
 
      // Reach end of list
      head1 = null;
 
    // Connect the first node
    // with the second node
    cur.next = head2;
 
    // Update the current node
    cur = head2;
 
    // If next even node exists
    if (head2.next != null)
 
      // Store the next even node
      head2 = head2.next.next;
 
    // Otherwise
    else
 
      // Reach the end of the list
      head2 = null;
  }
 
  // If end of the second
  // list has been reached
  while (head1 != null)
  {
    // Connect with the
    // previous node
    if (cur != null)
      cur.next = head1;
 
    // Update the current node
    cur = head1;
 
    // If next odd node exists
    if (head1.next != null)
 
      // Store the next odd node
      head1 = head1.next.next;
 
    // Otherwise
    else
 
      // Reach end of list
      head1 = null;
  }
 
  // If end of second list
  // has been reached
  while (head2 != null)
  {
    // Connect with the
    // previous node
    if (cur != null)
      cur.next = head2;
 
    // Update the current node
    cur = head2;
 
    // If next even node exists
    if (head2.next != null)
 
      // Store the next odd node
      head2 = head2.next.next;
 
    // Otherwise
    else
 
      // Reach end of list
      head2 = null;
  }
 
  // End of the resultant list
  if (cur != null)
    cur.next = null;
 
  // Returning the head of
  // the resultant node
  return head3;
}
 
// Driver Code
public static void Main(String[] args)
{
  node head1 = null, head2 = null;
 
  // Create linked list
  head1 = insert_at_head(head1, 6);
  head1 = insert_at_head(head1, 19);
  head1 = insert_at_head(head1, 13);
  head1 = insert_at_head(head1, 12);
  head1 = insert_at_head(head1, 10);
  head1 = insert_at_head(head1, 5);
  head1 = insert_at_head(head1, 1);
 
  head2 = insert_at_head(head2, 9);
  head2 = insert_at_head(head2, 7);
  head2 = insert_at_head(head2, 2);
 
  // Merging the linked lists
  head1 = merge_alternate(head1, head2);
 
  print(head1);
}
}
 
// This code is contributed by Princi Singh

<script>
// javascript program to implement
// the above approach
 
    // Structure of a Node
     class node {
 
        constructor(d) {
            this.data = d;
            this.next = null;
        }
    }
    // Function to insert the node
    // at the head of the linkedlist
    function insert_at_head( head , data) {
         n = new node(data);
        n.next = head;
        head = n;
        return head;
    }
 
    // Function to print the linked list
    function print( head) {
        while (head != null) {
            document.write(head.data + " ");
            head = head.next;
        }
        document.write();
        return;
    }
 
    // Function to merge the odd and
    // even positioned nodes of two
    // given linked lists alternately
    function merge_alternate( head1,  head2) {
        // Traverse from the second
        // node of second linked list
        if (head2 != null)
            head2 = head2.next;
 
        // Stores the head of
        // the resultant list
         head3 = null;
 
        // Stores the current node
         cur = null;
 
        // Store the first node of
        // first list in the result
        if (head1 != null)
            head3 = head1;
 
        // Otherwise
        else
            head3 = head2;
 
        // Traverse until end of a
        // one of the list is reached
        while (head1 != null && head2 != null) {
            // If there is a previous node then
            // connect that with the current node
            if (cur != null)
                cur.next = head1;
 
            // Update the current node
            cur = head1;
 
            // If next odd node exists
            if (head1.next != null)
 
                // Store the next odd node
                head1 = head1.next.next;
 
            // Otherwise
            else
 
                // Reach end of list
                head1 = null;
 
            // Connect the first node
            // with the second node
            cur.next = head2;
 
            // Update the current node
            cur = head2;
 
            // If next even node exists
            if (head2.next != null)
 
                // Store the next even node
                head2 = head2.next.next;
 
            // Otherwise
            else
 
                // Reach the end of the list
                head2 = null;
        }
 
        // If end of the second
        // list has been reached
        while (head1 != null) {
            // Connect with the
            // previous node
            if (cur != null)
                cur.next = head1;
 
            // Update the current node
            cur = head1;
 
            // If next odd node exists
            if (head1.next != null)
 
                // Store the next odd node
                head1 = head1.next.next;
 
            // Otherwise
            else
 
                // Reach end of list
                head1 = null;
        }
 
        // If end of second list
        // has been reached
        while (head2 != null) {
            // Connect with the
            // previous node
            if (cur != null)
                cur.next = head2;
 
            // Update the current node
            cur = head2;
 
            // If next even node exists
            if (head2.next != null)
 
                // Store the next odd node
                head2 = head2.next.next;
 
            // Otherwise
            else
 
                // Reach end of list
                head2 = null;
        }
 
        // End of the resultant list
        if (cur != null)
            cur.next = null;
 
        // Returning the head of
        // the resultant node
        return head3;
    }
 
    // Driver Code
     
         head1 = null, head2 = null;
 
        // Create linked list
        head1 = insert_at_head(head1, 6);
        head1 = insert_at_head(head1, 19);
        head1 = insert_at_head(head1, 13);
        head1 = insert_at_head(head1, 12);
        head1 = insert_at_head(head1, 10);
        head1 = insert_at_head(head1, 5);
        head1 = insert_at_head(head1, 1);
 
        head2 = insert_at_head(head2, 9);
        head2 = insert_at_head(head2, 7);
        head2 = insert_at_head(head2, 2);
 
        // Merging the linked lists
        head1 = merge_alternate(head1, head2);
 
        print(head1);
 
// This code is contributed by umadevi9616
</script>

1 7 10 13 6

Complejidad temporal: O(N)
Espacio auxiliar: O(1)