# Swap Kth node from beginning with Kth node from end in a Linked List

Last Updated : 10 Jan, 2023

Given a singly linked list, swap kth node from beginning with kth node from end. Swapping of data is not allowed, only pointers should be changed. This requirement may be logical in many situations where the linked list data part is huge (For example student details like Name, RollNo, Address, ..etc). The pointers are always fixed (4 bytes for most of the compilers)

Example:

Input: 5 -> 10 -> 8 -> 5 -> 9 -> 3, K = 2
Output: 5 -> 9 -> 8 -> 5 -> 10 -> 3
Explanation: The 2nd node from 1st is 10 and 2nd node from last is 9, so swap them.

Input: 1 -> 2 -> 3 -> 4 -> 5, K = 5
Output: 5 -> 2 -> 3 -> 4 -> 1
Explanation: The 5th node from 1st is 5 and 5th node from last is 1, so swap them.

Recommended Practice

Approach: To solve the problem follow the below idea:

The idea is very simple to find the kth node from the start and the kth node from the last is n-k+1th node from start. Swap both nodes
However, there are some corner cases, which must be handled

• Y is next to X
• X is next to Y
• X and Y are the same
• X and Y don’t exist (k is more than the number of nodes in the linked list)

Below is the implementation of the above approach:

## C++

 `// A C++ program to swap Kth node from beginning with kth ` `// node from end ` `#include ` `using` `namespace` `std; ` ` `  `// A Linked List node ` `typedef` `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node* next; ` `} Node; ` ` `  `// Utility function to insert a node at the beginning ` `void` `push(Node** head_ref, ``int` `new_data) ` `{ ` `    ``Node* new_node = (Node*)``malloc``(``sizeof``(Node)); ` `    ``new_node->data = new_data; ` `    ``new_node->next = (*head_ref); ` `    ``(*head_ref) = new_node; ` `} ` ` `  `/* Utility function for displaying linked list */` `void` `printList(Node* node) ` `{ ` `    ``while` `(node != NULL) { ` `        ``cout << node->data << ``" "``; ` `        ``node = node->next; ` `    ``} ` `    ``cout << endl; ` `} ` ` `  `/* Utility function for calculating ` `   ``length of linked list */` `int` `countNodes(``struct` `Node* s) ` `{ ` `    ``int` `count = 0; ` `    ``while` `(s != NULL) { ` `        ``count++; ` `        ``s = s->next; ` `    ``} ` `    ``return` `count; ` `} ` ` `  `// Utility function for calculating length of linked list ` `void` `swapKth(``struct` `Node** head_ref, ``int` `k) ` `{ ` `    ``// Count nodes in linked list ` `    ``int` `n = countNodes(*head_ref); ` `    ``// Check if k is valid ` `    ``if` `(n < k) ` `        ``return``; ` `    ``// If x (kth node from start) and y(kth node from end) ` `    ``// are same ` `    ``if` `(2 * k - 1 == n) ` `        ``return``; ` `    ``// Find the kth node from the beginning of the linked ` `    ``// list. We also find previous of kth node because we ` `    ``// need to update next pointer of the previous. ` `    ``Node* x = *head_ref; ` `    ``Node* x_prev = NULL; ` `    ``for` `(``int` `i = 1; i < k; i++) { ` `        ``x_prev = x; ` `        ``x = x->next; ` `    ``} ` `    ``// Similarly, find the kth node from end and its ` `    ``// previous. kth node from end is (n-k+1)th node from ` `    ``// beginning ` `    ``Node* y = *head_ref; ` `    ``Node* y_prev = NULL; ` `    ``for` `(``int` `i = 1; i < n - k + 1; i++) { ` `        ``y_prev = y; ` `        ``y = y->next; ` `    ``} ` `    ``// If x_prev exists, then new next of it will be y. ` `    ``// Consider the case when y->next is x, in this case, ` `    ``// x_prev and y are same. So the statement "x_prev->next ` `    ``// = y" creates a self loop. This self loop will be ` `    ``// broken when we change y->next. ` `    ``if` `(x_prev) ` `        ``x_prev->next = y; ` `    ``// Same thing applies to y_prev ` `    ``if` `(y_prev) ` `        ``y_prev->next = x; ` `    ``// Swap next pointers of x and y. These statements also ` `    ``// break self loop if x->next is y or y->next is x ` `    ``Node* temp = x->next; ` `    ``x->next = y->next; ` `    ``y->next = temp; ` `    ``// Change head pointers when k is 1 or n ` `    ``if` `(k == 1) ` `        ``*head_ref = y; ` `    ``if` `(k == n) ` `        ``*head_ref = x; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``// Let us create the following linked list for testing ` `    ``// 1->2->3->4->5->6->7->8 ` `    ``struct` `Node* head = NULL; ` `    ``for` `(``int` `i = 8; i >= 1; i--) ` `        ``push(&head, i); ` `    ``cout << ``"Original Linked List: "``; ` `    ``printList(head); ` `    ``for` `(``int` `k = 1; k < 9; k++) { ` ` `  `        ``// Function call ` `        ``swapKth(&head, k); ` `        ``cout << ``"\nModified List for k = "` `<< k << endl; ` `        ``printList(head); ` `    ``} ` `    ``return` `0; ` `} ` ` `  `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// A C program to swap Kth node from beginning with kth ` `// node from end ` `#include ` `#include ` ` `  `// A Linked List node ` `typedef` `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node* next; ` `} Node; ` ` `  `// Utility function to insert a node at the beginning ` `void` `push(Node** head_ref, ``int` `new_data) ` `{ ` `    ``Node* new_node = (Node*)``malloc``(``sizeof``(Node)); ` `    ``new_node->data = new_data; ` `    ``new_node->next = (*head_ref); ` `    ``(*head_ref) = new_node; ` `} ` ` `  `// Utility function for displaying linked list ` `void` `printList(Node* node) ` `{ ` `    ``while` `(node != NULL) { ` `        ``printf``(``"%d "``, node->data); ` `        ``node = node->next; ` `    ``} ` `    ``printf``(``"\n"``); ` `} ` ` `  `// Utility function for calculating length of linked list ` `int` `countNodes(Node* s) ` `{ ` `    ``int` `count = 0; ` `    ``while` `(s != NULL) { ` `        ``count++; ` `        ``s = s->next; ` `    ``} ` `    ``return` `count; ` `} ` ` `  `// Function for swapping kth nodes from both ends of linked ` `// list ` `void` `swapKth(Node** head_ref, ``int` `k) ` `{ ` `    ``// Count nodes in linked list ` `    ``int` `n = countNodes(*head_ref); ` `    ``// Check if k is valid ` `    ``if` `(n < k) ` `        ``return``; ` `    ``// If x (kth node from start) and y(kth node from end) ` `    ``// are same ` `    ``if` `(2 * k - 1 == n) ` `        ``return``; ` `    ``// Find the kth node from the beginning of the linked ` `    ``// list. We also find previous of kth node because we ` `    ``// need to update next pointer of the previous. ` `    ``Node* x = *head_ref; ` `    ``Node* x_prev = NULL; ` `    ``for` `(``int` `i = 1; i < k; i++) { ` `        ``x_prev = x; ` `        ``x = x->next; ` `    ``} ` `    ``// Similarly, find the kth node from end and its ` `    ``// previous. kth node from end is (n-k+1)th node from ` `    ``// beginning ` `    ``Node* y = *head_ref; ` `    ``Node* y_prev = NULL; ` `    ``for` `(``int` `i = 1; i < n - k + 1; i++) { ` `        ``y_prev = y; ` `        ``y = y->next; ` `    ``} ` `    ``// If x_prev exists, then new next of it will be y. ` `    ``// Consider the case when y->next is x, in this case, ` `    ``// x_prev and y are same. So the statement "x_prev->next ` `    ``// = y" creates a self loop. This self loop will be ` `    ``// broken when we change y->next. ` `    ``if` `(x_prev) ` `        ``x_prev->next = y; ` `    ``// Same thing applies to y_prev ` `    ``if` `(y_prev) ` `        ``y_prev->next = x; ` `    ``// Swap next pointers of x and y. These statements also ` `    ``// break self loop if x->next is y or y->next is x ` `    ``Node* temp = x->next; ` `    ``x->next = y->next; ` `    ``y->next = temp; ` `    ``// Change head pointers when k is 1 or n ` `    ``if` `(k == 1) ` `        ``*head_ref = y; ` `    ``if` `(k == n) ` `        ``*head_ref = x; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``// Let us create the following linked list for testing ` `    ``// 1->2->3->4->5->6->7->8 ` `    ``Node* head = NULL; ` `    ``for` `(``int` `i = 8; i >= 1; i--) ` `        ``push(&head, i); ` `    ``printf``(``"Original Linked List: "``); ` `    ``printList(head); ` `    ``for` `(``int` `k = 1; k < 9; k++) { ` ` `  `        ``// Function call ` `        ``swapKth(&head, k); ` `        ``printf``(``"\nModified List for k = %d\n"``, k); ` `        ``printList(head); ` `    ``} ` `    ``return` `0; ` `} ` ` `  `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `// A Java program to swap kth node from the beginning with ` `// kth node from the end ` ` `  `class` `Node { ` `    ``int` `data; ` `    ``Node next; ` `    ``Node(``int` `d) ` `    ``{ ` `        ``data = d; ` `        ``next = ``null``; ` `    ``} ` `} ` ` `  `class` `LinkedList { ` `    ``Node head; ` ` `  `    ``// Utility function to insert a node at the beginning ` `    ``void` `push(``int` `new_data) ` `    ``{ ` `        ``Node new_node = ``new` `Node(new_data); ` `        ``new_node.next = head; ` `        ``head = new_node; ` `    ``} ` ` `  `    ``/* Utility function for displaying linked list */` `    ``void` `printList() ` `    ``{ ` `        ``Node node = head; ` `        ``while` `(node != ``null``) { ` `            ``System.out.print(node.data + ``" "``); ` `            ``node = node.next; ` `        ``} ` `        ``System.out.println(``""``); ` `    ``} ` ` `  `    ``// Utility function for calculating length of linked ` `    ``// list ` `    ``int` `countNodes() ` `    ``{ ` `        ``int` `count = ``0``; ` `        ``Node s = head; ` `        ``while` `(s != ``null``) { ` `            ``count++; ` `            ``s = s.next; ` `        ``} ` `        ``return` `count; ` `    ``} ` ` `  `    ``// Function for swapping kth nodes from both ends of ` `    ``// linked list ` `    ``void` `swapKth(``int` `k) ` `    ``{ ` `        ``// Count nodes in linked list ` `        ``int` `n = countNodes(); ` ` `  `        ``// Check if k is valid ` `        ``if` `(n < k) ` `            ``return``; ` ` `  `        ``// If x (kth node from start) and ` `        ``// y(kth node from end) are same ` `        ``if` `(``2` `* k - ``1` `== n) ` `            ``return``; ` ` `  `        ``// Find the kth node from beginning of linked list. ` `        ``// We also find previous of kth node because we need ` `        ``// to update next pointer of the previous. ` `        ``Node x = head; ` `        ``Node x_prev = ``null``; ` `        ``for` `(``int` `i = ``1``; i < k; i++) { ` `            ``x_prev = x; ` `            ``x = x.next; ` `        ``} ` ` `  `        ``// Similarly, find the kth node from end and its ` `        ``// previous. kth node from end is (n-k+1)th node ` `        ``// from beginning ` `        ``Node y = head; ` `        ``Node y_prev = ``null``; ` `        ``for` `(``int` `i = ``1``; i < n - k + ``1``; i++) { ` `            ``y_prev = y; ` `            ``y = y.next; ` `        ``} ` ` `  `        ``// If x_prev exists, then new next of it will be y. ` `        ``// Consider the case when y->next is x, in this ` `        ``// case, x_prev and y are same. So the statement ` `        ``// "x_prev->next = y" creates a self loop. This self ` `        ``// loop will be broken when we change y->next. ` `        ``if` `(x_prev != ``null``) ` `            ``x_prev.next = y; ` ` `  `        ``// Same thing applies to y_prev ` `        ``if` `(y_prev != ``null``) ` `            ``y_prev.next = x; ` ` `  `        ``// Swap next pointers of x and y. These statements ` `        ``// also break self loop if x->next is y or y->next ` `        ``// is x ` `        ``Node temp = x.next; ` `        ``x.next = y.next; ` `        ``y.next = temp; ` ` `  `        ``// Change head pointers when k is 1 or n ` `        ``if` `(k == ``1``) ` `            ``head = y; ` ` `  `        ``if` `(k == n) ` `            ``head = x; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``LinkedList llist = ``new` `LinkedList(); ` `        ``for` `(``int` `i = ``8``; i >= ``1``; i--) ` `            ``llist.push(i); ` ` `  `        ``System.out.print(``"Original linked list: "``); ` `        ``llist.printList(); ` `        ``System.out.println(``""``); ` ` `  `        ``for` `(``int` `i = ``1``; i < ``9``; i++) { ` ` `  `            ``// Function call ` `            ``llist.swapKth(i); ` `            ``System.out.println(``"Modified List for k = "` `                               ``+ i); ` `            ``llist.printList(); ` `            ``System.out.println(``""``); ` `        ``} ` `    ``} ` `} ` ` `  `// This code is contributed by Aditya Kumar (adityakumar129)`

## Python3

 `""" ` `A Python3 program to swap kth node from  ` `the beginning with kth node from the end ` `"""` ` `  ` `  `class` `Node: ` `    ``def` `__init__(``self``, data, ``next``=``None``): ` `        ``self``.data ``=` `data ` `        ``self``.``next` `=` `next` ` `  ` `  `class` `LinkedList: ` ` `  `    ``def` `__init__(``self``, ``*``args, ``*``*``kwargs): ` `        ``self``.head ``=` `Node(``None``) ` `    ``""" ` `    ``Utility function to insert a node at the beginning ` `    ``@args: ` `        ``data: value of node ` `    ``"""` ` `  `    ``def` `push(``self``, data): ` `        ``node ``=` `Node(data) ` `        ``node.``next` `=` `self``.head ` `        ``self``.head ``=` `node ` ` `  `    ``# Print linked list ` `    ``def` `printList(``self``): ` `        ``node ``=` `self``.head ` `        ``while` `node.``next` `is` `not` `None``: ` `            ``print``(node.data, end``=``" "``) ` `            ``node ``=` `node.``next` ` `  `    ``# count number of node in linked list ` `    ``def` `countNodes(``self``): ` `        ``count ``=` `0` `        ``node ``=` `self``.head ` `        ``while` `node.``next` `is` `not` `None``: ` `            ``count ``+``=` `1` `            ``node ``=` `node.``next` `        ``return` `count ` ` `  `    ``""" ` `    ``Function for swapping kth nodes from ` `    ``both ends of linked list ` `    ``"""` ` `  `    ``def` `swapKth(``self``, k): ` ` `  `        ``# Count nodes in linked list ` `        ``n ``=` `self``.countNodes() ` ` `  `        ``# check if k is valid ` `        ``if` `n < k: ` `            ``return` ` `  `        ``""" ` `        ``If x (kth node from start) and  ` `        ``y(kth node from end) are same  ` `        ``"""` `        ``if` `(``2` `*` `k ``-` `1``) ``=``=` `n: ` `            ``return` ` `  `        ``""" ` `        ``Find the kth node from beginning of linked list.  ` `        ``We also find previous of kth node because we need  ` `        ``to update next pointer of the previous.  ` `        ``"""` `        ``x ``=` `self``.head ` `        ``x_prev ``=` `Node(``None``) ` `        ``for` `i ``in` `range``(k ``-` `1``): ` `            ``x_prev ``=` `x ` `            ``x ``=` `x.``next` ` `  `        ``""" ` `        ``Similarly, find the kth node from end and its  ` `        ``previous. kth node from end is (n-k + 1)th node  ` `        ``from beginning  ` `        ``"""` `        ``y ``=` `self``.head ` `        ``y_prev ``=` `Node(``None``) ` `        ``for` `i ``in` `range``(n ``-` `k): ` `            ``y_prev ``=` `y ` `            ``y ``=` `y.``next` ` `  `        ``""" ` `        ``If x_prev exists, then new next of it will be y.  ` `        ``Consider the case when y->next is x, in this case,  ` `        ``x_prev and y are same. So the statement  ` `        ``"x_prev->next = y" creates a self loop. This self  ` `        ``loop will be broken when we change y->next.  ` `        ``"""` `        ``if` `x_prev ``is` `not` `None``: ` `            ``x_prev.``next` `=` `y ` ` `  `        ``# Same thing applies to y_prev ` `        ``if` `y_prev ``is` `not` `None``: ` `            ``y_prev.``next` `=` `x ` ` `  `        ``""" ` `        ``Swap next pointers of x and y. These statements  ` `        ``also break self loop if x->next is y or y->next  ` `        ``is x  ` `        ``"""` `        ``temp ``=` `x.``next` `        ``x.``next` `=` `y.``next` `        ``y.``next` `=` `temp ` ` `  `        ``# Change head pointers when k is 1 or n ` `        ``if` `k ``=``=` `1``: ` `            ``self``.head ``=` `y ` ` `  `        ``if` `k ``=``=` `n: ` `            ``self``.head ``=` `x ` ` `  ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` `    ``llist ``=` `LinkedList() ` `    ``for` `i ``in` `range``(``8``, ``0``, ``-``1``): ` `        ``llist.push(i) ` `    ``llist.printList() ` `    ``print``(``"\n"``) ` ` `  `    ``for` `i ``in` `range``(``1``, ``9``): ` ` `  `            ``# Function call ` `        ``llist.swapKth(i) ` `        ``print``(``"Modified List for k = "``, i) ` `        ``llist.printList() ` `        ``print``(``"\n"``) ` ` `  `# This code is contributed by Pulkit `

