Site icon NF AI

What is Binary Search Tree?

Differences among Binary Search, Binary Search Tree and Linear Search along with thier properties.

What is binary search?

A binary search is a method of searching for an element in a sorted array. It works by repeatedly dividing the array in half until the element is found or the array is empty.

Why is Binary Search SO IMPORTANT?

Binary search is an efficient algorithm for finding an item in a sorted list.

Features of Binary Search

Examples of Binary Search:

When looking up a word in the dictionary, you would use a binary search. When searching for a value in a sorted list, you would use a binary search.

Binary search algorithm in Python

def binary_search(list, item):
    low = 0
    high = len(list) - 1

    while low <= high:
        mid = (low + high) // 2
        guess = list[mid]
        if guess == item:
            return mid
        if guess > item:
            high = mid - 1
        else:
            low = mid + 1
    return None

Binary search algorithm in JS

binary_search_algorithm = function(array, target) {
  var left = 0;
  var right = array.length - 1;
  var middle = Math.floor((left + right) / 2);
  while (array[middle] !== target && left <= right) {
    if (target < array[middle]) {
      right = middle - 1;
    } else {
      left = middle + 1;
    }
    middle = Math.floor((left + right) / 2);
  }
  if (array[middle] === target) {
    return middle;
  } else {
    return -1;
  }
}

What is the difference between Binary Search and Binary Search Tree?

Binary search is a search algorithm that finds the position of a target value within a sorted array. Binary search trees are data structures that allow efficient access to data via key-based searches.

What is Binary Search Tree?

A binary search tree is a data structure that allows fast lookup, insertion, and deletion of data items. It is a binary tree with the following properties:

What are the Usages of Binary Search Tree?

The binary search tree data structure can be used for data in which the items have a natural order. For example, if the items are integers, the binary search tree can be used to determine which integer is larger or smaller. The binary search tree can also be used to find out if a particular item is in the tree.

Examples of Binary Search Tree:

A binary tree is a search tree if and only if it is both a binary tree and a search tree.

Python code for Binary Search Tree Algorithm:

def binary_search_tree(root):
    # check if the root is None
    if root is None:
        return True
    # check if the left subtree is a binary search tree
    if root.left is not None:
        if root.left.value > root.value:
            return False
        if root.left.value < root.value:
            return binary_search_tree(root.left)
    # check if the right subtree is a binary search tree
    if root.right is not None:
        if root.right.value < root.value:
            return False
        if root.right.value > root.value:
            return binary_search_tree(root.right)
    return True

JS code for Binary Search Tree Algorithm:

/* Prototype of binary search tree */
binary_search_tree.prototype.insert = function(value) {
  var node = new binary_search_tree.node(value);
  if (this.root == null) {
    this.root = node;
  } else {
    var current = this.root;
    while (true) {
      if (value < current.value) {
        if (current.left == null) {
          current.left = node;
          break;
        } else {
          current = current.left;
        }
      } else if (value > current.value) {
        if (current.right == null) {
          current.right = node;
          break;
        } else {
          current = current.right;
        }
      } else {
        break;
      }
    }
  }
  this.size++;
}

What is Linear Search Algorithm?

A linear search algorithm is a method for finding a target value within a list of values. It sequentially checks each element of the list until it finds an element that matches the target value or until it reaches the end of the list.

Python code for Linear Search Algorithm:

def linear_search(arr, n, x):
    for i in range(n):
        if arr[i] == x:
            return i
    return -1

Linear Search Algorithm in JS:

/* linear search Algorithm in JS*/
linearSearch = (arr, val) => {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === val) {
      return i;
    }
  }
  return -1;
}

Conclusion

The biggest difference between linear search and binary search is that, in the worst case, you have to check every element in the array when doing linear search, while you only need to check half of the elements when doing binary search. This is due to the fact that binary search uses a divide and conquer strategy, while linear search just goes through the elements one by one until it finds the desired element. The time complexity of binary search is therefore much better than linear search.

Exit mobile version