Open In App

Sorted insert for circular linked list

Last Updated : 17 May, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

Given a sorted circular linked list, your task is to insert a new node in this circular list so that it remains a sorted circular linked list.

Examples:

Input: head = 1 →2 →4, data = 2
Output: 1 →2 →2 →4
Explanation: We can add 2 after the second node.
Input: head = 1 →4 →7 →9, data = 5
Output: 1 →4 →5 →7 →9
Explanation: We can add 5 after the second node.

Approach:

To inset the newNode in the circular Linked List follow below :

  • Allocate memory for the newNode with the given data.
  • If the list is empty, update the head to point to the newNode.
  • If data is less than head, create a new node, link it after the last node, and return it as the new head.
  • Else, traverse to find the position where input data is smaller or equal to head's data and insert newNode by adjusting the necessary pointers.
  • Otherwise, insert the newNode in its appropriate position which is data <= head  →data:

Illustration:

C++ 
// C++ program for sorted insert
// in circular linked list

#include <iostream>
using namespace std;

class Node { 
public:
    int data; 
    Node *next; 
    Node(int x) { 
        data = x; 
        next = nullptr; 
    } 
}; 

// Function to insert a new node in the 
// list in a sorted way
Node* sortedInsert(Node* head, int data) {
  
  	// Create the new node with the given data
    Node* newNode = new Node(data); 
    
    // If linked list is empty
    if (head == nullptr) {
        newNode->next = newNode; 
        head = newNode;
        return head;
    }
    
    Node* curr = head;
    Node* nextToCurr = head->next;
    
    // Insert at the beginning if data is less 
  	// than or equal to head's data
    if (data <= head->data) {
        Node* lastNode = head;
        while (lastNode->next != head) {
          	
          	// Find the last node
            lastNode = lastNode->next; 
        }
      
      	// Set new node's next to head
        newNode->next = head; 
        
      	// Update last node's next to new node
      	lastNode->next = newNode; 
        
      	// Update head to new node
      	head = newNode; 
        return head;
    }
    
    // Insert in the middle of the list
    while (curr->next != head) {
        if (curr->data < data && nextToCurr->data >= data) {
          	
          	// Set new node's next to current's next
            newNode->next = curr->next; 
            curr->next = newNode;
            return head;
        } else {
          
          	// Move to the next node
            curr = curr->next; 
            nextToCurr = nextToCurr->next; 
        }
    }
    
    // Insert at the end of the list
    newNode->next = head; 
    curr->next = newNode; 
    return head;
}

int main()  {
  
    // Create circular linked list: 3->7->9->11->3
    Node *head = new Node(3);
    head->next = new Node(7);
    head->next->next = new Node(9);
    head->next->next->next = new Node(11);
    head->next->next->next->next = head; 
  	
    head = sortedInsert(head, 8); 
    Node *curr = head;
    
    if (head != nullptr) { 
        do { 
            cout << curr->data << " "; 
            curr = curr->next; 
        } while (curr != head); 
    } 
    cout << endl; 
    return 0; 
}
C 
// C program for sorted insert in 
// circular linked list

#include <stdlib.h>

struct Node {
    int data;
    struct Node *next;
};

