ಬೈನರಿ ಸರ್ಚ್ ಟ್ರೀಸ್: ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಒಂದು ಸಮಗ್ರ ಅನುಷ್ಠಾನ ಮಾರ್ಗದರ್ಶಿ

ಬೈನರಿ ಸರ್ಚ್ ಟ್ರೀಸ್ (BSTs) ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದಲ್ಲಿ ಒಂದು ಮೂಲಭೂತ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್ ಆಗಿದೆ, ಇದನ್ನು ದತ್ತಾಂಶವನ್ನು ದಕ್ಷವಾಗಿ ಹುಡುಕಲು, ವಿಂಗಡಿಸಲು ಮತ್ತು ಹಿಂಪಡೆಯಲು ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಅವುಗಳ ಶ್ರೇಣೀಕೃತ ರಚನೆಯು ಅನೇಕ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿ ಲಾಗರಿಥಮಿಕ್ ಟೈಮ್ ಕಾಂಪ್ಲೆಕ್ಸಿಟಿಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆ, ಇದು ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಒಂದು ಶಕ್ತಿಯುತ ಸಾಧನವಾಗಿದೆ. ಈ ಮಾರ್ಗದರ್ಶಿಯು BSTಗಳ ಸಮಗ್ರ ಅವಲೋಕನವನ್ನು ಒದಗಿಸುತ್ತದೆ ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಅವುಗಳ ಅನುಷ್ಠಾನವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ, ಇದು ವಿಶ್ವಾದ್ಯಂತ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಸಹಕಾರಿಯಾಗಿದೆ.

ಬೈನರಿ ಸರ್ಚ್ ಟ್ರೀಸ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಬೈನರಿ ಸರ್ಚ್ ಟ್ರೀ ಎಂದರೇನು?

ಬೈನರಿ ಸರ್ಚ್ ಟ್ರೀ ಒಂದು ಟ್ರೀ-ಆಧಾರಿತ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್ ಆಗಿದೆ, ಇದರಲ್ಲಿ ಪ್ರತಿಯೊಂದು ನೋಡ್ ಗರಿಷ್ಠ ಎರಡು ಮಕ್ಕಳನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಇವನ್ನು ಎಡ ಚೈಲ್ಡ್ ಮತ್ತು ಬಲ ಚೈಲ್ಡ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. BST ಯ ಪ್ರಮುಖ ಗುಣಲಕ್ಷಣವೆಂದರೆ ಯಾವುದೇ ನಿರ್ದಿಷ್ಟ ನೋಡ್‌ಗೆ:

• ಎಡ ಸಬ್‌ಟ್ರೀಯಲ್ಲಿರುವ ಎಲ್ಲಾ ನೋಡ್‌ಗಳು ನೋಡ್‌ನ ಕೀಗಿಂತ ಕಡಿಮೆ ಕೀಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ.
• ಬಲ ಸಬ್‌ಟ್ರೀಯಲ್ಲಿರುವ ಎಲ್ಲಾ ನೋಡ್‌ಗಳು ನೋಡ್‌ನ ಕೀಗಿಂತ ಹೆಚ್ಚಿನ ಕೀಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ.

ಈ ಗುಣಲಕ್ಷಣವು BSTಯಲ್ಲಿನ ಅಂಶಗಳು ಯಾವಾಗಲೂ ಕ್ರಮಬದ್ಧವಾಗಿರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಇದರಿಂದಾಗಿ ದಕ್ಷ ಹುಡುಕಾಟ ಮತ್ತು ಹಿಂಪಡೆಯುವಿಕೆಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳು

• ನೋಡ್: ಟ್ರೀಯಲ್ಲಿನ ಒಂದು ಮೂಲ ಘಟಕ, ಇದು ಕೀ (ಡೇಟಾ) ಮತ್ತು ಅದರ ಎಡ ಮತ್ತು ಬಲ ಮಕ್ಕಳಿಗೆ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ.
• ರೂಟ್: ಟ್ರೀಯ ಅತ್ಯುನ್ನತ ನೋಡ್.
• ಲೀಫ್: ಯಾವುದೇ ಮಕ್ಕಳಿಲ್ಲದ ನೋಡ್.
• ಸಬ್‌ಟ್ರೀ: ನಿರ್ದಿಷ್ಟ ನೋಡ್‌ನಿಂದ ಬೇರೂರಿರುವ ಟ್ರೀಯ ಒಂದು ಭಾಗ.
• ಎತ್ತರ: ರೂಟ್‌ನಿಂದ ಲೀಫ್‌ಗೆ ಇರುವ ಅತಿ ಉದ್ದದ ಪಥದ ಉದ್ದ.
• ಆಳ: ರೂಟ್‌ನಿಂದ ನಿರ್ದಿಷ್ಟ ನೋಡ್‌ಗೆ ಇರುವ ಪಥದ ಉದ್ದ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಬೈನರಿ ಸರ್ಚ್ ಟ್ರೀ ಅನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸುವುದು

