Skip to content
Related Articles

Related Articles

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

View Discussion
Improve Article
Save Article
Like Article
  • Last Updated : 29 Jun, 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 <bits/stdc++.h>
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 minumum 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.

Javascript




<script>
 
// JavaScript code for the above approach
 
// Node Class
class Node{
    constructor(d){
        this.data = d
        this.next = null
    }
}
             
class LinkedList{
    constructor(){
        this.head = null
    }
 
    // Inserting new node
    // at the beginning of the linked list
    push(new_data){
 
        // Create a new node with the given data.
        let new_node = new Node(new_data)
 
        // Make the new node point to the head.
        new_node.next = this.head
 
        // Make the new node as the head node.
        this.head = new_node
    }
 
    // function to find the
    // minimum possible first node
    FirstNode(K){
        if(K == 0)
            return this.head.data
        else if (K == 1){
            if (this.head.next == null)
                return -1
            return  this.head.next.data
        }
        else if (this.head.next == null){
            if(K%2==1)
                return -1
            return this.head.data
        }
        // Initialize answer with Ininity
        let ans = 1000000000000000000
        let i = 0
 
        // Traverse 1st K-1 nodes and find out
        // minimum node value
        while(this.head != null && i < (K-1)){
            if(this.head.data < ans)
                ans = this.head.data
            this.head = this.head.next
            i+=1
        }
        // Check whether Linked list have (K+1)th
        // Node or not
        if(this.head != null && this.head.next != null)
 
            // Update ans with minimum of 1st K-1
            // nodes and the (K+1)th Node.
            ans = Math.min(ans, this.head.next.data)
         
        return ans
    }
}
 
 
// Driver Code
 
let K = 4
 
// Create an empty singly linked list
let llist = new LinkedList()
 
llist.push(3)
llist.push(5)
llist.push(2)
llist.push(4)
llist.push(1)
 
// Call FirstNode function
document.write(llist.FirstNode(K),"</br>")
 
// This code is contributed by shinjanpatra
 
</script>

Output

1

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


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!