Binary search in an object Array for the field of an element

Binary Search on Singly Linked List

Last Updated : 04 Sep, 2024

Given a sorted singly linked list and a key, the task is to find the key in the Linked List using Binary Search.

Examples:

Input: head = 1->4->7->8->9->10, key = 7
Output: Present

Input: LinkedList = 1->4->7->8->9->10, key = 12
Output: Value Not Present

Note that Binary Search does not work efficiently for linked lists. The purpose of this article is to show the same. It is recommended to use simple linear search. If we wish to achieve better than linear time, Skip List is recommended for fast search.

Find the middle element of the Linked List.
Compare the middle element with the key.
if the key is found in the middle element, return true.
If the key is not found in the middle element, choose which half will be used as the next search space.
- If the key is smaller than the middle node, the left half is used for the next search.
- If the key is greater than the middle node, then the right half is used for the next search.
This process is continued until the key is found or the total Linked List is exhausted.

Below is the implementation of the above approach:

C++

// C++ code to implement binary search
// on Singly Linked List
#include <bits/stdc++.h>
using namespace std;

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

// function to find out middle element
Node *middle(Node *start, Node *last) {
    if (start == NULL) {
        return NULL;
    }

    if (start == last)
        return start;

    Node *slow = start;
    Node *fast = start->next;

    while (fast != last) {
        fast = fast->next;
        slow = slow->next;
        if (fast != last) {
            fast = fast->next;
        }
    }

    return slow;
}

// Function for implementing the Binary
// Search on linked list
bool binarySearch(Node *head, int value) {
    Node *start = head;
    Node *last = NULL;

    while (true) {

        // Find middle
        Node *mid = middle(start, last);

        // If middle is empty
        if (mid == NULL) {
            return false;
        }

        // If value is present at middle
        if (mid->data == value)
            return true;

        // If start and last node are overlapping
        else if (start == last)
            break;

        // If value is more than mid
        else if (mid->data < value) {
            start = mid->next;
        }

        // If the value is less than mid.
        else if (mid->data > value)
            last = mid;
    }

    // value not present
    return false;
}

int main() {
  	
  	 // Create a hard-coded linked list:
	// 1 -> 4 -> 7 -> 8 -> 9 -> 10
    Node *head = new Node(1);
    head->next = new Node(4);
    head->next->next = new Node(7);
    head->next->next->next = new Node(8);
    head->next->next->next->next = new Node(9);
    head->next->next->next->next->next = new Node(10);

    int value = 7;
    if (binarySearch(head, value))
        cout << "Present";
    else
        cout << "Value not present\n";

    return 0;
}

// C code to implement binary search
// on Singly Linked List
#include <stdio.h>
#include <stdlib.h>

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

// function to find out middle element
struct Node *middle(struct Node *start, struct Node *last) {
    if (start == NULL) {
        return NULL;
    }

    if (start == last)
        return start;

    struct Node *slow = start;
    struct Node *fast = start->next;

    while (fast != last) {
        fast = fast->next;
        slow = slow->next;
        if (fast != last) {
            fast = fast->next;
        }
    }

    return slow;
}

// Function for implementing the Binary
// Search on linked list
int binarySearch(struct Node *head, int value) {
    struct Node *start = head;
    struct Node *last = NULL;

    while (1) {

        // Find middle
        struct Node *mid = middle(start, last);

        // If middle is empty
        if (mid == NULL) {
            return 0;
        }

        // If value is present at middle
        if (mid->data == value)
            return 1;

        // If start and last node are overlapping
        else if (start == last)
            break;

        // If value is more than mid
        else if (mid->data < value) {
            start = mid->next;
        }

        // If the value is less than mid.
        else if (mid->data > value)
            last = mid;
    }

    // value not present
    return 0;
}

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

int main() {
  
 	 // Create a hard-coded linked list:
	// 1 -> 4 -> 7 -> 8 -> 9 -> 10
    struct Node *head = createNode(1);
    head->next = createNode(4);
    head->next->next = createNode(7);
    head->next->next->next = createNode(8);
    head->next->next->next->next = createNode(9);
    head->next->next->next->next->next = createNode(10);

    int value = 7;
    if (binarySearch(head, value))
        printf("Present\n");
    else
        printf("Value not present\n");

    return 0;
}

Java

// Java code to implement binary search
// on Singly Linked List

class Node {
    int data;
    Node next;

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

public class GfG {

    // function to find out middle element
    static Node middle(Node start, Node last) {
        if (start == null) {
            return null;
        }

        if (start == last)
            return start;

        Node slow = start;
        Node fast = start.next;

        while (fast != last) {
            fast = fast.next;
            slow = slow.next;
            if (fast != last) {
                fast = fast.next;
            }
        }

        return slow;
    }

    // Function for implementing the Binary
    // Search on linked list
    static boolean binarySearch(Node head, int value) {
        Node start = head;
        Node last = null;

        while (true) {

            // Find middle
            Node mid = middle(start, last);

            // If middle is empty
            if (mid == null) {
                return false;
            }

            // If value is present at middle
            if (mid.data == value)
                return true;

            // If start and last node are overlapping
            else if (start == last)
                break;

            // If value is more than mid
            else if (mid.data < value) {
                start = mid.next;
            }

            // If the value is less than mid.
            else if (mid.data > value)
                last = mid;
        }

        // value not present
        return false;
    }

    public static void main(String[] args) {
      
       	// Create a hard-coded linked list:
		// 1 -> 4 -> 7 -> 8 -> 9 -> 10
        Node head = new Node(1);
        head.next = new Node(4);
        head.next.next = new Node(7);
        head.next.next.next = new Node(8);
        head.next.next.next.next = new Node(9);
        head.next.next.next.next.next = new Node(10);

        int value = 7;

        if (binarySearch(head, value))
            System.out.println("Present");
        else
            System.out.println("Value not present");
    }
}

Python

# Python code to implement binary search
# on Singly Linked List
class Node:
    def __init__(self, new_data):
        self.data = new_data
        self.next = None

# function to find out middle element
def middle(start, last):
    if start is None:
        return None

    if start == last:
        return start

    slow = start
    fast = start.next

    while fast != last:
        fast = fast.next
        slow = slow.next
        if fast != last:
            fast = fast.next

    return slow

# Function for implementing the Binary
# Search on linked list
def binary_search(head, value):
    start = head
    last = None

    while True:

        # Find middle
        mid = middle(start, last)

        # If middle is empty
        if mid is None:
            return False

        # If value is present at middle
        if mid.data == value:
            return True

        # If start and last node are overlapping
        elif start == last:
            break

        # If value is more than mid
        elif mid.data < value:
            start = mid.next

        # If the value is less than mid.
        elif mid.data > value:
            last = mid

    # value not present
    return False


if __name__ == "__main__":
  
  	# Create a hard-coded linked list:
	# 1 -> 4 -> 7 -> 8 -> 9 -> 10
    head = Node(1)
    head.next = Node(4)
    head.next.next = Node(7)
    head.next.next.next = Node(8)
    head.next.next.next.next = Node(9)
    head.next.next.next.next.next = Node(10)

    value = 7
    if binary_search(head, value):
        print("Present")
    else:
        print("Value not present")

// C# code to implement binary search
// on Singly Linked List
using System;

class Node {
    public int Data;
    public Node next;

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

class GfG {

    // function to find out middle element
    static Node Middle(Node start, Node last) {
        if (start == null) {
            return null;
        }

        if (start == last) {
            return start;
        }

        Node slow = start;
        Node fast = start.next;

        while (fast != last) {
            fast = fast.next;
            slow = slow.next;
            if (fast != last) {
                fast = fast.next;
            }
        }

        return slow;
    }

    // Function for implementing the Binary
    // Search on linked list
    static bool BinarySearch(Node head, int value) {
        Node start = head;
        Node last = null;

        while (true) {

            // Find middle
            Node mid = Middle(start, last);

            // If middle is empty
            if (mid == null) {
                return false;
            }

            // If value is present at middle
            if (mid.Data == value) {
                return true;
            }

            // If start and last node are overlapping
            else if (start == last) {
                break;
            }

            // If value is more than mid
            else if (mid.Data < value) {
                start = mid.next;
            }

            // If the value is less than mid.
            else if (mid.Data > value) {
                last = mid;
            }
        }

        // value not present
        return false;
    }

    static void Main() {

        // Create a hard-coded linked list:
        // 1 -> 4 -> 7 -> 8 -> 9 -> 10
        Node head = new Node(1);
        head.next = new Node(4);
        head.next.next = new Node(7);
        head.next.next.next = new Node(8);
        head.next.next.next.next = new Node(9);
        head.next.next.next.next.next = new Node(10);

        int value = 7;
        if (BinarySearch(head, value)) {
            Console.WriteLine("Present");
        }
        else {
            Console.WriteLine("Value not present");
        }
    }
}

JavaScript

// JavaScript code to implement binary search
// on Singly Linked List
class Node {
    constructor(newData) {
        this.data = newData;
        this.next = null;
    }
}

// function to find out middle element
function middle(start, last) {
    if (start === null) {
        return null;
    }

    if (start === last) {
        return start;
    }

    let slow = start;
    let fast = start.next;

    while (fast !== last) {
        fast = fast.next;
        slow = slow.next;
        if (fast !== last) {
            fast = fast.next;
        }
    }

    return slow;
}

// Function for implementing the Binary
// Search on linked list
function binarySearch(head, value) {
    let start = head;
    let last = null;

    while (true) {
    
        // Find middle
        let mid = middle(start, last);

        // If middle is empty
        if (mid === null) {
            return false;
        }

        // If value is present at middle
        if (mid.data === value) {
            return true;
        }

        // If start and last node are overlapping
        else if (start === last) {
            break;
        }

        // If value is more than mid
        else if (mid.data < value) {
            start = mid.next;
        }

        // If the value is less than mid.
        else if (mid.data > value) {
            last = mid;
        }
    }

    // value not present
    return false;
}

// Create a hard-coded linked list:
// 1 -> 4 -> 7 -> 8 -> 9 -> 10
let head = new Node(1);
head.next = new Node(4);
head.next.next = new Node(7);
head.next.next.next = new Node(8);
head.next.next.next.next = new Node(9);
head.next.next.next.next.next = new Node(10);

let value = 7;
if (binarySearch(head, value)) {
    console.log("Present");
}
else {
    console.log("Value not present");
}

Output

Present

Time complexity: O(n) , where n is the number of nodes in linked list.
Auxilliary Space: O(1)

Binary search in an object Array for the field of an element

KunalDhyani

Improve

Article Tags :

Practice Tags :

Binary Search on Singly Linked List

Similar Reads

Variants of Binary Search

Implementation of Binary Search in different languages

Comparison with other Searching

Thank You!

What kind of Experience do you want to share?