ನೋಡ್ ಕ್ಲಾಸ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು

ಮೊದಲಿಗೆ, BST ಯಲ್ಲಿನ ಪ್ರತಿಯೊಂದು ನೋಡ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸಲು ನಾವು `Node` ಕ್ಲಾಸ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ. ಪ್ರತಿಯೊಂದು ನೋಡ್ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು `key` ಮತ್ತು ಅದರ ಮಕ್ಕಳಿಗೆ `left` ಮತ್ತು `right` ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ.

class Node {
  constructor(key) {
    this.key = key;
    this.left = null;
    this.right = null;
  }
}

ಬೈನರಿ ಸರ್ಚ್ ಟ್ರೀ ಕ್ಲಾಸ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು

ಮುಂದೆ, ನಾವು `BinarySearchTree` ಕ್ಲಾಸ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ. ಈ ಕ್ಲಾಸ್ ರೂಟ್ ನೋಡ್ ಮತ್ತು ಟ್ರೀಯನ್ನು ಇನ್ಸರ್ಟ್, ಸರ್ಚ್, ಡಿಲೀಟ್ ಮತ್ತು ಟ್ರಾವರ್ಸ್ ಮಾಡಲು ಮೆಥಡ್‌ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ.

class BinarySearchTree {
  constructor() {
    this.root = null;
  }

  // ಮೆಥಡ್‌ಗಳನ್ನು ಇಲ್ಲಿ ಸೇರಿಸಲಾಗುತ್ತದೆ
}

ಇನ್ಸರ್ಷನ್ (ಸೇರಿಸುವಿಕೆ)

`insert` ಮೆಥಡ್ ನೀಡಿದ ಕೀ ಯೊಂದಿಗೆ ಹೊಸ ನೋಡ್ ಅನ್ನು BST ಗೆ ಸೇರಿಸುತ್ತದೆ. ಇನ್ಸರ್ಷನ್ ಪ್ರಕ್ರಿಯೆಯು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ನೋಡ್‌ಗಳಿಗೆ ಸಂಬಂಧಿಸಿದಂತೆ ಸೂಕ್ತ ಸ್ಥಾನದಲ್ಲಿ ಹೊಸ ನೋಡ್ ಅನ್ನು ಇರಿಸುವ ಮೂಲಕ BST ಗುಣಲಕ್ಷಣವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.

insert(key) {
  const newNode = new Node(key);

  if (this.root === null) {
    this.root = newNode;
  } else {
    this.insertNode(this.root, newNode);
  }
}

insertNode(node, newNode) {
  if (newNode.key < node.key) {
    if (node.left === null) {
      node.left = newNode;
    } else {
      this.insertNode(node.left, newNode);
    }
  } else {
    if (node.right === null) {
      node.right = newNode;
    } else {
      this.insertNode(node.right, newNode);
    }
  }
}

ಉದಾಹರಣೆ: BST ಗೆ ಮೌಲ್ಯಗಳನ್ನು ಸೇರಿಸುವುದು

const bst = new BinarySearchTree();
bst.insert(11);
bst.insert(7);
bst.insert(15);
bst.insert(5);
bst.insert(3);
bst.insert(9);
bst.insert(8);
bst.insert(10);
bst.insert(13);
bst.insert(12);
bst.insert(14);
bst.insert(20);
bst.insert(18);
bst.insert(25);

ಸರ್ಚಿಂಗ್ (ಹುಡುಕಾಟ)

`search` ಮೆಥಡ್ ನೀಡಿದ ಕೀ ಯೊಂದಿಗೆ ನೋಡ್ BST ಯಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಇದು ಕೀ ಅನ್ನು ಪ್ರಸ್ತುತ ನೋಡ್‌ನ ಕೀ ಯೊಂದಿಗೆ ಹೋಲಿಸಿ, ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಎಡ ಅಥವಾ ಬಲ ಸಬ್‌ಟ್ರೀಗೆ ಚಲಿಸುವ ಮೂಲಕ ಟ್ರೀಯನ್ನು ಟ್ರಾವರ್ಸ್ ಮಾಡುತ್ತದೆ.

