# Minimize first node of Linked List by deleting first or adding one deleted node at start

• Last Updated : 22 Aug, 2022

Given a singly linked list, and an integer K, the task is to make the first node value as minimum as possible in K operations where in each operation:

• Select the first node of the linked list and remove it.
• Add a previously removed node at the start of the linked list.

Examples:

Input: list: 1->4->2->5->3, K=4
Output:1
Explanation:
1st operation-> Remove 1st Node, After performing operation linked list become 4->2->5->3
2nd operation-> Remove 1st Node, After performing operation linked list become 2->5->3
3rd operation-> Remove 1st Node, After performing operation linked list become 5->3
4th operation-> Add previously removed Node (i.e. 1), After performing operation linked list become 1->5->3

Input: Linked List: 5, K = 1
Output: -1
Explanation: Only possible operation is to delete the first node.
If that operation is performed then the list will be empty.

Approach: The problem can be solved by using below observation:

In first K-1 operations, the K-1 value of the starting can be removed. So currently at Kth node. Now in the last operation there are two possible choice:

• Either remove the current starting node (optimal if the value of the (K+1)th node is smaller than the smallest amongst first K-1 already removed elements)
• Add the smallest from the already removed K-1 elements (optimal when the (K+1)th node has higher value than the smallest one)

Follow the below steps to solve the problem:

• If K = 0, then return First Node Value.
• If K = 1, then return Second Node value(if any) else return -1 (because after K operations the list does not exist).
• If the size of the linked list is one then in every odd operation (i.e. 1, 3, 5, . . . ), return -1, else return the first node value (for the same reason as above).
• If K > 2, then:
• Traverse first K-1 nodes and find out the minimum value.
• Compare that minimum value with the (K+1)th node value.
• If (K+1)th value is less than the previous minimum value, update it with (K+1)th Node value.
• Return the minimum value.

Below is the implementation of the above approach:

## C++

 `// C++ program for above approach`   `#include ` `using` `namespace` `std;`   `// Structure of node of singly linked list` `struct` `Node {` `    ``int` `data;` `    ``Node* next;` `    ``Node(``int` `x)` `    ``{` `        ``data = x;` `        ``next = NULL;` `    ``}` `};`   `// Inserting new node` `// at the  beginning of the linked list` `void` `push(``struct` `Node** head_ref,` `          ``int` `new_data)` `{` `    ``// Create a new node with the given data.` `    ``struct` `Node* new_node = ``new` `Node(new_data);`   `    ``// Make the new node point to the head.` `    ``new_node->next = (*head_ref);`   `    ``// Make the new node as the head node.` `    ``(*head_ref) = new_node;` `}`   `// Function to find the` `// minimum possible first node` `int` `FirstNode(Node* head, ``int` `K)` `{` `    ``if` `(K == 0) {` `        ``return` `head->data;` `    ``}` `    ``if` `(K == 1) {` `        ``return` `(head->next == NULL) ? -1 : head->next->data;` `    ``}` `    ``if` `(head->next == NULL) {` `        ``return` `(K % 2) ? -1 : head->data;` `    ``}` `    ``int` `ans = INT_MAX;` `    ``int` `i = 0;`   `    ``// Traverse 1st K-1 Nodes and find out` `    ``// minimum node` `    ``// value` `    ``while` `(head != NULL && i < K - 1) {` `        ``if` `(head->data < ans)` `            ``ans = head->data;` `        ``head = head->next;` `        ``i++;` `    ``}`   `    ``// Check whether Linked list have (K+1)th` `    ``// Node or not` `    ``if` `(head && head->next != NULL) {`   `        ``// Update ans with minimum of 1st K-1` `        ``// nodes and the (K+1)th Node.` `        ``ans = min(ans, head->next->data);` `    ``}` `    ``return` `ans;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `K = 4;`   `    ``// Create an empty singly linked list` `    ``struct` `Node* head = NULL;`   `    ``// Insert values in Linked List` `    ``push(&head, 3);` `    ``push(&head, 5);` `    ``push(&head, 2);` `    ``push(&head, 4);` `    ``push(&head, 1);`   `    ``// Call FirstNode function` `    ``cout << FirstNode(head, K);` `    ``return` `0;` `}`

## Java

 `// Java Program for the above approach`   `import` `java.io.*;`   `class` `GFG {`   `      ``// structure of a node.` `    ``class` `Node {` `        ``int` `data;` `        ``Node next;` `        ``Node(``int` `data)` `        ``{` `            ``this``.data = data;` `            ``this``.next = ``null``;` `        ``}` `    ``}` `    `  `      ``// Creating a head node.` `      ``Node head;` `      `  `      ``// Inserting nodes into linked list.` `    ``public` `void` `push(``int` `data)` `    ``{` `        ``Node new_node = ``new` `Node(data);` `        ``new_node.next = head;` `        ``head = new_node;` `    ``}`   `      ``// Method to find the minimum possible time.` `    ``public` `int` `firstNode(``int` `k)` `    ``{` `        ``int` `ans = Integer.MAX_VALUE;` `        ``int` `i = ``0``;` `        ``if` `(k == ``0``) {` `            ``return` `head.data;` `        ``}` `        ``if` `(k == ``1``) {` `            ``return` `(head.next == ``null``) ? -``1` `                                       ``: head.next.data;` `        ``}` `        ``if` `(head.next == ``null``) {` `            ``if` `(k % ``2` `== ``1``) {` `                ``return` `-``1``;` `            ``}` `            ``return` `head.data;` `        ``}`   `        ``while` `(head != ``null` `&& (i < k - ``1``)) {` `            ``if` `(head.data < ans) {` `                ``ans = head.data;` `            ``}` `            ``head = head.next;` `            ``i++;` `        ``}` `        ``if` `(head != ``null` `&& head.next != ``null``) {` `            ``ans = Math.min(ans, head.next.data);` `        ``}` `        ``return` `ans;` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``GFG list = ``new` `GFG();`   `          ``// Insert values in linked list.` `        ``list.push(``3``);` `        ``list.push(``5``);` `        ``list.push(``2``);` `        ``list.push(``4``);` `        ``list.push(``1``);`   `        ``int` `k = ``4``;` `        ``System.out.print(list.firstNode(k));` `    ``}` `}`   `// This code is contributed by lokesh (lokeshmvs21).`

## Python3

 `# Python code for the above approach`   `# Node Class` `class` `Node:` `    ``def` `__init__(``self``, d):` `        ``self``.data ``=` `d` `        ``self``.``next` `=` `None` `            `    `class` `LinkedList:` `    ``def` `__init__(``self``):` `        ``self``.head ``=` `None`   `    ``## Inserting new node` `    ``## at the beginning of the linked list` `    ``def` `push(``self``, new_data):`   `        ``## Create a new node with the given data.` `        ``new_node ``=` `Node(new_data)`   `        ``## Make the new node point to the head.` `        ``new_node.``next` `=` `self``.head`   `        ``## Make the new node as the head node.` `        ``self``.head ``=` `new_node`   `    ``## Function to find the` `    ``## minimum possible first node` `    ``def` `FirstNode(``self``, K):` `        ``if``(K ``=``=` `0``):` `            ``return` `self``.head.data` `        ``elif` `(K ``=``=` `1``):` `            ``if` `(``self``.head.``next` `=``=` `None``):` `                ``return` `-``1` `            ``return`  `self``.head.``next``.data` `        ``elif` `(``self``.head.``next` `=``=` `None``):` `            ``if``(K``%``2``=``=``1``):` `                ``return` `-``1` `            ``return` `self``.head.data` `        ``## Initialize answer with Ininity` `        ``ans ``=` `1000000000000000000` `        ``i ``=` `0`   `        ``## Traverse 1st K-1 nodes and find out` `        ``## minimum node value` `        ``while``(``self``.head !``=` `None` `and` `i < (K``-``1``)):` `            ``if``(``self``.head.data < ans):` `                ``ans ``=` `self``.head.data` `            ``self``.head ``=` `self``.head.``next` `            ``i``+``=``1` `        `  `        ``## Check whether Linked list have (K+1)th` `        ``## Node or not` `        ``if``(``self``.head !``=` `None` `and` `self``.head.``next` `!``=` `None``):`   `            ``## Update ans with minimum of 1st K-1` `            ``## nodes and the (K+1)th Node.` `            ``ans ``=` `min``(ans, ``self``.head.``next``.data)` `        `  `        ``return` `ans`     `# Driver Code` `if` `__name__``=``=``'__main__'``:`   `    ``K ``=` `4`   `    ``## Create an empty singly linked list` `    ``llist ``=` `LinkedList()`   `    ``llist.push(``3``)` `    ``llist.push(``5``)` `    ``llist.push(``2``)` `    ``llist.push(``4``)` `    ``llist.push(``1``)`   `    ``## Call FirstNode function` `    ``print``(llist.FirstNode(K))`   `    ``# This code is contributed by subhamgoyal2014.`

## C#

 `// C# program for the above approach` `using` `System;`   `public` `class` `GFG {`   `    ``// Structure of a node.` `    ``class` `Node {` `        ``public` `int` `data;` `        ``public` `Node next;` `        ``public` `Node(``int` `data)` `        ``{` `            ``this``.data = data;` `            ``this``.next = ``null``;` `        ``}` `    ``}`   `    ``// Creating a head node.` `    ``Node head;`   `    ``// Inserting nodes into linked list.` `    ``public` `void` `push(``int` `data)` `    ``{` `        ``Node new_node = ``new` `Node(data);` `        ``new_node.next = head;` `        ``head = new_node;` `    ``}`   `    ``// Function to find the minimum possible time.` `    ``public` `int` `firstNode(``int` `k)` `    ``{` `        ``int` `ans = Int32.MaxValue;` `        ``int` `i = 0;` `        ``if` `(k == 0) {` `            ``return` `head.data;` `        ``}` `        ``if` `(k == 1) {` `            ``return` `(head.next == ``null``) ? -1` `                                       ``: head.next.data;` `        ``}` `        ``if` `(head.next == ``null``) {` `            ``if` `(k % 2 == 1) {` `                ``return` `-1;` `            ``}` `            ``return` `head.data;` `        ``}` `        ``while` `(head != ``null` `&& (i < k - 1)) {` `            ``if` `(head.data < ans) {` `                ``ans = head.data;` `            ``}` `            ``head = head.next;` `            ``i++;` `        ``}` `        ``if` `(head != ``null` `&& head.next != ``null``) {` `            ``ans = Math.Min(ans, head.next.data);` `        ``}` `        ``return` `ans;` `    ``}`   `    ``static` `public` `void` `Main()` `    ``{`   `        ``// Code` `        ``GFG list = ``new` `GFG();`   `        ``// Insert values in linked list.` `        ``list.push(3);` `        ``list.push(5);` `        ``list.push(2);` `        ``list.push(4);` `        ``list.push(1);`   `        ``int` `k = 4;` `        ``Console.WriteLine(list.firstNode(k));` `    ``}` `}`   `// This code is contributed by lokesh (lokeshmvs21).`

## Javascript

 ``

Output

`1`

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

My Personal Notes arrow_drop_up
Related Articles