 Open in App
Not now

# Exchange first and last nodes in Circular Linked List

• Difficulty Level : Easy
• Last Updated : 22 Feb, 2023

Given Circular linked list exchange the first and the last node. The task should be done with only one extra node, you can not declare more than one extra node, and also you are not allowed to declare any other temporary variable.

Note: Extra node means the need of a node to traverse a list. Examples:

Input : 5 4 3 2 1
Output : 1 4 3 2 5

Input  : 6 1 2 3 4 5 6 7 8 9
Output : 9 1 2 3 4 5 6 7 8 6

Method 1: (By Changing Links of First and Last Nodes)

We first find a pointer to the previous to the last node. Let this node be p. Now we change the next links so that the last and first nodes are swapped.

## C++

 `// CPP program to exchange first and` `// last node in circular linked list` `#include ` `using` `namespace` `std;`   `struct` `Node {` `    ``int` `data;` `    ``struct` `Node* next;` `};`   `struct` `Node* addToEmpty(``struct` `Node* head, ``int` `data)` `{` `    ``// This function is only for empty list` `    ``if` `(head != NULL)` `        ``return` `head;`   `    ``// Creating a node dynamically.` `    ``struct` `Node* temp` `        ``= (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));`   `    ``// Assigning the data.` `    ``temp->data = data;` `    ``head = temp;`   `    ``// Creating the link.` `    ``head->next = head;`   `    ``return` `head;` `}`   `struct` `Node* addBegin(``struct` `Node* head, ``int` `data)` `{` `    ``if` `(head == NULL)` `        ``return` `addToEmpty(head, data);`   `    ``struct` `Node* temp` `        ``= (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));`   `    ``temp->data = data;` `    ``temp->next = head->next;` `    ``head->next = temp;`   `    ``return` `head;` `}`   `/* function for traversing the list */` `void` `traverse(``struct` `Node* head)` `{` `    ``struct` `Node* p;`   `    ``// If list is empty, return.` `    ``if` `(head == NULL) {` `        ``cout << ``"List is empty."` `<< endl;` `        ``return``;` `    ``}`   `    ``// Pointing to first Node of the list.` `    ``p = head;`   `    ``// Traversing the list.` `    ``do` `{` `        ``cout << p->data << ``" "``;` `        ``p = p->next;`   `    ``} ``while` `(p != head);` `}`   `/* Function to exchange first and last node*/` `struct` `Node* exchangeNodes(``struct` `Node* head)` `{` `    ``// If list is of length 2` `    ``if` `(head->next->next == head) {` `        ``head = head->next;` `        ``return` `head;` `    ``}`   `    ``// Find pointer to previous of last node` `    ``struct` `Node* p = head;` `    ``while` `(p->next->next != head)` `        ``p = p->next;`   `    ``/* Exchange first and last nodes using` `       ``head and p */` `    ``p->next->next = head->next;` `    ``head->next = p->next;` `    ``p->next = head;` `    ``head = head->next;`   `    ``return` `head;` `}`   `// Driven Program` `int` `main()` `{` `    ``int` `i;` `    ``struct` `Node* head = NULL;` `    ``head = addToEmpty(head, 6);`   `    ``for` `(i = 5; i > 0; i--)` `        ``head = addBegin(head, i);` `    ``cout << ``"List Before: "``;` `    ``traverse(head);` `    ``cout << endl;`   `    ``cout << ``"List After: "``;` `    ``head = exchangeNodes(head);` `    ``traverse(head);`   `    ``return` `0;` `}`

