C++ 程序，用于在倒数第 N 个节点之后插入一个节点

在给定的单链表中，在倒数第 n 个节点之后插入一个节点x 。保证列表包含倒数第 n 个节点。还有 1 <= n。

例子：

Input : list: 1->3->4->5
        n = 4, x = 2
Output : 1->2->3->4->5
4th node from the end is 1 and
insertion has been done after this node.

Input : list: 10->8->3->12->5->18
        n = 2, x = 11
Output : 10->8->3->12->5->11->18

方法1（使用列表的长度）：
求链表的长度，即链表中的节点数。让它成为len 。现在从头开始遍历列表的第一个节点到第(len-n+1) 个节点，并在该节点之后插入新节点。此方法需要对列表进行两次遍历。

C++

// C++ implementation to insert a node after
// the n-th node from the end
#include 
using namespace std;
  
// structure of a node
struct Node {
    int data;
    Node* next;
};
  
// function to get a new node
Node* getNode(int data)
{
    // allocate memory for the node
    Node* newNode = (Node*)malloc(sizeof(Node));
  
    // put in the data
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}
  
// function to insert a node after the
// nth node from the end
void insertAfterNthNode(Node* head, int n, int x)
{
    // if list is empty
    if (head == NULL)
        return;
  
    // get a new node for the value 'x'
    Node* newNode = getNode(x);
    Node* ptr = head;
    int len = 0, i;
  
    // find length of the list, i.e, the
    // number of nodes in the list
    while (ptr != NULL) {
        len++;
        ptr = ptr->next;
    }
  
    // traverse up to the nth node from the end
    ptr = head;
    for (i = 1; i <= (len - n); i++)
        ptr = ptr->next;
  
    // insert the 'newNode' by making the
    // necessary adjustment in the links
    newNode->next = ptr->next;
    ptr->next = newNode;
}
  
// function to print the list
void printList(Node* head)
{
    while (head != NULL) {
        cout << head->data << " ";
        head = head->next;
    }
}
  
// Driver program to test above
int main()
{
    // Creating list 1->3->4->5
    Node* head = getNode(1);
    head->next = getNode(3);
    head->next->next = getNode(4);
    head->next->next->next = getNode(5);
  
    int n = 4, x = 2;
  
    cout << "Original Linked List: ";
    printList(head);
  
    insertAfterNthNode(head, n, x);
  
    cout << "
Linked List After Insertion: ";
    printList(head);
  
    return 0;
}

输出：

Original Linked List: 1 3 4 5
Linked List After Insertion: 1 2 3 4 5

时间复杂度： O(n)，其中n是列表中的节点数。

方法二（单次遍历）：
该方法使用两个指针，一个是slow_ptr ，另一个是fast_ptr 。首先将fast_ptr 从头向上移动到第n 个节点。使slow_ptr指向列表的第一个节点。现在，同时移动两个指针，直到fast_ptr指向最后一个节点。此时， slow_ptr将指向从末尾算起的第 n 个节点。在该节点之后插入新节点。此方法需要单次遍历列表。

C++

// C++ implementation to insert a node after the
// nth node from the end
#include 
  
using namespace std;
  
// structure of a node
struct Node {
    int data;
    Node* next;
};
  
// function to get a new node
Node* getNode(int data)
{
    // allocate memory for the node
    Node* newNode = (Node*)malloc(sizeof(Node));
  
    // put in the data
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}
  
// function to insert a node after the
// nth node from the end
void insertAfterNthNode(Node* head, int n, int x)
{
    // if list is empty
    if (head == NULL)
        return;
  
    // get a new node for the value 'x'
    Node* newNode = getNode(x);
  
    // Initializing the slow and fast pointers
    Node* slow_ptr = head;
    Node* fast_ptr = head;
  
    // move 'fast_ptr' to point to the nth node
    // from the beginning
    for (int i = 1; i <= n - 1; i++)
        fast_ptr = fast_ptr->next;
  
    // iterate until 'fast_ptr' points to the
    // last node
    while (fast_ptr->next != NULL) {
  
        // move both the pointers to the
        // respective next nodes
        slow_ptr = slow_ptr->next;
        fast_ptr = fast_ptr->next;
    }
  
    // insert the 'newNode' by making the
    // necessary adjustment in the links
    newNode->next = slow_ptr->next;
    slow_ptr->next = newNode;
}
  
// function to print the list
void printList(Node* head)
{
    while (head != NULL) {
        cout << head->data << " ";
        head = head->next;
    }
}
  
// Driver program to test above
int main()
{
    // Creating list 1->3->4->5
    Node* head = getNode(1);
    head->next = getNode(3);
    head->next->next = getNode(4);
    head->next->next->next = getNode(5);
  
    int n = 4, x = 2;
  
    cout << "Original Linked List: ";
    printList(head);
  
    insertAfterNthNode(head, n, x);
  
    cout << "
Linked List After Insertion: ";
    printList(head);
  
    return 0;
}

输出：

Original Linked List: 1 3 4 5
Linked List After Insertion: 1 2 3 4 5

时间复杂度： O(n)，其中n是列表中的节点数。

有关详细信息，请参阅关于在倒数第 n 个节点之后插入节点的完整文章！