Open In App

Move last element to front of a given Linked List | Set 2

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Share
Report issue
Report

Given a singly linked list and an integer K. The task is to append last K elements of the linked list to front. Examples:

Input: 1 -> 2 -> 3 -> 4 -> 5 -> 6, k = 3 
Output : 4 -> 5 -> 6 -> 1 -> 2 -> 3
 Input: 1 -> 2 -> 3 -> 4 -> 5 -> 6, k = 7 
Output : 6 -> 1 -> 2 -> 3 -> 4 -> 5

Prerequisites: Move last element to front of a given Linked List Approach:

  • Loop over (k % n) times, Where n is the number of elements of the linked list.
  • Each time, delete one node from the end of the linked list.
  • Simultaneously insert that deleted node at the beginning of the linked list.

Below is the implementation of the above approach :

C++




// CPP Program to move k last elements
// to front in a given linked list
#include<iostream>
using namespace std;
   
// A linked list node
class Node
{
    public:
       
    int data;
    Node* next;
    Node(int d) {
        data = d;
        next = NULL;
    }
};
   
// Function to add a new node at the
// end/tail of Linked List
void insertAtTail(Node*& head, Node*& tail, int d ) {
    Node* newnode = new Node(d);
    if(tail == NULL) {
        tail = head = newnode;
        return;
    }
   
    tail->next = newnode;
    tail = newnode;
}
   
// Function to add a node at the
// beginning of Linked List
void insertAtHead(Node*& head, Node*& tail,
                           Node*& deletedNode)
{
    if(head == NULL) {
        head = tail = deletedNode;
        return;
    }
    deletedNode->next = head;
    head = deletedNode;
    return;
}
   
// Function to add a node at the beginning of Linked List
Node* deleteAtTail(Node*& head, Node*& tail) {
    Node* deleted = tail;
    Node* temp = head;
   
    while(temp->next->next != NULL) {
        temp = temp->next;
    }
   
    temp->next = NULL;
    tail = temp;
    return deleted;
}
   
// k can be more than n, so this function takes the modulus
// of k with n and delete nodes from end k
// times and simultaneously insert it in front
void appendAtFront(Node*& head, Node*& tail, int n, int k)
{
    k = k % n;
    while(k != 0) {
        Node* deleted = deleteAtTail(head, tail);
        insertAtHead(head, tail, deleted);
        k--;
    }
}
   