## Java

 `// Java program to exchange` `// first and last node in` `// circular linked list` `import` `java.util.*;` `import` `java.io.*;`   `public` `class` `GFG {`   `    ``static` `class` `Node {` `        ``int` `data;` `        ``Node next;` `    ``};`   `    ``static` `Node addToEmpty(Node head, ``int` `data)` `    ``{` `        ``// This function is only` `        ``// for empty list` `        ``if` `(head != ``null``)` `            ``return` `head;`   `        ``// Creating a node dynamically.` `        ``Node temp = ``new` `Node();`   `        ``// Assigning the data.` `        ``temp.data = data;` `        ``head = temp;`   `        ``// Creating the link.` `        ``head.next = head;`   `        ``return` `head;` `    ``}`   `    ``static` `Node addBegin(Node head, ``int` `data)` `    ``{` `        ``if` `(head == ``null``)` `            ``return` `addToEmpty(head, data);`   `        ``Node temp = ``new` `Node();`   `        ``temp.data = data;` `        ``temp.next = head.next;` `        ``head.next = temp;`   `        ``return` `head;` `    ``}`   `    ``// function for traversing the list` `    ``static` `void` `traverse(Node head)` `    ``{` `        ``Node p;`   `        ``// If list is empty, return.` `        ``if` `(head == ``null``) {` `            ``System.out.print(``"List is empty."``);` `            ``return``;` `        ``}`   `        ``// Pointing to first` `        ``// Node of the list.` `        ``p = head;`   `        ``// Traversing the list.` `        ``do` `{` `            ``System.out.print(p.data + ``" "``);` `            ``p = p.next;`   `        ``} ``while` `(p != head);` `    ``}`   `    ``// Function to exchange` `    ``// first and last node` `    ``static` `Node exchangeNodes(Node head)` `    ``{`   `        ``// If list is of length 2` `        ``if` `(head.next.next == head) {` `            ``head = head.next;` `            ``return` `head;` `        ``}` `        ``// Find pointer to previous` `        ``// of last node` `        ``Node p = head;` `        ``while` `(p.next.next != head)` `            ``p = p.next;`   `        ``// Exchange first and last` `        ``// nodes using head and p` `        ``p.next.next = head.next;` `        ``head.next = p.next;` `        ``p.next = head;` `        ``head = head.next;`   `        ``return` `head;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `i;` `        ``Node head = ``null``;` `        ``head = addToEmpty(head, ``6``);`   `        ``for` `(i = ``5``; i > ``0``; i--)` `            ``head = addBegin(head, i);` `        ``System.out.print(``"List Before: "``);` `        ``traverse(head);` `        ``System.out.println();`   `        ``System.out.print(``"List After: "``);` `        ``head = exchangeNodes(head);` `        ``traverse(head);` `    ``}` `}`   `// This code is contributed` `// by Arnab Kundu`

## Python3

 `# Python3 program to exchange first and` `# last node in circular linked list` `import` `math`     `class` `Node:` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.``next` `=` `None`     `def` `addToEmpty(head, data):`   `    ``# This function is only for empty list` `    ``if` `(head !``=` `None``):` `        ``return` `head`   `    ``# Creating a node dynamically.` `    ``temp ``=` `Node(data)`   `    ``# Assigning the data.` `    ``temp.data ``=` `data` `    ``head ``=` `temp`   `    ``# Creating the link.` `    ``head.``next` `=` `head` `    ``return` `head`     `def` `addBegin(head, data):`   `    ``if` `(head ``=``=` `None``):` `        ``return` `addToEmpty(head, data)`   `    ``temp ``=` `Node(data)` `    ``temp.data ``=` `data` `    ``temp.``next` `=` `head.``next` `    ``head.``next` `=` `temp`   `    ``return` `head`   `# function for traversing the list`     `def` `traverse(head):`   `    ``# If list is empty, return.` `    ``if` `(head ``=``=` `None``):`   `        ``print``(``"List is empty."``)` `        ``return`   `    ``# Pointing to first Node of the list.` `    ``p ``=` `head` `    ``print``(p.data, end``=``" "``)` `    ``p ``=` `p.``next`   `    ``# Traversing the list.` `    ``while``(p !``=` `head):`   `        ``print``(p.data, end``=``" "``)` `        ``p ``=` `p.``next`     `def` `exchangeNodes(head):`   `    ``# Cases Handled: Linked List either empty or containing single node.` `    ``if` `head ``=``=` `None` `or` `head.``next` `=``=` `head:` `        ``return` `head` `    ``# Cases Handled: Linked List containing only two nodes` `    ``elif` `head.``next``.``next` `=``=` `head:` `        ``head ``=` `head.``next` `        ``return` `head` `    ``# Cases Handled: Linked List containing multiple nodes` `    ``else``:` `        ``prev ``=` `None` `        ``curr ``=` `head` `        ``temp ``=` `head` `        ``# finding last and second last nodes in linkedlist list` `        ``while` `curr.``next` `!``=` `head:` `            ``prev ``=` `curr` `            ``curr ``=` `curr.``next`   `        ``# point the last node to second node of the list` `        ``curr.``next` `=` `temp.``next` `        ``# point the second last node to first node` `        ``prev.``next` `=` `temp` `        ``# point the end of node to start ( make linked list circular )` `        ``temp.``next` `=` `curr` `        ``# mark the starting of linked list` `        ``head ``=` `curr`   `        ``return` `head`     `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``head ``=` `None` `    ``head ``=` `addToEmpty(head, ``6``)` `    ``for` `x ``in` `range``(``5``, ``0``, ``-``1``):` `        ``head ``=` `addBegin(head, x)` `    ``print``(``"List Before: "``, end``=``"")` `    ``traverse(head)` `    ``print``()`   `    ``print``(``"List After: "``, end``=``"")` `    ``head ``=` `exchangeNodes(head)` `    ``traverse(head)`   `# This code is contributed by Srathore` `# Improved by Vinay Kumar (vinaykumar71)`

## C#

 `// C# program to exchange` `// first and last node in` `// circular linked list` `using` `System;`   `public` `class` `GFG {`   `    ``class` `Node {` `        ``public` `int` `data;` `        ``public` `Node next;` `    ``};`   `    ``static` `Node addToEmpty(Node head, ``int` `data)` `    ``{` `        ``// This function is only` `        ``// for empty list` `        ``if` `(head != ``null``)` `            ``return` `head;`   `        ``// Creating a node dynamically.` `        ``Node temp = ``new` `Node();`   `        ``// Assigning the data.` `        ``temp.data = data;` `        ``head = temp;`   `        ``// Creating the link.` `        ``head.next = head;`   `        ``return` `head;` `    ``}`   `    ``static` `Node addBegin(Node head, ``int` `data)` `    ``{` `        ``if` `(head == ``null``)` `            ``return` `addToEmpty(head, data);`   `        ``Node temp = ``new` `Node();`   `        ``temp.data = data;` `        ``temp.next = head.next;` `        ``head.next = temp;`   `        ``return` `head;` `    ``}`   `    ``// function for traversing the list` `    ``static` `void` `traverse(Node head)` `    ``{` `        ``Node p;`   `        ``// If list is empty, return.` `        ``if` `(head == ``null``) {` `            ``Console.Write(``"List is empty."``);` `            ``return``;` `        ``}`   `        ``// Pointing to first` `        ``// Node of the list.` `        ``p = head;`   `        ``// Traversing the list.` `        ``do` `{` `            ``Console.Write(p.data + ``" "``);` `            ``p = p.next;`   `        ``} ``while` `(p != head);` `    ``}`   `    ``// Function to exchange` `    ``// first and last node` `    ``static` `Node exchangeNodes(Node head)` `    ``{`   `        ``// If list is of length 2` `        ``if` `(head.next.next == head) {` `            ``head = head.next;` `            ``return` `head;` `        ``}` `        ``// Find pointer to previous` `        ``// of last node` `        ``Node p = head;` `        ``while` `(p.next.next != head)` `            ``p = p.next;`   `        ``// Exchange first and last` `        ``// nodes using head and p` `        ``p.next.next = head.next;` `        ``head.next = p.next;` `        ``p.next = head;` `        ``head = head.next;`   `        ``return` `head;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `i;` `        ``Node head = ``null``;` `        ``head = addToEmpty(head, 6);`   `        ``for` `(i = 5; i > 0; i--)` `            ``head = addBegin(head, i);` `        ``Console.Write(``"List Before: "``);` `        ``traverse(head);` `        ``Console.WriteLine();`   `        ``Console.Write(``"List After: "``);` `        ``head = exchangeNodes(head);` `        ``traverse(head);` `    ``}` `}`   `/* This code is contributed PrinciRaj1992 */`

## Javascript

 ``

Output

```List Before: 6 1 2 3 4 5
List After: 5 1 2 3 4 6 ```

Time Complexity: O(n), as we are using a loop to traverse n times. Where n is the number of nodes in the linked list.
Auxiliary Space: O(1), as we are not using any extra space.

Method 2: (By Swapping Values of First and Last nodes)

Algorithm:

1. Traverse the list and find the last node(tail).
2. Swap data of head and tail.

Below is the implementation of the algorithm:

## C++

 `// CPP program to exchange first and` `// last node in circular linked list` `#include ` `using` `namespace` `std;`   `struct` `Node {` `    ``int` `data;` `    ``struct` `Node* next;` `};`   `struct` `Node* addToEmpty(``struct` `Node* head, ``int` `data)` `{` `    ``// This function is only for empty list` `    ``if` `(head != NULL)` `        ``return` `head;`   `    ``// Creating a node dynamically.` `    ``struct` `Node* temp` `        ``= (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));`   `    ``// Assigning the data.` `    ``temp->data = data;` `    ``head = temp;`   `    ``// Creating the link.` `    ``head->next = head;`   `    ``return` `head;` `}`   `struct` `Node* addBegin(``struct` `Node* head, ``int` `data)` `{` `    ``if` `(head == NULL)` `        ``return` `addToEmpty(head, data);`   `    ``struct` `Node* temp` `        ``= (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));`   `    ``temp->data = data;` `    ``temp->next = head->next;` `    ``head->next = temp;`   `    ``return` `head;` `}`   `/* function for traversing the list */` `void` `traverse(``struct` `Node* head)` `{` `    ``struct` `Node* p;`   `    ``// If list is empty, return.` `    ``if` `(head == NULL) {` `        ``cout << ``"List is empty."` `<< endl;` `        ``return``;` `    ``}`   `    ``// Pointing to first Node of the list.` `    ``p = head;`   `    ``// Traversing the list.` `    ``do` `{` `        ``cout << p->data << ``" "``;` `        ``p = p->next;`   `    ``} ``while` `(p != head);` `}`   `/* Function to exchange first and last node*/` `struct` `Node* exchangeNodes(``struct` `Node* head)` `{` `    `  `    ``// If list is of length less than 2` `    ``if` `(head == NULL || head->next == NULL) {` `        ``return` `head;` `    ``}` `    ``Node* tail = head;` `  `  `    ``// Find pointer to the last node` `    ``while` `(tail->next != head) {` `        ``tail = tail->next;` `    ``}` `    ``/* Exchange first and last nodes using` `       ``head and p */` `  `  `    ``// temporary variable to store` `    ``// head data` `    ``int` `temp = tail->data; ` `    ``tail->data = head->data;` `    ``head->data = temp;` `    ``return` `head;` `}`   `// Driven Program` `int` `main()` `{` `    ``int` `i;` `    ``struct` `Node* head = NULL;` `    ``head = addToEmpty(head, 6);`   `    ``for` `(i = 5; i > 0; i--)` `        ``head = addBegin(head, i);` `    ``cout << ``"List Before: "``;` `    ``traverse(head);` `    ``cout << endl;`   `    ``cout << ``"List After: "``;` `    ``head = exchangeNodes(head);` `    ``traverse(head);`   `    ``return` `0;` `}`

## Java

 `// JAVA program to exchange first and` `// last node in circular linked list` `import` `java.util.*;` `import` `java.io.*;`   `public` `class` `GFG{`   `static` `class` `Node {` `    ``int` `data;` `    ``Node next;` `};`   `static` `Node addToEmpty(Node head, ``int` `data)` `{` `  `  `    ``// This function is only for empty list` `    ``if` `(head != ``null``)` `        ``return` `head;`   `    ``// Creating a node dynamically.` `    ``Node temp` `        ``= ``new` `Node();`   `    ``// Assigning the data.` `    ``temp.data = data;` `    ``head = temp;`   `    ``// Creating the link.` `    ``head.next = head;`   `    ``return` `head;` `}`   `static` `Node addBegin(Node head, ``int` `data)` `{` `    ``if` `(head == ``null``)` `        ``return` `addToEmpty(head, data);`   `    ``Node temp` `        ``= ``new` `Node();`   `    ``temp.data = data;` `    ``temp.next = head.next;` `    ``head.next = temp;`   `    ``return` `head;` `}`   `/* function for traversing the list */` `static` `void` `traverse(Node head)` `{` `    ``Node p;`   `    ``// If list is empty, return.` `    ``if` `(head == ``null``) {` `        ``System.out.print(``"List is empty."` `+``"\n"``);` `        ``return``;` `    ``}`   `    ``// Pointing to first Node of the list.` `    ``p = head;`   `    ``// Traversing the list.` `    ``do` `{` `        ``System.out.print(p.data+ ``" "``);` `        ``p = p.next;`   `    ``} ``while` `(p != head);` `}`   `/* Function to exchange first and last node*/` `static` `Node exchangeNodes(Node head)` `{` `    `  `    ``// If list is of length less than 2` `    ``if` `(head == ``null` `|| head.next == ``null``) {` `        ``return` `head;` `    ``}` `    ``Node tail = head;` `  `  `    ``// Find pointer to the last node` `    ``while` `(tail.next != head) {` `        ``tail = tail.next;` `    ``}` `    ``/* Exchange first and last nodes using` `       ``head and p */` `  `  `    ``// temporary variable to store` `    ``// head data` `    ``int` `temp = tail.data; ` `    ``tail.data = head.data;` `    ``head.data = temp;` `    ``return` `head;` `}`   `// Driven Program` `public` `static` `void` `main(String[] args)` `{` `    ``int` `i;` `    ``Node head = ``null``;` `    ``head = addToEmpty(head, ``6``);`   `    ``for` `(i = ``5``; i > ``0``; i--)` `        ``head = addBegin(head, i);` `    ``System.out.print(``"List Before: "``);` `    ``traverse(head);` `    ``System.out.println();`   `    ``System.out.print(``"List After: "``);` `    ``head = exchangeNodes(head);` `    ``traverse(head);`   `}` `}`   `// This code is contributed by umadevi9616 `

## Python3

 `# Python program to exchange first and` `# last node in circular linked list     class Node {` `class` `Node:` `    ``def` `__init__(``self``):` `        ``self``.data ``=` `0` `        ``self``.``next` `=` `None`   `def` `addToEmpty(head, data):`   `    ``# This function is only for empty list` `    ``if` `(head !``=` `None``):` `        ``return` `head`   `    ``# Creating a node dynamically.` `    ``temp ``=` `Node()`   `    ``# Assigning the data.` `    ``temp.data ``=` `data` `    ``head ``=` `temp`   `    ``# Creating the link.` `    ``head.``next` `=` `head`   `    ``return` `head`   `def` `addBegin(head, data):` `    ``if` `(head ``=``=` `None``):` `        ``return` `addToEmpty(head, data)`   `    ``temp ``=` `Node()`   `    ``temp.data ``=` `data` `    ``temp.``next` `=` `head.``next` `    ``head.``next` `=` `temp`   `    ``return` `head`   `# function for traversing the list` `def` `traverse(head):`   `    ``# If list is empty, return.` `    ``if` `(head ``=``=` `None``):` `        ``print``(``"List is empty."``)` `        ``return`   `    ``# Pointing to first Node of the list.` `    ``p ``=` `head`   `    ``# Traversing the list.` `    ``while` `(``True``):` `        ``print``(p.data, end``=``" "``)` `        ``p ``=` `p.``next` `        ``if``(p ``=``=` `head):` `            ``break`   `# Function to exchange first and last node` `def` `exchangeNodes(head):`   `    ``# If list is of length less than 2` `    ``if` `(head ``=``=` `None` `or` `head.``next` `=``=` `None``):` `        ``return` `head`   `    ``tail ``=` `head`   `    ``# Find pointer to the last node` `    ``while` `(tail.``next` `!``=` `head):` `        ``tail ``=` `tail.``next`   `    ``# Exchange first and last nodes using head and p`   `    ``# temporary variable to store` `    ``# head data` `    ``temp ``=` `tail.data` `    ``tail.data ``=` `head.data` `    ``head.data ``=` `temp` `    ``return` `head`   `# Driven Program` `head ``=` `None` `head ``=` `addToEmpty(head, ``6``)`   `for` `i ``in` `range``(``5``, ``0``, ``-``1``):` `    ``head ``=` `addBegin(head, i)`   `print``(``"List Before: "``)` `traverse(head)` `print``("")`   `print``(``"List After: "``)` `head ``=` `exchangeNodes(head)` `traverse(head)`   `# This code is contributed by Saurabh Jaiswal`