search(key) {
  return this.searchNode(this.root, key);
}

searchNode(node, key) {
  if (node === null) {
    return false;
  }

  if (key < node.key) {
    return this.searchNode(node.left, key);
  } else if (key > node.key) {
    return this.searchNode(node.right, key);
  } else {
    return true;
  }
}

ಉದಾಹರಣೆ: BST ಯಲ್ಲಿ ಮೌಲ್ಯವನ್ನು ಹುಡುಕುವುದು

console.log(bst.search(9));  // Output: true
console.log(bst.search(2));  // Output: false

ಡಿಲೀಷನ್ (ಅಳಿಸುವಿಕೆ)

`remove` ಮೆಥಡ್ ನೀಡಿದ ಕೀ ಯೊಂದಿಗೆ ನೋಡ್ ಅನ್ನು BST ಯಿಂದ ಅಳಿಸುತ್ತದೆ. ಇದು ಅತ್ಯಂತ ಸಂಕೀರ್ಣವಾದ ಕಾರ್ಯಾಚರಣೆಯಾಗಿದೆ ಏಕೆಂದರೆ ನೋಡ್ ಅನ್ನು ತೆಗೆದುಹಾಕುವಾಗ BST ಗುಣಲಕ್ಷಣವನ್ನು ನಿರ್ವಹಿಸಬೇಕಾಗುತ್ತದೆ. ಪರಿಗಣಿಸಲು ಮೂರು ಪ್ರಕರಣಗಳಿವೆ:

• ಪ್ರಕರಣ 1: ಅಳಿಸಬೇಕಾದ ನೋಡ್ ಲೀಫ್ ನೋಡ್ ಆಗಿದೆ. ಅದನ್ನು ಸರಳವಾಗಿ ತೆಗೆದುಹಾಕಿ.
• ಪ್ರಕರಣ 2: ಅಳಿಸಬೇಕಾದ ನೋಡ್‌ಗೆ ಒಂದು ಮಗು ಇದೆ. ನೋಡ್ ಅನ್ನು ಅದರ ಮಗುವಿನೊಂದಿಗೆ ಬದಲಾಯಿಸಿ.
• ಪ್ರಕರಣ 3: ಅಳಿಸಬೇಕಾದ ನೋಡ್‌ಗೆ ಎರಡು ಮಕ್ಕಳಿವೆ. ಇನ್-ಆರ್ಡರ್ ಸಕ್ಸೆಸರ್ ಅನ್ನು (ಬಲ ಸಬ್‌ಟ್ರೀಯಲ್ಲಿನ ಚಿಕ್ಕ ನೋಡ್) ಹುಡುಕಿ, ನೋಡ್ ಅನ್ನು ಸಕ್ಸೆಸರ್‌ನೊಂದಿಗೆ ಬದಲಾಯಿಸಿ, ಮತ್ತು ನಂತರ ಸಕ್ಸೆಸರ್ ಅನ್ನು ಅಳಿಸಿ.

remove(key) {
  this.root = this.removeNode(this.root, key);
}

removeNode(node, key) {
  if (node === null) {
    return null;
  }

  if (key < node.key) {
    node.left = this.removeNode(node.left, key);
    return node;
  } else if (key > node.key) {
    node.right = this.removeNode(node.right, key);
    return node;
  } else {
    // ಕೀ ನೋಡ್‌ನ ಕೀಗೆ ಸಮನಾಗಿದೆ

    // ಪ್ರಕರಣ 1 - ಲೀಫ್ ನೋಡ್
    if (node.left === null && node.right === null) {
      node = null;
      return node;
    }

    // ಪ್ರಕರಣ 2 - ನೋಡ್‌ಗೆ ಕೇವಲ 1 ಮಗು ಇದೆ
    if (node.left === null) {
      node = node.right;
      return node;
    } else if (node.right === null) {
      node = node.left;
      return node;
    }

    // ಪ್ರಕರಣ 3 - ನೋಡ್‌ಗೆ 2 ಮಕ್ಕಳಿದ್ದಾರೆ
    const aux = this.findMinNode(node.right);
    node.key = aux.key;
    node.right = this.removeNode(node.right, aux.key);
    return node;
  }
}

findMinNode(node) {
  let current = node;
  while (current != null && current.left != null) {
    current = current.left;
  }
  return current;
}

ಉದಾಹರಣೆ: BST ಯಿಂದ ಮೌಲ್ಯವನ್ನು ತೆಗೆದುಹಾಕುವುದು

bst.remove(7);
console.log(bst.search(7)); // Output: false

ಟ್ರೀ ಟ್ರಾವರ್ಸಲ್

ಟ್ರೀ ಟ್ರಾವರ್ಸಲ್ ಎಂದರೆ ಟ್ರೀಯ ಪ್ರತಿಯೊಂದು ನೋಡ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟ ಕ್ರಮದಲ್ಲಿ ಭೇಟಿ ಮಾಡುವುದು. ಹಲವಾರು ಸಾಮಾನ್ಯ ಟ್ರಾವರ್ಸಲ್ ವಿಧಾನಗಳಿವೆ:

• ಇನ್-ಆರ್ಡರ್: ಎಡ ಸಬ್‌ಟ್ರೀ, ನಂತರ ನೋಡ್, ನಂತರ ಬಲ ಸಬ್‌ಟ್ರೀಯನ್ನು ಭೇಟಿ ಮಾಡುತ್ತದೆ. ಇದು ನೋಡ್‌ಗಳನ್ನು ಆರೋಹಣ ಕ್ರಮದಲ್ಲಿ ಭೇಟಿ ಮಾಡಲು ಕಾರಣವಾಗುತ್ತದೆ.
• ಪ್ರೀ-ಆರ್ಡರ್: ನೋಡ್, ನಂತರ ಎಡ ಸಬ್‌ಟ್ರೀ, ನಂತರ ಬಲ ಸಬ್‌ಟ್ರೀಯನ್ನು ಭೇಟಿ ಮಾಡುತ್ತದೆ.
• ಪೋಸ್ಟ್-ಆರ್ಡರ್: ಎಡ ಸಬ್‌ಟ್ರೀ, ನಂತರ ಬಲ ಸಬ್‌ಟ್ರೀ, ನಂತರ ನೋಡ್ ಅನ್ನು ಭೇಟಿ ಮಾಡುತ್ತದೆ.

inOrderTraverse(callback) {
  this.inOrderTraverseNode(this.root, callback);
}

inOrderTraverseNode(node, callback) {
  if (node !== null) {
    this.inOrderTraverseNode(node.left, callback);
    callback(node.key);
    this.inOrderTraverseNode(node.right, callback);
  }
}

preOrderTraverse(callback) {
  this.preOrderTraverseNode(this.root, callback);
}

preOrderTraverseNode(node, callback) {
  if (node !== null) {
    callback(node.key);
    this.preOrderTraverseNode(node.left, callback);
    this.preOrderTraverseNode(node.right, callback);
  }
}

postOrderTraverse(callback) {
  this.postOrderTraverseNode(this.root, callback);
}

postOrderTraverseNode(node, callback) {
  if (node !== null) {
    this.postOrderTraverseNode(node.left, callback);
    this.postOrderTraverseNode(node.right, callback);
    callback(node.key);
  }
}

ಉದಾಹರಣೆ: BST ಅನ್ನು ಟ್ರಾವರ್ಸ್ ಮಾಡುವುದು

const printNode = (value) => console.log(value);

bst.inOrderTraverse(printNode);   // Output: 3 5 8 9 10 11 12 13 14 15 18 20 25
bst.preOrderTraverse(printNode);  // Output: 11 5 3 9 8 10 15 13 12 14 20 18 25
bst.postOrderTraverse(printNode); // Output: 3 8 10 9 12 14 13 18 25 20 15 11

ಕನಿಷ್ಠ ಮತ್ತು ಗರಿಷ್ಠ ಮೌಲ್ಯಗಳು

BST ಯಲ್ಲಿ ಕನಿಷ್ಠ ಮತ್ತು ಗರಿಷ್ಠ ಮೌಲ್ಯಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಅದರ ಕ್ರಮಬದ್ಧ ಸ್ವಭಾವಕ್ಕೆ ಧನ್ಯವಾದಗಳು, ಸರಳವಾಗಿದೆ.

min() {
  return this.minNode(this.root);
}

minNode(node) {
  let current = node;
  while (current !== null && current.left !== null) {
    current = current.left;
  }
  return current;
}

max() {
  return this.maxNode(this.root);
}

maxNode(node) {
  let current = node;
  while (current !== null && current.right !== null) {
    current = current.right;
  }
  return current;
}

ಉದಾಹರಣೆ: ಕನಿಷ್ಠ ಮತ್ತು ಗರಿಷ್ಠ ಮೌಲ್ಯಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು

console.log(bst.min().key); // Output: 3
console.log(bst.max().key); // Output: 25

ಬೈನರಿ ಸರ್ಚ್ ಟ್ರೀಗಳ ಪ್ರಾಯೋಗಿಕ ಅನ್ವಯಗಳು

ಬೈನರಿ ಸರ್ಚ್ ಟ್ರೀಗಳನ್ನು ವಿವಿಧ ಅನ್ವಯಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ, ಅವುಗಳೆಂದರೆ:

• ಡೇಟಾಬೇಸ್‌ಗಳು: ಡೇಟಾವನ್ನು ಇಂಡೆಕ್ಸಿಂಗ್ ಮತ್ತು ಸರ್ಚಿಂಗ್ ಮಾಡುವುದು. ಉದಾಹರಣೆಗೆ, ಅನೇಕ ಡೇಟಾಬೇಸ್ ಸಿಸ್ಟಮ್‌ಗಳು ರೆಕಾರ್ಡ್‌ಗಳನ್ನು ದಕ್ಷವಾಗಿ ಪತ್ತೆಹಚ್ಚಲು B-ಟ್ರೀಗಳಂತಹ BST ಗಳ ರೂಪಾಂತರಗಳನ್ನು ಬಳಸುತ್ತವೆ. ಬಹುರಾಷ್ಟ್ರೀಯ ನಿಗಮಗಳು ಬಳಸುವ ಡೇಟಾಬೇಸ್‌ಗಳ ಜಾಗತಿಕ ಪ್ರಮಾಣವನ್ನು ಪರಿಗಣಿಸಿ; ದಕ್ಷ ಡೇಟಾ ಹಿಂಪಡೆಯುವಿಕೆ ಅತ್ಯಂತ ಮುಖ್ಯವಾಗಿದೆ.
• ಕಂಪೈಲರ್‌ಗಳು: ಸಿಂಬಲ್ ಟೇಬಲ್‌ಗಳು, ಇವು ವೇರಿಯೇಬಲ್‌ಗಳು ಮತ್ತು ಫಂಕ್ಷನ್‌ಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತವೆ.
• ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಳು: ಪ್ರೊಸೆಸ್ ಶೆಡ್ಯೂಲಿಂಗ್ ಮತ್ತು ಮೆಮೊರಿ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್.
• ಸರ್ಚ್ ಇಂಜಿನ್‌ಗಳು: ವೆಬ್ ಪುಟಗಳನ್ನು ಇಂಡೆಕ್ಸಿಂಗ್ ಮಾಡುವುದು ಮತ್ತು ಹುಡುಕಾಟ ಫಲಿತಾಂಶಗಳನ್ನು ಶ್ರೇಣೀಕರಿಸುವುದು.
• ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗಳು: ಫೈಲ್‌ಗಳನ್ನು ಸಂಘಟಿಸುವುದು ಮತ್ತು ಪ್ರವೇಶಿಸುವುದು. ಜಾಗತಿಕವಾಗಿ ವೆಬ್‌ಸೈಟ್‌ಗಳನ್ನು ಹೋಸ್ಟ್ ಮಾಡಲು ಬಳಸುವ ಸರ್ವರ್‌ನಲ್ಲಿರುವ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ; ಉತ್ತಮವಾಗಿ ಸಂಘಟಿತವಾದ BST-ಆಧಾರಿತ ರಚನೆಯು ವಿಷಯವನ್ನು ವೇಗವಾಗಿ ಒದಗಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಗಣನೆಗಳು

BST ಯ ಕಾರ್ಯಕ್ಷಮತೆಯು ಅದರ ರಚನೆಯನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಅತ್ಯುತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ, ಸಮತೋಲಿತ BSTಯು ಇನ್ಸರ್ಷನ್, ಸರ್ಚ್, ಮತ್ತು ಡಿಲೀಷನ್ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಲಾಗರಿಥಮಿಕ್ ಟೈಮ್ ಕಾಂಪ್ಲೆಕ್ಸಿಟಿಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ (ಉದಾಹರಣೆಗೆ, ವಕ್ರವಾದ ಟ್ರೀ), ಟೈಮ್ ಕಾಂಪ್ಲೆಕ್ಸಿಟಿಯು ಲೀನಿಯರ್ ಟೈಮ್‌ಗೆ ಕುಸಿಯಬಹುದು.

ಸಮತೋಲಿತ ಮತ್ತು ಅಸಮತೋಲಿತ ಟ್ರೀಗಳು

ಸಮತೋಲಿತ BST ಎಂದರೆ ಯಾವುದೇ ನೋಡ್‌ನ ಎಡ ಮತ್ತು ಬಲ ಸಬ್‌ಟ್ರೀಗಳ ಎತ್ತರವು ಗರಿಷ್ಠ ಒಂದರಿಂದ ಭಿನ್ನವಾಗಿರುತ್ತದೆ. AVL ಟ್ರೀಗಳು ಮತ್ತು ರೆಡ್-ಬ್ಲ್ಯಾಕ್ ಟ್ರೀಗಳಂತಹ ಸ್ವಯಂ-ಸಮತೋಲನ ಅಲ್ಗಾರಿದಮ್‌ಗಳು ಟ್ರೀ ಸಮತೋಲಿತವಾಗಿರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತವೆ, ಸ್ಥಿರ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಒದಗಿಸುತ್ತವೆ. ಸರ್ವರ್‌ನಲ್ಲಿನ ಲೋಡ್ ಅನ್ನು ಆಧರಿಸಿ ವಿವಿಧ ಪ್ರದೇಶಗಳಿಗೆ ವಿಭಿನ್ನ ಆಪ್ಟಿಮೈಸೇಶನ್ ಮಟ್ಟಗಳು ಬೇಕಾಗಬಹುದು; ಸಮತೋಲನವು ಹೆಚ್ಚಿನ ಜಾಗತಿಕ ಬಳಕೆಯ ಅಡಿಯಲ್ಲಿ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಟೈಮ್ ಕಾಂಪ್ಲೆಕ್ಸಿಟಿ

• ಇನ್ಸರ್ಷನ್: ಸರಾಸರಿ O(log n), ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ O(n).
• ಸರ್ಚ್: ಸರಾಸರಿ O(log n), ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ O(n).
• ಡಿಲೀಷನ್: ಸರಾಸರಿ O(log n), ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ O(n).
• ಟ್ರಾವರ್ಸಲ್: O(n), ಇಲ್ಲಿ n ಎಂಬುದು ಟ್ರೀಯಲ್ಲಿರುವ ನೋಡ್‌ಗಳ ಸಂಖ್ಯೆ.

ಸುಧಾರಿತ BST ಪರಿಕಲ್ಪನೆಗಳು

ಸ್ವಯಂ-ಸಮತೋಲನ ಟ್ರೀಗಳು

ಸ್ವಯಂ-ಸಮತೋಲನ ಟ್ರೀಗಳು BSTಗಳಾಗಿದ್ದು, ಅವು ಸಮತೋಲನವನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು ತಮ್ಮ ರಚನೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸರಿಹೊಂದಿಸುತ್ತವೆ. ಇದು ಟ್ರೀಯ ಎತ್ತರವು ಲಾಗರಿಥಮಿಕ್ ಆಗಿ ಉಳಿಯುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಎಲ್ಲಾ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಸ್ಥಿರವಾದ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಸಾಮಾನ್ಯ ಸ್ವಯಂ-ಸಮತೋಲನ ಟ್ರೀಗಳಲ್ಲಿ AVL ಟ್ರೀಗಳು ಮತ್ತು ರೆಡ್-ಬ್ಲ್ಯಾಕ್ ಟ್ರೀಗಳು ಸೇರಿವೆ.

AVL ಟ್ರೀಗಳು

AVL ಟ್ರೀಗಳು ಯಾವುದೇ ನೋಡ್‌ನ ಎಡ ಮತ್ತು ಬಲ ಸಬ್‌ಟ್ರೀಗಳ ನಡುವಿನ ಎತ್ತರದ ವ್ಯತ್ಯಾಸವು ಗರಿಷ್ಠ ಒಂದಾಗಿರುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ ಸಮತೋಲನವನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳುತ್ತವೆ. ಈ ಸಮತೋಲನವು ಅಸ್ತವ್ಯಸ್ತಗೊಂಡಾಗ, ಸಮತೋಲನವನ್ನು ಮರುಸ್ಥಾಪಿಸಲು ರೊಟೇಷನ್‌ಗಳನ್ನು ನಡೆಸಲಾಗುತ್ತದೆ.

ರೆಡ್-ಬ್ಲ್ಯಾಕ್ ಟ್ರೀಗಳು

ರೆಡ್-ಬ್ಲ್ಯಾಕ್ ಟ್ರೀಗಳು ಸಮತೋಲನವನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು ಬಣ್ಣದ ಗುಣಲಕ್ಷಣಗಳನ್ನು (ಕೆಂಪು ಅಥವಾ ಕಪ್ಪು) ಬಳಸುತ್ತವೆ. ಇವು AVL ಟ್ರೀಗಳಿಗಿಂತ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿವೆ ಆದರೆ ಕೆಲವು ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಉತ್ತಮ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನೀಡುತ್ತವೆ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಉದಾಹರಣೆ: ಸಂಪೂರ್ಣ ಬೈನರಿ ಸರ್ಚ್ ಟ್ರೀ ಅನುಷ್ಠಾನ

class Node {
  constructor(key) {
    this.key = key;
    this.left = null;
    this.right = null;
  }
}

class BinarySearchTree {
  constructor() {
    this.root = null;
  }

  insert(key) {
    const newNode = new Node(key);

    if (this.root === null) {
      this.root = newNode;
    } else {
      this.insertNode(this.root, newNode);
    }
  }

  insertNode(node, newNode) {
    if (newNode.key < node.key) {
      if (node.left === null) {
        node.left = newNode;
      } else {
        this.insertNode(node.left, newNode);
      }
    } else {
      if (node.right === null) {
        node.right = newNode;
      } else {
        this.insertNode(node.right, newNode);
      }
    }
  }

  search(key) {
    return this.searchNode(this.root, key);
  }

  searchNode(node, key) {
    if (node === null) {
      return false;
    }

    if (key < node.key) {
      return this.searchNode(node.left, key);
    } else if (key > node.key) {
      return this.searchNode(node.right, key);
    } else {
      return true;
    }
  }

  remove(key) {
    this.root = this.removeNode(this.root, key);
  }

  removeNode(node, key) {
    if (node === null) {
      return null;
    }

    if (key < node.key) {
      node.left = this.removeNode(node.left, key);
      return node;
    } else if (key > node.key) {
      node.right = this.removeNode(node.right, key);
      return node;
    } else {
      // ಕೀ ನೋಡ್‌ನ ಕೀಗೆ ಸಮನಾಗಿದೆ

      // ಪ್ರಕರಣ 1 - ಲೀಫ್ ನೋಡ್
      if (node.left === null && node.right === null) {
        node = null;
        return node;
      }

      // ಪ್ರಕರಣ 2 - ನೋಡ್‌ಗೆ ಕೇವಲ 1 ಮಗು ಇದೆ
      if (node.left === null) {
        node = node.right;
        return node;
      } else if (node.right === null) {
        node = node.left;
        return node;
      }

      // ಪ್ರಕರಣ 3 - ನೋಡ್‌ಗೆ 2 ಮಕ್ಕಳಿದ್ದಾರೆ
      const aux = this.findMinNode(node.right);
      node.key = aux.key;
      node.right = this.removeNode(node.right, aux.key);
      return node;
    }
  }

  findMinNode(node) {
    let current = node;
    while (current != null && current.left != null) {
      current = current.left;
    }
    return current;
  }

  min() {
    return this.minNode(this.root);
  }

  minNode(node) {
    let current = node;
    while (current !== null && current.left !== null) {
      current = current.left;
    }
    return current;
  }

  max() {
    return this.maxNode(this.root);
  }

  maxNode(node) {
    let current = node;
    while (current !== null && current.right !== null) {
      current = current.right;
    }
    return current;
  }

  inOrderTraverse(callback) {
    this.inOrderTraverseNode(this.root, callback);
  }

  inOrderTraverseNode(node, callback) {
    if (node !== null) {
      this.inOrderTraverseNode(node.left, callback);
      callback(node.key);
      this.inOrderTraverseNode(node.right, callback);
    }
  }

  preOrderTraverse(callback) {
    this.preOrderTraverseNode(this.root, callback);
  }

  preOrderTraverseNode(node, callback) {
    if (node !== null) {
      callback(node.key);
      this.preOrderTraverseNode(node.left, callback);
      this.preOrderTraverseNode(node.right, callback);
    }
  }

  postOrderTraverse(callback) {
    this.postOrderTraverseNode(this.root, callback);
  }

  postOrderTraverseNode(node, callback) {
    if (node !== null) {
      this.postOrderTraverseNode(node.left, callback);
      this.postOrderTraverseNode(node.right, callback);
      callback(node.key);
    }
  }
}

// ಬಳಕೆಯ ಉದಾಹರಣೆ
const bst = new BinarySearchTree();
bst.insert(11);
bst.insert(7);
bst.insert(15);
bst.insert(5);
bst.insert(3);
bst.insert(9);
bst.insert(8);
bst.insert(10);
bst.insert(13);
bst.insert(12);
bst.insert(14);
bst.insert(20);
bst.insert(18);
bst.insert(25);

const printNode = (value) => console.log(value);

console.log("ಇನ್-ಆರ್ಡರ್ ಟ್ರಾವರ್ಸಲ್:");
bst.inOrderTraverse(printNode);

console.log("ಪ್ರೀ-ಆರ್ಡರ್ ಟ್ರಾವರ್ಸಲ್:");
bst.preOrderTraverse(printNode);

console.log("ಪೋಸ್ಟ್-ಆರ್ಡರ್ ಟ್ರಾವರ್ಸಲ್:");
bst.postOrderTraverse(printNode);

console.log("ಕನಿಷ್ಠ ಮೌಲ್ಯ:", bst.min().key);
console.log("ಗರಿಷ್ಠ ಮೌಲ್ಯ:", bst.max().key);

console.log("9 ಕ್ಕಾಗಿ ಹುಡುಕಾಟ:", bst.search(9));
console.log("2 ಕ್ಕಾಗಿ ಹುಡುಕಾಟ:", bst.search(2));

bst.remove(7);
console.log("7 ಅನ್ನು ತೆಗೆದುಹಾಕಿದ ನಂತರ ಹುಡುಕಾಟ:", bst.search(7));

ತೀರ್ಮಾನ

ಬೈನರಿ ಸರ್ಚ್ ಟ್ರೀಗಳು ಹಲವಾರು ಅನ್ವಯಗಳನ್ನು ಹೊಂದಿರುವ ಒಂದು ಶಕ್ತಿಯುತ ಮತ್ತು ಬಹುಮುಖ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್ ಆಗಿದೆ. ಈ ಮಾರ್ಗದರ್ಶಿಯು BSTಗಳ ರಚನೆ, ಕಾರ್ಯಾಚರಣೆಗಳು, ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಅನುಷ್ಠಾನವನ್ನು ಒಳಗೊಂಡಂತೆ ಸಮಗ್ರ ಅವಲೋಕನವನ್ನು ಒದಗಿಸಿದೆ. ಈ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ ಚರ್ಚಿಸಲಾದ ತತ್ವಗಳು ಮತ್ತು ತಂತ್ರಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ವಿಶ್ವಾದ್ಯಂತ ಡೆವಲಪರ್‌ಗಳು ಸಾಫ್ಟ್‌ವೇರ್ ಡೆವಲಪ್‌ಮೆಂಟ್‌ನಲ್ಲಿ ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು BSTಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಿಕೊಳ್ಳಬಹುದು. ಜಾಗತಿಕ ಡೇಟಾಬೇಸ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುವುದರಿಂದ ಹಿಡಿದು ಹುಡುಕಾಟ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವವರೆಗೆ, BSTಗಳ ಜ್ಞಾನವು ಯಾವುದೇ ಪ್ರೋಗ್ರಾಮರ್‌ಗೆ ಒಂದು ಅಮೂಲ್ಯ ಆಸ್ತಿಯಾಗಿದೆ.

ನೀವು ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದಲ್ಲಿ ನಿಮ್ಮ ಪ್ರಯಾಣವನ್ನು ಮುಂದುವರೆಸಿದಂತೆ, ಸ್ವಯಂ-ಸಮತೋಲನ ಟ್ರೀಗಳಂತಹ ಸುಧಾರಿತ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಮತ್ತು ಅವುಗಳ ವಿವಿಧ ಅನುಷ್ಠಾನಗಳನ್ನು ಅನ್ವೇಷಿಸುವುದು ನಿಮ್ಮ ತಿಳುವಳಿಕೆ ಮತ್ತು ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಮತ್ತಷ್ಟು ಹೆಚ್ಚಿಸುತ್ತದೆ. ಬೈನರಿ ಸರ್ಚ್ ಟ್ರೀಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸುವ ಕಲೆಯನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಲು ವಿವಿಧ ಸನ್ನಿವೇಶಗಳೊಂದಿಗೆ ಅಭ್ಯಾಸ ಮತ್ತು ಪ್ರಯೋಗವನ್ನು ಮುಂದುವರಿಸಿ.