在倒数第 N 个节点之后插入一个节点的Java程序

在给定的单链表中，在倒数第 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) 个节点，并在该节点之后插入新节点。此方法需要对列表进行两次遍历。

Java

// Java implementation to insert a node after 
// the n-th node from the end 
class GfG 
{
  
// structure of a node 
static class Node 
{ 
    int data; 
    Node next; 
}
  
// function to get a new node 
static Node getNode(int data) 
{ 
    // allocate memory for the node 
    Node newNode = new 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 
static 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 
static void printList(Node head) 
{ 
    while (head != null)
    { 
        System.out.print(head.data + " "); 
        head = head.next; 
    } 
} 
  
// Driver code 
public static void main(String[] args) 
{ 
    // 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; 
  
    System.out.print("Original Linked List: "); 
    printList(head); 
  
    insertAfterNthNode(head, n, x); 
    System.out.println();
    System.out.print("Linked List After Insertion: "); 
    printList(head); 
}
} 
  
// This code is contributed by prerna saini

输出：

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 个节点。在该节点之后插入新节点。此方法需要单次遍历列表。

Java

// Java implementation to 
// insert a node after the 
// nth node from the end 
class GfG
{ 
  
// structure of a node 
static class Node 
{ 
    int data; 
    Node next; 
}
  
// function to get a new node 
static Node getNode(int data) 
{ 
    // allocate memory for the node 
    Node newNode = new 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 
static 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 
static void printList(Node head) 
{ 
    while (head != null) 
    { 
        System.out.print(head.data + " "); 
        head = head.next; 
    } 
} 
  
// Driver code 
public static void main(String[] args) 
{ 
    // 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; 
    System.out.println("Original Linked List: "); 
    printList(head); 
  
    insertAfterNthNode(head, n, x); 
    System.out.println();
    System.out.println("Linked List After Insertion: "); 
    printList(head); 
}
} 
  
// This code is contributed by
// Prerna Saini.

输出：

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

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

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