## C#

 `// C# program to exchange first and` `// last node in circular linked list` `using` `System;`   `public` `class` `GFG {`   `public`    `class` `Node {` `    ``public`    `int` `data;` `    ``public`    `Node next;` `    ``};`   `    ``static` `Node addToEmpty(Node head, ``int` `data) {`   `        ``// This function is only for empty list` `        ``if` `(head != ``null``)` `            ``return` `head;`   `        ``// Creating a node dynamically.` `        ``Node temp = ``new` `Node();`   `        ``// Assigning the data.` `        ``temp.data = data;` `        ``head = temp;`   `        ``// Creating the link.` `        ``head.next = head;`   `        ``return` `head;` `    ``}`   `    ``static` `Node addBegin(Node head, ``int` `data) {` `        ``if` `(head == ``null``)` `            ``return` `addToEmpty(head, data);`   `        ``Node temp = ``new` `Node();`   `        ``temp.data = data;` `        ``temp.next = head.next;` `        ``head.next = temp;`   `        ``return` `head;` `    ``}`   `    ``/* function for traversing the list */` `    ``static` `void` `traverse(Node head) {` `        ``Node p;`   `        ``// If list is empty, return.` `        ``if` `(head == ``null``) {` `            ``Console.Write(``"List is empty."` `+ ``"\n"``);` `            ``return``;` `        ``}`   `        ``// Pointing to first Node of the list.` `        ``p = head;`   `        ``// Traversing the list.` `        ``do` `{` `            ``Console.Write(p.data + ``" "``);` `            ``p = p.next;`   `        ``} ``while` `(p != head);` `    ``}`   `    ``/* Function to exchange first and last node */` `    ``static` `Node exchangeNodes(Node head) {`   `        ``// If list is of length less than 2` `        ``if` `(head == ``null` `|| head.next == ``null``) {` `            ``return` `head;` `        ``}` `        ``Node tail = head;`   `        ``// Find pointer to the last node` `        ``while` `(tail.next != head) {` `            ``tail = tail.next;` `        ``}` `        ``/*` `         ``* Exchange first and last nodes using head and p` `         ``*/`   `        ``// temporary variable to store` `        ``// head data` `        ``int` `temp = tail.data;` `        ``tail.data = head.data;` `        ``head.data = temp;` `        ``return` `head;` `    ``}`   `    ``// Driven Program` `    ``public` `static` `void` `Main(String[] args) {` `        ``int` `i;` `        ``Node head = ``null``;` `        ``head = addToEmpty(head, 6);`   `        ``for` `(i = 5; i > 0; i--)` `            ``head = addBegin(head, i);` `        ``Console.Write(``"List Before: "``);` `        ``traverse(head);` `        ``Console.WriteLine();`   `        ``Console.Write(``"List After: "``);` `        ``head = exchangeNodes(head);` `        ``traverse(head);` `    ``}` `}`   `// This code is contributed by umadevi9616`

## Javascript

 ``

Output

```List Before: 6 1 2 3 4 5
List After: 5 1 2 3 4 6 ```

Time Complexity: O(n), as we are using a loop to traverse n times. Where n is the number of nodes in the linked list.
Auxiliary Space: O(1), as we are not using any extra space.

This article is contributed by R_Raj. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up
Related Articles