## C#

 `// C# program to swap kth node from the beginning with ` `// kth node from the end ` `using` `System; ` ` `  `public` `class` `Node { ` `    ``public` `int` `data; ` `    ``public` `Node next; ` `    ``public` `Node(``int` `d) ` `    ``{ ` `        ``data = d; ` `        ``next = ``null``; ` `    ``} ` `} ` ` `  `public` `class` `LinkedList { ` `    ``Node head; ` ` `  `    ``/* Utility function to insert ` `    ``a node at the beginning */` `    ``void` `push(``int` `new_data) ` `    ``{ ` `        ``Node new_node = ``new` `Node(new_data); ` `        ``new_node.next = head; ` `        ``head = new_node; ` `    ``} ` ` `  `    ``/* Utility function for displaying linked list */` `    ``void` `printList() ` `    ``{ ` `        ``Node node = head; ` `        ``while` `(node != ``null``) { ` `            ``Console.Write(node.data + ``" "``); ` `            ``node = node.next; ` `        ``} ` `        ``Console.WriteLine(``""``); ` `    ``} ` ` `  `    ``/* Utility function for calculating ` `    ``length of linked list */` `    ``int` `countNodes() ` `    ``{ ` `        ``int` `count = 0; ` `        ``Node s = head; ` `        ``while` `(s != ``null``) { ` `            ``count++; ` `            ``s = s.next; ` `        ``} ` `        ``return` `count; ` `    ``} ` ` `  `    ``/* Function for swapping kth nodes from ` `    ``both ends of linked list */` `    ``void` `swapKth(``int` `k) ` `    ``{ ` `        ``// Count nodes in linked list ` `        ``int` `n = countNodes(); ` ` `  `        ``// Check if k is valid ` `        ``if` `(n < k) ` `            ``return``; ` ` `  `        ``// If x (kth node from start) and y(kth node from ` `        ``// end) are same ` `        ``if` `(2 * k - 1 == n) ` `            ``return``; ` ` `  `        ``// Find the kth node from beginning of linked list. ` `        ``// We also find previous of kth node because we need ` `        ``// to update next pointer of the previous. ` `        ``Node x = head; ` `        ``Node x_prev = ``null``; ` `        ``for` `(``int` `i = 1; i < k; i++) { ` `            ``x_prev = x; ` `            ``x = x.next; ` `        ``} ` ` `  `        ``// Similarly, find the kth node from end and its ` `        ``// previous. kth node from end is (n-k+1)th node ` `        ``// from beginning ` `        ``Node y = head; ` `        ``Node y_prev = ``null``; ` `        ``for` `(``int` `i = 1; i < n - k + 1; i++) { ` `            ``y_prev = y; ` `            ``y = y.next; ` `        ``} ` ` `  `        ``// If x_prev exists, then new next of it will be y. ` `        ``// Consider the case when y->next is x, in this ` `        ``// case, x_prev and y are same. So the statement ` `        ``// "x_prev->next = y" creates a self loop. This self ` `        ``// loop will be broken when we change y->next. ` `        ``if` `(x_prev != ``null``) ` `            ``x_prev.next = y; ` ` `  `        ``// Same thing applies to y_prev ` `        ``if` `(y_prev != ``null``) ` `            ``y_prev.next = x; ` ` `  `        ``// Swap next pointers of x and y. These statements ` `        ``// also break self loop if x->next is y or y->next ` `        ``// is x ` `        ``Node temp = x.next; ` `        ``x.next = y.next; ` `        ``y.next = temp; ` ` `  `        ``// Change head pointers when k is 1 or n ` `        ``if` `(k == 1) ` `            ``head = y; ` ` `  `        ``if` `(k == n) ` `            ``head = x; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `        ``LinkedList llist = ``new` `LinkedList(); ` `        ``for` `(``int` `i = 8; i >= 1; i--) ` `            ``llist.push(i); ` ` `  `        ``Console.Write(``"Original linked list: "``); ` `        ``llist.printList(); ` `        ``Console.WriteLine(``""``); ` ` `  `        ``for` `(``int` `i = 1; i < 9; i++) { ` ` `  `            ``// Function call ` `            ``llist.swapKth(i); ` `            ``Console.WriteLine(``"Modified List for k = "` `+ i); ` `            ``llist.printList(); ` `            ``Console.WriteLine(``""``); ` `        ``} ` `    ``} ` `} ` ` `  `// This code has been contributed by 29AjayKumar`

## Javascript

 ``

Output

```Original Linked List: 1 2 3 4 5 6 7 8

Modified List for k = 1
8 2 3 4 5 6 7 1

Modified List for k = 2
8 7 3 4 5 6 2 1

Modified List for k = 3
8 7 6 4 5 3 2 1

Modified List for k = 4
8 7 6 5 4 3 2 1

Modified List for k = 5
8 7 6 4 5 3 2 1

Modified List for k = 6
8 7 3 4 5 6 2 1

Modified List for k = 7
8 2 3 4 5 6 7 1

Modified List for k = 8
1 2 3 4 5 6 7 8 ```

Time Complexity: O(N), where N is the length of the list. One traversal of the list is needed.
Auxiliary Space: O(1). No extra space is required.

Please note that the above code runs three separate loops to count nodes, find x and x prev, and to find y and y_prev. These three things can be done in a single loop. The code uses three loops to keep things simple and readable.

Previous
Next