// Function to print nodes in a given linked list
void printLinkedList(Node* head) {
    while(head != NULL) {
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
}
   
// Driver Code
int main()
{
    // Pointer to the start of the linked list
    Node* head = NULL;
       
    // Pointer to the end of the linked list
    Node* tail = NULL;
       
    // Number of elements in the linked list
    int n = 6;
       
    // Building linked list
    insertAtTail(head, tail, 1);
    insertAtTail(head, tail, 2);
    insertAtTail(head, tail, 3);
    insertAtTail(head, tail, 4);
    insertAtTail(head, tail, 5);
    insertAtTail(head, tail, 6);
       
       
    // Printing linked list before
    // appending the linked list
    cout << "Linked List before appending: ";
    printLinkedList(head);
       
    // Number of elements to be appended
    int k = 7;
       
    // Function call
    appendAtFront(head, tail, n, k);
       
    // Printing linked list after appending the list
    cout << "Linked List after appending "<<k<<" elements: ";
    printLinkedList(head);
}


Java




// JAVA Program to move k last elements
// to front in a given linked list
 
import java.io.*;
 
class Node {
    int data;
    Node next;
    Node(int data)
    {
        this.data = data;
        this.next = null;
    }
}
 
class LinkedList {
    Node head;
    Node tail;
 
    // Function to add a new node at the end/tail of Linked
    // List
    public void insertAtTail(int data)
    {
        Node newnode = new Node(data);
        if (tail == null) {
            tail = head = newnode;
            return;
        }
        tail.next = newnode;
        tail = newnode;
    }
 
    // Function to add a node at the beginning of Linked
    // List
    public void insertAtHead(Node deletedNode)
    {
        if (head == null) {
            head = tail = deletedNode;
            return;
        }
        deletedNode.next = head;
        head = deletedNode;
    }
 
    // Function to delete a node at the end of Linked List
    public Node deleteAtTail()
    {
        Node deleted = tail;
        Node temp = head;
        while (temp.next.next != null) {
            temp = temp.next;
        }
        temp.next = null;
        tail = temp;
        return deleted;
    }
 
    // k can be more than n, so this function takes the
    // modulus of k with n and delete nodes from end k times
    // and simultaneously insert it in front
    public void appendAtFront(int n, int k)
    {
        k = k % n;
        while (k != 0) {
            Node deleted = deleteAtTail();
            insertAtHead(deleted);
            k--;
        }
    }
 
    // Function to print nodes in a given linked list
    public void printLinkedList()
    {
        Node temp = head;
        while (temp != null) {
            System.out.print(temp.data + " ");
            temp = temp.next;
        }
        System.out.println();
    }
}
 
class GFG {
    public static void main(String[] args)
    {
        LinkedList ll = new LinkedList();
        ll.insertAtTail(1);
        ll.insertAtTail(2);
        ll.insertAtTail(3);
        ll.insertAtTail(4);
        ll.insertAtTail(5);
        ll.insertAtTail(6);
 
        System.out.print("Linked List before appending: ");
        ll.printLinkedList();
 
        int k = 7;
 
        ll.appendAtFront(6, k);
 
        System.out.print("Linked List after appending " + k
                         + " elements: ");
        ll.printLinkedList();
    }
}
 
// This code is contributed by lokesh.


Python3




class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
 
 
class LinkedList:
    def __init__(self):
        self.head = None
        self.tail = None
 
    # Function to add a new node at the end/tail of Linked List
    def insert_at_tail(self, data):
        new_node = Node(data)
        if self.tail is None:
            self.tail = self.head = new_node
            return
        self.tail.next = new_node
        self.tail = new_node
 
    # Function to add a node at the beginning of Linked List
    def insert_at_head(self, deleted_node):
        if self.head is None:
            self.head = self.tail = deleted_node
            return
        deleted_node.next = self.head
        self.head = deleted_node
 
    # Function to delete a node at the end of Linked List
    def delete_at_tail(self):
        deleted = self.tail
        temp = self.head
        while temp.next.next is not None:
            temp = temp.next
        temp.next = None
        self.tail = temp
        return deleted
 
    # k can be more than n, so this function takes the modulus
    # of k with n and deletes nodes from the end k times while
    # simultaneously inserting them at the front
    def append_at_front(self, n, k):
        k = k % n
        while k != 0:
            deleted = self.delete_at_tail()
            self.insert_at_head(deleted)
            k -= 1
 
    # Function to print nodes in a given linked list
    def print_linked_list(self):
        temp = self.head
        while temp is not None:
            print(temp.data, end=" ")
            temp = temp.next
        print()
 
 
# Driver Code
if __name__ == "__main__":
    ll = LinkedList()
    ll.insert_at_tail(1)
    ll.insert_at_tail(2)
    ll.insert_at_tail(3)
    ll.insert_at_tail(4)
    ll.insert_at_tail(5)
    ll.insert_at_tail(6)
 
    print("Linked List before appending: ", end="")
    ll.print_linked_list()
 
    k = 7
 
    ll.append_at_front(6, k)
 
    print("Linked List after appending", k, "elements: ", end="")
    ll.print_linked_list()


C#




using System;
 
class Node {
    public int data;
    public Node next;
 
    public Node(int data)
    {
        this.data = data;
        this.next = null;
    }
}
 
class LinkedList {
    public Node head;
    public Node tail;
 
    // Function to add a new node at the end/tail of Linked
    // List
    public void InsertAtTail(int data)
    {
        Node newNode = new Node(data);
        if (tail == null) {
            tail = head = newNode;
            return;
        }
        tail.next = newNode;
        tail = newNode;
    }
 
    // Function to add a node at the beginning of Linked
    // List
    public void InsertAtHead(Node deletedNode)
    {
        if (head == null) {
            head = tail = deletedNode;
            return;
        }
        deletedNode.next = head;
        head = deletedNode;
    }
 
    // Function to delete a node at the end of Linked List
    public Node DeleteAtTail()
    {
        Node deleted = tail;
        Node temp = head;
        while (temp.next.next != null) {
            temp = temp.next;
        }
        temp.next = null;
        tail = temp;
        return deleted;
    }
 
    // k can be more than n, so this function takes the
    // modulus of k with n and deletes nodes from the end k
    // times while simultaneously inserting them at the
    // front
    public void AppendAtFront(int n, int k)
    {
        k = k % n;
        while (k != 0) {
            Node deleted = DeleteAtTail();
            InsertAtHead(deleted);
            k--;
        }
    }
 
    // Function to print nodes in a given linked list
    public void PrintLinkedList()
    {
        Node temp = head;
        while (temp != null) {
            Console.Write(temp.data + " ");
            temp = temp.next;
        }
        Console.WriteLine();
    }
}
 
class Program {
    public static void Main()
    {
        LinkedList ll = new LinkedList();
        ll.InsertAtTail(1);
        ll.InsertAtTail(2);
        ll.InsertAtTail(3);
        ll.InsertAtTail(4);
        ll.InsertAtTail(5);
        ll.InsertAtTail(6);
 
        Console.Write("Linked List before appending: ");
        ll.PrintLinkedList();
 
        int k = 7;
 
        ll.AppendAtFront(6, k);
 
        Console.Write("Linked List after appending " + k
                      + " elements: ");
        ll.PrintLinkedList();
    }
}


Javascript




class Node {
    constructor(data) {
        this.data = data;
        this.next = null;
    }
}
 
class LinkedList {
    constructor() {
        this.head = null;
        this.tail = null;
    }
 
    // Function to add a new node at the end/tail of Linked List
    insertAtTail(data) {
        const newNode = new Node(data);
        if (this.tail === null) {
            this.tail = this.head = newNode;
            return;
        }
        this.tail.next = newNode;
        this.tail = newNode;
    }
 
    // Function to add a node at the beginning of Linked List
    insertAtHead(deletedNode) {
        if (this.head === null) {
            this.head = this.tail = deletedNode;
            return;
        }
        deletedNode.next = this.head;
        this.head = deletedNode;
    }
 
    // Function to delete a node at the end of Linked List
    deleteAtTail() {
        if (this.head === null) {
            return null; // Empty list, nothing to delete
        }
 
        const deleted = this.tail;
        let temp = this.head;
 
        // If there is only one element in the list
        if (temp === this.tail) {
            this.head = this.tail = null;
            return deleted;
        }
 
        while (temp.next.next !== null) {
            temp = temp.next;
        }
 
        temp.next = null;
        this.tail = temp;
        return deleted;
    }
 
    // k can be more than n, so this function takes the
    // modulus of k with n and delete nodes from end k times
    // and simultaneously insert it in front
    appendAtFront(n, k) {
        k = k % n;
        while (k !== 0) {
            const deleted = this.deleteAtTail();
            this.insertAtHead(deleted);
            k--;
        }
    }
 
    // Function to print nodes in a given linked list
    printLinkedList() {
        let temp = this.head;
        while (temp !== null) {
            process.stdout.write(temp.data + " ");
            temp = temp.next;
        }
        console.log();
    }
}
 
// Driver Code
const ll = new LinkedList();
ll.insertAtTail(1);
ll.insertAtTail(2);
ll.insertAtTail(3);
ll.insertAtTail(4);
ll.insertAtTail(5);
ll.insertAtTail(6);
 
process.stdout.write("Linked List before appending: ");
ll.printLinkedList();
 
const k = 7;
 
ll.appendAtFront(6, k);
 
process.stdout.write("Linked List after appending " + k + " elements: ");
ll.printLinkedList();


Output

Linked List before appending: 1 2 3 4 5 6 
Linked List after appending 7 elements: 6 1 2 3 4 5 





Time Complexity: O(N)
Auxiliary Space: O(1)



Last Updated : 18 Dec, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads