Programa C++ para escribir una función para obtener el Node N en una lista vinculada

Escriba una función GetNth() que tome una lista enlazada y un índice entero y devuelva el valor de datos almacenado en el Node en esa posición de índice. 

Ejemplo: 

Input:  1->10->30->14,  index = 2
Output: 30  
The node at index 2 is 30

Algoritmo: 

1. Initialize count = 0
2. Loop through the link list
     a. If count is equal to the passed index then return current
         node
     b. Increment count
     c. change current to point to next of the current.

Implementación: 

// C++ program to find n'th
// node in linked list
#include <assert.h>
#include <bits/stdc++.h>
using namespace std;
 
// Link list node
class Node
{
    public:
    int data;
    Node* next;
};
 
/* Given a reference (pointer to
pointer) to the head of a list
and an int, push a new node on
the front of the 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;
}
 
// Takes head pointer of
// the linked list and index
// as arguments and return
// data at index
int GetNth(Node* head, int index)
{
    Node* current = head;
 
    // The index of the
    // node we're currently
    // looking at
    int count = 0;
    while (current != NULL)
    {
        if (count == index)
            return (current->data);
        count++;
        current = current->next;
    }
 
    /* If we get to this line,
    the caller was asking
    for a non-existent element
    so we assert fail */
    assert(0);
}
 
// Driver Code
int main()
{
    // Start with the empty list
    Node* head = NULL;
 
    // Use push() to construct list
    // 1->12->1->4->1
    push(&head, 1);
    push(&head, 4);
    push(&head, 1);
    push(&head, 12);
    push(&head, 1);
 
    // Check the count function
    cout << "Element at index 3 is " <<
             GetNth(head, 3);
    return 0;
}
// This code is contributed by rathbhupendra

Producción:

Element at index 3 is 4

Complejidad de tiempo: O(n)

Complejidad espacial: O(1) usando solo variables constantes

Método 2: con recursividad: 
este método lo aporta MY_DOOM . 

Algoritmo:  

getnth(node,n)
1. Initialize count = 0
2. if count==n
     return node->data
3. else
    return getnth(node->next,n-1)

Implementación: 

// C++ program to find n'th node in
// linked list using recursion
#include <bits/stdc++.h>
using namespace std;
 
// Link list node
struct Node
{
    int data;
    struct Node* next;
};
 
/*  Given a reference (pointer to pointer)
    to the head of a list and an int, push
    a new node on the front of the list. */
void push(struct Node** head_ref,
          int new_data)
{
    // Allocate node
    struct Node* new_node =
           (struct Node*)malloc(sizeof(struct 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;
}
 
/* Takes head pointer of the linked list and
   index as arguments and return data at index.
   (Don't use another variable)*/
int GetNth(struct Node* head, int n)
{
    // If length of the list is less
    // than the given index, return -1
    if (head == NULL)
        return -1;
 
    // If n equal to 0 return node->data
    if (n == 0)
        return head->data;
 
    // Increase head to next pointer
    // n - 1: decrease the number of
    // recursions until n = 0
    return GetNth(head->next, n - 1);
}
 
// Driver code
int main()
{
    // Start with the empty list
    struct Node* head = NULL;
 
    // Use push() to construct list
    // 1->12->1->4->1
    push(&head, 1);
    push(&head, 4);
    push(&head, 1);
    push(&head, 12);
    push(&head, 1);
 
    // Check the count function
    printf("Element at index 3 is %d",
            GetNth(head, 3));
    getchar();
}

Producción:

Element at index 3 is 4

Complejidad de tiempo: O(n) 

Complejidad espacial : O (n) ya que usa espacio constante para crear Nodes

¡ Consulte el artículo completo sobre Escribir una función para obtener el enésimo Node en una lista vinculada para obtener más detalles!