ബൈനറി സെർച്ച് ട്രീകൾ: ജാവാസ്ക്രിപ്റ്റിൽ നടപ്പിലാക്കുന്നതിനുള്ള ഒരു സമഗ്രമായ ഗൈഡ്

കമ്പ്യൂട്ടർ സയൻസിലെ ഒരു അടിസ്ഥാന ഡാറ്റാ സ്ട്രക്ച്ചറാണ് ബൈനറി സെർച്ച് ട്രീകൾ (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;
  }

  // Methods will be added here
}

ഇൻസേർഷൻ (Insertion)

ഒരു പുതിയ നോഡിനെ നൽകിയിട്ടുള്ള കീ ഉപയോഗിച്ച് BST-യിലേക്ക് ചേർക്കാൻ `insert` മെത്തേഡ് ഉപയോഗിക്കുന്നു. ഇൻസേർഷൻ പ്രക്രിയ, പുതിയ നോഡിനെ നിലവിലുള്ള നോഡുകളുമായി താരതമ്യം ചെയ്ത് ശരിയായ സ്ഥാനത്ത് സ്ഥാപിക്കുന്നതിലൂടെ 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);

തിരയൽ (Searching)

നൽകിയിട്ടുള്ള കീ ഉള്ള ഒരു നോഡ് BST-യിൽ ഉണ്ടോ എന്ന് പരിശോധിക്കാൻ `search` മെത്തേഡ് ഉപയോഗിക്കുന്നു. ഇത് കീയെ നിലവിലെ നോഡിന്റെ കീയുമായി താരതമ്യം ചെയ്ത് ഇടത്തോട്ടോ വലത്തോട്ടോ ഉള്ള സബ്ട്രീയിലേക്ക് നീങ്ങി ട്രീയിലൂടെ സഞ്ചരിക്കുന്നു.

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

നീക്കംചെയ്യൽ (Deletion)

നൽകിയിട്ടുള്ള കീ ഉള്ള നോഡിനെ BST-യിൽ നിന്ന് നീക്കം ചെയ്യാൻ `remove` മെത്തേഡ് ഉപയോഗിക്കുന്നു. ഇത് ഏറ്റവും സങ്കീർണ്ണമായ പ്രവർത്തനമാണ്, കാരണം നോഡ് നീക്കം ചെയ്യുമ്പോൾ 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 {
    // key is equal to node.key

    // case 1 - a leaf node
    if (node.left === null && node.right === null) {
      node = null;
      return node;
    }

    // case 2 - node has only 1 child
    if (node.left === null) {
      node = node.right;
      return node;
    } else if (node.right === null) {
      node = node.left;
      return node;
    }

    // case 3 - node has 2 children
    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

ബൈനറി സെർച്ച് ട്രീകളുടെ പ്രായോഗിക ഉപയോഗങ്ങൾ

ബൈനറി സെർച്ച് ട്രീകൾ വിവിധ ആവശ്യങ്ങൾക്കായി ഉപയോഗിക്കുന്നു, അവയിൽ ചിലത് താഴെ നൽകുന്നു:

• ഡാറ്റാബേസുകൾ: ഡാറ്റ ഇൻഡെക്സ് ചെയ്യാനും തിരയാനും. ഉദാഹരണത്തിന്, പല ഡാറ്റാബേസ് സിസ്റ്റങ്ങളും റെക്കോർഡുകൾ കാര്യക്ഷമമായി കണ്ടെത്താൻ ബി-ട്രീകൾ പോലുള്ള 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 {
      // key is equal to node.key

      // case 1 - a leaf node
      if (node.left === null && node.right === null) {
        node = null;
        return node;
      }

      // case 2 - node has only 1 child
      if (node.left === null) {
        node = node.right;
        return node;
      } else if (node.right === null) {
        node = node.left;
        return node;
      }

      // case 3 - node has 2 children
      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);
    }
  }
}

// Example Usage
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-കളെക്കുറിച്ചുള്ള അറിവ് ഏതൊരു പ്രോഗ്രാമർക്കും വിലമതിക്കാനാവാത്ത ഒരു മുതൽക്കൂട്ടാണ്.

കമ്പ്യൂട്ടർ സയൻസിലെ നിങ്ങളുടെ യാത്ര തുടരുമ്പോൾ, സ്വയം-ബാലൻസിംഗ് ട്രീകൾ പോലുള്ള നൂതന ആശയങ്ങളും അവയുടെ വിവിധ നടപ്പാക്കലുകളും പര്യവേക്ഷണം ചെയ്യുന്നത് നിങ്ങളുടെ ധാരണയും കഴിവുകളും കൂടുതൽ മെച്ചപ്പെടുത്തും. ബൈനറി സെർച്ച് ട്രീകൾ ഫലപ്രദമായി ഉപയോഗിക്കുന്നതിൽ വൈദഗ്ദ്ധ്യം നേടുന്നതിന് വ്യത്യസ്ത സാഹചര്യങ്ങളിൽ പരിശീലിക്കുകയും പരീക്ഷിക്കുകയും ചെയ്യുക.