struct Node* createNode(int data) {
    struct Node* newNode = 
      (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// Function to insert a new node 
// in the list in a sorted way
struct Node* sortedInsert(struct Node* head, int data) {
  
    // Create the new node with the given data
    struct Node* newNode = createNode(data);
    
    // If linked list is empty
    if (head == NULL) {
        newNode->next = newNode;
        head = newNode;
        return head;
    }
    
    struct Node* curr = head;
    struct Node* nextToCurr = head->next;
    
    // Insert at the beginning if data is 
  	// less than or equal to head's data
    if (data <= head->data) {
        struct Node* lastNode = head;
        while (lastNode->next != head) {
            // Find the last node
            lastNode = lastNode->next;
        }
        
        // Set new node's next to head
        newNode->next = head;
        
      	// Update last node's next to new node
        lastNode->next = newNode;
        
      	// Update head to new node
        head = newNode;
        return head;
    }
    
    // Insert in the middle of the list
    while (curr->next != head) {
        if (curr->data < data && nextToCurr->data >= data) {
          
            // Set new node's next to current's next
            newNode->next = curr->next;
            curr->next = newNode;
            return head;
        } else {
          
            // Move to the next node
            curr = curr->next;
            nextToCurr = nextToCurr->next;
        }
    }
    
    // Insert at the end of the list
    newNode->next = head;
    curr->next = newNode;
    return head;
}


int main() {
  
    // Create circular linked list: 3->7->9->11->3
    struct Node *head = createNode(3);
    head->next = createNode(7);
    head->next->next = createNode(9);
    head->next->next->next = createNode(11);
    head->next->next->next->next = head;
  
    head = sortedInsert(head, 8);
    struct Node *curr = head;
    
    if (head != NULL) {
        do {
            printf("%d ", curr->data);
            curr = curr->next;
        } while (curr != head);
    }   
    printf("\n");
}
Java 
// Java program for sorted insert
// in circular linked list

class Node {
    int data;
    Node next;

    Node(int x) {
        data = x;
        next = null;
    }
}

public class GfG {
    
    // Function to insert a new node in the 
  	// list in a sorted way
    static Node sortedInsert(Node head, int data) {
        
        // Create the new node with the given data
        Node newNode = new Node(data);
        
        // If linked list is empty
        if (head == null) {
            newNode.next = newNode;
            return newNode;
        }

        Node curr = head;
        Node nextToCurr = head.next;

        // Insert at the beginning if data is 
      	// less than or equal to head's data
        if (data <= head.data) {
            Node lastNode = head;
            while (lastNode.next != head) {
                
                // Find the last node
                lastNode = lastNode.next;
            }

            // Set new node's next to head
            newNode.next = head;

            // Update last node's next to new node
            lastNode.next = newNode;

            // Update head to new node
            return newNode;
        }

        // Insert in the middle of the list
        while (curr.next != head) {
            if (curr.data < data && nextToCurr.data >= data) {
                
                // Set new node's next to current's next
                newNode.next = curr.next;
                curr.next = newNode;
                return head;
            } else {
                
                // Move to the next node
                curr = curr.next;
                nextToCurr = nextToCurr.next;
            }
        }

        // Insert at the end of the list
        newNode.next = head;
        curr.next = newNode;
        return head;
    }

    public static void main(String[] args) {
      
        // Create circular linked list: 3->7->9->11->3
        Node head = new Node(3);
        head.next = new Node(7);
        head.next.next = new Node(9);
        head.next.next.next = new Node(11);
        head.next.next.next.next = head;

        head = sortedInsert(head, 8);
        Node curr = head;

        if (head != null) {
            do {
                System.out.print(curr.data + " ");
                curr = curr.next;
            } while (curr != head);
        }
        System.out.println();
    }
}
Python 
# python program for sorted insert in 
# circular linked list
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

# Function to insert a new node in
# the list in a sorted way
def sortedInsert(head, data):
    new_node = Node(data)

    # If linked list is empty
    if head is None:
        new_node.next = new_node
        return new_node

    curr = head
    next_to_curr = head.next

    # Insert at the beginning if data is less
    # than or equal to head's data
    if data <= head.data:
        last_node = head
        while last_node.next != head:
            last_node = last_node.next
        new_node.next = head
        last_node.next = new_node
        return new_node

    # Insert in the middle of the list
    while curr.next != head:
        if curr.data < data and next_to_curr.data >= data:
            new_node.next = curr.next
            curr.next = new_node
            return head
        else:
            curr = curr.next
            next_to_curr = next_to_curr.next

    # Insert at the end of the list
    new_node.next = head
    curr.next = new_node
    return head


if __name__ == "__main__":
  
    # Create circular linked list: 3->7->9->11->3
    head = Node(3)
    head.next = Node(7)
    head.next.next = Node(9)
    head.next.next.next = Node(11)
    head.next.next.next.next = head

    head = sortedInsert(head, 8)
    curr = head
    if head is not None:
        while True:
            print(curr.data, end=" ")
            curr = curr.next
            if curr == head:
                break
    print()
C# 
// C# program for sorted insert
// in circular linked list

using System;

class Node {
    public int data;
    public Node next;

    public Node(int x) {
        data = x;
        next = null;
    }
}

class GfG {

    // Function to insert a new node in the list in a sorted
    // way
    static Node SortedInsert(Node head, int data) {

        // Create the new node with the given data
        Node newNode = new Node(data);

        // If linked list is empty
        if (head == null) {
            newNode.next = newNode;
            return newNode;
        }

        Node curr = head;
        Node nextToCurr = head.next;

        // Insert at the beginning if data is
        // less than or equal to head's data
        if (data <= head.data) {
            Node lastNode = head;
            while (lastNode.next != head) {

                // Find the last node
                lastNode = lastNode.next;
            }

            // Set new node's next to head
            newNode.next = head;

            // Update last node's next to new node
            lastNode.next = newNode;

            // Update head to new node
            return newNode;
        }

        // Insert in the middle of the list
        while (curr.next != head) {
            if (curr.data < data
                && nextToCurr.data >= data) {

                // Set new node's next to current's next
                newNode.next = curr.next;
                curr.next = newNode;
                return head;
            }
            else {

                // Move to the next node
                curr = curr.next;
                nextToCurr = nextToCurr.next;
            }
        }

        // Insert at the end of the list
        newNode.next = head;
        curr.next = newNode;
        return head;
    }


    static void Main(string[] args) {
      
        // Create circular linked list: 3->7->9->11->3
        Node head = new Node(3);
        head.next = new Node(7);
        head.next.next = new Node(9);
        head.next.next.next = new Node(11);
        head.next.next.next.next = head;
      
        head = SortedInsert(head, 8);
        Node curr = head;

        if (head != null) {
            do {
                Console.Write(curr.data + " ");
                curr = curr.next;
            } while (curr != head);
        }
        Console.WriteLine();
    }
}
JavaScript 
// Javascript program for sorted insert in circular linked
// list

class Node {
    constructor(data) {
        this.data = data;
        this.next = null;
    }
}

// Function to insert a new node in 
// the list in a sorted way
function sortedInsert(head, data) {
    let newNode = new Node(data);

    // If linked list is empty
    if (head === null) {
        newNode.next = newNode;
        return newNode;
    }

    let curr = head;
    let nextToCurr = head.next;

    // Insert at the beginning if data is
    // less than or equal to head's data
    if (data <= head.data) {
        let lastNode = head;
        while (lastNode.next !== head) {
            lastNode = lastNode.next;
        }
        newNode.next = head;
        lastNode.next = newNode;
        return newNode;
    }

    // Insert in the middle of the list
    while (curr.next !== head) {
        if (curr.data < data && nextToCurr.data >= data) {
            newNode.next = curr.next;
            curr.next = newNode;
            return head;
        }
        else {
            curr = curr.next;
            nextToCurr = nextToCurr.next;
        }
    }

    // Insert at the end of the list
    newNode.next = head;
    curr.next = newNode;
    return head;
}


// Create circular linked list: 3->7->9->11->3
let head = new Node(3);
head.next = new Node(7);
head.next.next = new Node(9);
head.next.next.next = new Node(11);
head.next.next.next.next = head;

head = sortedInsert(head, 8);
let output = "";
if (head !== null) {
    let curr = head;
    do {
        output += curr.data + " ";
        curr = curr.next;
    } while (curr !== head);
}
console.log(output.trim());

Output
3 7 8 9 11

Time Complexity: O(n), where n is the number of nodes in the given circular linked list.
Auxiliary Space: O(1)


Sorted insert for circular linked list | DSA Problem
Next Article
Analysis of Algorithms

K
kartik
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox