Skip to content
Related Articles

Related Articles

Improve Article

Exchange first and last nodes in Circular Linked List

  • Difficulty Level : Easy
  • Last Updated : 17 May, 2021

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.  

https://media.geeksforgeeks.org/wp-content/uploads/Capturehgh.png

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 previous of 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 <bits/stdc++.h>
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
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




<script>
// javascript program to exchange
// first and last node in
// circular linked list    
  
class Node {
    constructor() {
        this.data = 0;
        this.next = null;
    }
}
    function addToEmpty(head , data) {
        // This function is only
        // for empty list
        if (head != null)
            return head;
  
        // Creating a node dynamically.
        var temp = new Node();
  
        // Assigning the data.
        temp.data = data;
        head = temp;
  
        // Creating the link.
        head.next = head;
  
        return head;
    }
  
    function addBegin(head , data) {
        if (head == null)
            return addToEmpty(head, data);
  
        var temp = new Node();
  
        temp.data = data;
        temp.next = head.next;
        head.next = temp;
  
        return head;
    }
  
    // function for traversing the list
    function traverse(head) {
    var p;
  
        // If list is empty, return.
        if (head == null) {
            document.write("List is empty.");
            return;
        }
  
        // Pointing to first
        // Node of the list.
        p = head;
  
        // Traversing the list.
        do {
            document.write(p.data + " ");
            p = p.next;
  
        } while (p != head);
    }
  
    // Function to exchange
    // first and last node
    function exchangeNodes(head) {
  
        // If list is of length 2
        if (head.next.next == head) {
            head = head.next;
            return head;
        }
        // Find pointer to previous
        // of last node
        var 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
      
        var i;
        var head = null;
        head = addToEmpty(head, 6);
  
        for (i = 5; i > 0; i--)
            head = addBegin(head, i);
        document.write("List Before: ");
        traverse(head);
        document.write("<br/>");
  
        document.write("List After: ");
        head = exchangeNodes(head);
        traverse(head);
  
// This code contributed by umadevi9616 
</script>
Output



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

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 <bits/stdc++.h>
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;
}
Output
List Before: 6 1 2 3 4 5 
List After: 5 1 2 3 4 6 

Time Complexity:O(N)

 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 contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :