বাইনারি সার্চ ট্রি: জাভাস্ক্রিপ্টে একটি সম্পূর্ণ ইমপ্লিমেন্টেশন গাইড

বাইনারি সার্চ ট্রি (BSTs) কম্পিউটার বিজ্ঞানের একটি মৌলিক ডেটা স্ট্রাকচার, যা ডেটা খোঁজা, সাজানো এবং পুনরুদ্ধারের জন্য ব্যাপকভাবে ব্যবহৃত হয়। এর হায়ারারকিকাল বা স্তরবিন্যাস কাঠামো অনেক অপারেশনে লগারিদমিক টাইম কমপ্লেক্সিটি প্রদান করে, যা এটিকে বড় ডেটাসেট পরিচালনার জন্য একটি শক্তিশালী টুল করে তোলে। এই গাইডটি BST-এর একটি সম্পূর্ণ বিবরণ প্রদান করে এবং জাভাস্ক্রিপ্টে এর ইমপ্লিমেন্টেশন প্রদর্শন করে, যা বিশ্বব্যাপী ডেভেলপারদের জন্য সহায়ক হবে।

বাইনারি সার্চ ট্রি বোঝা

বাইনারি সার্চ ট্রি কী?

বাইনারি সার্চ ট্রি একটি ট্রি-ভিত্তিক ডেটা স্ট্রাকচার যেখানে প্রতিটি নোডের সর্বাধিক দুটি চাইল্ড থাকে, যা বাম চাইল্ড এবং ডান চাইল্ড হিসাবে পরিচিত। একটি BST-এর মূল বৈশিষ্ট্য হলো যে কোনো নির্দিষ্ট নোডের জন্য:

• বাম সাবট্রি-র সমস্ত নোডের কী (key) নোডের কী-এর থেকে কম।
• ডান সাবট্রি-র সমস্ত নোডের কী (key) নোডের কী-এর থেকে বেশি।

এই বৈশিষ্ট্যটি নিশ্চিত করে যে একটি 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));  // আউটপুট: true
console.log(bst.search(2));  // আউটপুট: false

ডিলিশন

`remove` মেথডটি BST থেকে প্রদত্ত কী সহ একটি নোড ডিলিট করে। এটি সবচেয়ে জটিল অপারেশন কারণ নোডটি সরানোর সময় BST-এর বৈশিষ্ট্য বজায় রাখতে হয়। এখানে তিনটি কেস বিবেচনা করতে হবে:

• কেস ১: যে নোডটি ডিলিট করা হবে সেটি একটি লিফ নোড। এটিকে কেবল সরিয়ে ফেলুন।
• কেস ২: যে নোডটি ডিলিট করা হবে তার একটি চাইল্ড আছে। নোডটিকে তার চাইল্ড দিয়ে প্রতিস্থাপন করুন।
• কেস ৩: যে নোডটি ডিলিট করা হবে তার দুটি চাইল্ড আছে। ইন-অর্ডার সাকসেসর (ডান সাবট্রি-র সবচেয়ে ছোট নোড) খুঁজুন, নোডটিকে সাকসেসর দিয়ে প্রতিস্থাপন করুন এবং তারপর সাকসেসরটিকে ডিলিট করুন।

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 {
    // কী নোডের কী-এর সমান

    // কেস ১ - একটি লিফ নোড
    if (node.left === null && node.right === null) {
      node = null;
      return node;
    }

    // কেস ২ - নোডের কেবল ১টি চাইল্ড আছে
    if (node.left === null) {
      node = node.right;
      return node;
    } else if (node.right === null) {
      node = node.left;
      return node;
    }

    // কেস ৩ - নোডের ২টি চাইল্ড আছে
    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)); // আউটপুট: false

ট্রি ট্রাভার্সাল

ট্রি ট্রাভার্সাল হলো একটি নির্দিষ্ট ক্রমে ট্রি-এর প্রতিটি নোড ভিজিট করা। কয়েকটি সাধারণ ট্রাভার্সাল পদ্ধতি রয়েছে:

• ইন-অর্ডার: বাম সাবট্রি, তারপর নোড, তারপর ডান সাবট্রি ভিজিট করে। এর ফলে নোডগুলি আরোহী ক্রমে (ascending order) ভিজিট হয়।
• প্রি-অর্ডার: নোড, তারপর বাম সাবট্রি, তারপর ডান সাবট্রি ভিজিট করে।
• পোস্ট-অর্ডার: বাম সাবট্রি, তারপর ডান সাবট্রি, তারপর নোড ভিজিট করে।

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);   // আউটপুট: 3 5 8 9 10 11 12 13 14 15 18 20 25
bst.preOrderTraverse(printNode);  // আউটপুট: 11 5 3 9 8 10 15 13 12 14 20 18 25
bst.postOrderTraverse(printNode); // আউটপুট: 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); // আউটপুট: 3
console.log(bst.max().key); // আউটপুট: 25

বাইনারি সার্চ ট্রি-এর ব্যবহারিক প্রয়োগ

বাইনারি সার্চ ট্রি বিভিন্ন ধরনের অ্যাপ্লিকেশনে ব্যবহৃত হয়, যার মধ্যে রয়েছে:

• ডাটাবেস: ডেটা ইনডেক্সিং এবং সার্চিং। উদাহরণস্বরূপ, অনেক ডাটাবেস সিস্টেম BST-এর বিভিন্ন সংস্করণ, যেমন B-tree, ব্যবহার করে রেকর্ড দ্রুত খুঁজে বের করার জন্য। বহুজাতিক কর্পোরেশন দ্বারা ব্যবহৃত বিশ্বব্যাপী ডাটাবেসের কথা ভাবুন; সেখানে দক্ষ ডেটা পুনরুদ্ধার অত্যন্ত গুরুত্বপূর্ণ।
• কম্পাইলার: সিম্বল টেবিল, যা ভ্যারিয়েবল এবং ফাংশন সম্পর্কে তথ্য সংরক্ষণ করে।
• অপারেটিং সিস্টেম: প্রসেস শিডিউলিং এবং মেমরি ম্যানেজমেন্ট।
• সার্চ ইঞ্জিন: ওয়েব পেজ ইনডেক্সিং এবং সার্চ ফলাফলের র‍্যাংকিং।
• ফাইল সিস্টেম: ফাইল সংগঠিত করা এবং অ্যাক্সেস করা। বিশ্বব্যাপী ওয়েবসাইট হোস্ট করার জন্য ব্যবহৃত একটি সার্ভারের ফাইল সিস্টেমের কথা কল্পনা করুন; একটি সুসংগঠিত 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 {
      // কী নোডের কী-এর সমান

      // কেস ১ - একটি লিফ নোড
      if (node.left === null && node.right === null) {
        node = null;
        return node;
      }

      // কেস ২ - নোডের কেবল ১টি চাইল্ড আছে
      if (node.left === null) {
        node = node.right;
        return node;
      } else if (node.right === null) {
        node = node.left;
        return node;
      }

      // কেস ৩ - নোডের ২টি চাইল্ড আছে
      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("In-order traversal:");
bst.inOrderTraverse(printNode);

console.log("Pre-order traversal:");
bst.preOrderTraverse(printNode);

console.log("Post-order traversal:");
bst.postOrderTraverse(printNode);

console.log("Minimum value:", bst.min().key);
console.log("Maximum value:", bst.max().key);

console.log("Search for 9:", bst.search(9));
console.log("Search for 2:", bst.search(2));

bst.remove(7);
console.log("Search for 7 after removal:", bst.search(7));

উপসংহার

বাইনারি সার্চ ট্রি একটি শক্তিশালী এবং বহুমুখী ডেটা স্ট্রাকচার যা অসংখ্য অ্যাপ্লিকেশনে ব্যবহৃত হয়। এই গাইডটি BST-এর একটি সম্পূর্ণ বিবরণ প্রদান করেছে, যার মধ্যে রয়েছে এর গঠন, অপারেশন এবং জাভাস্ক্রিপ্টে ইমপ্লিমেন্টেশন। এই গাইডে আলোচিত নীতি এবং কৌশলগুলি বোঝার মাধ্যমে, বিশ্বব্যাপী ডেভেলপাররা সফটওয়্যার ডেভেলপমেন্টে বিস্তৃত সমস্যা সমাধানের জন্য কার্যকরভাবে BST ব্যবহার করতে পারে। বিশ্বব্যাপী ডাটাবেস পরিচালনা থেকে শুরু করে সার্চ অ্যালগরিদম অপ্টিমাইজ করা পর্যন্ত, BST-এর জ্ঞান যেকোনো প্রোগ্রামারের জন্য একটি অমূল্য সম্পদ।

আপনি কম্পিউটার বিজ্ঞানে আপনার যাত্রা চালিয়ে যাওয়ার সাথে সাথে, সেল্ফ-ব্যালেন্সিং ট্রি এবং তাদের বিভিন্ন ইমপ্লিমেন্টেশনের মতো উন্নত ধারণাগুলি অন্বেষণ করলে আপনার বোঝাপড়া এবং ক্ষমতা আরও বাড়বে। বাইনারি সার্চ ট্রি কার্যকরভাবে ব্যবহারের শিল্পে দক্ষতা অর্জনের জন্য বিভিন্ন পরিস্থিতিতে অনুশীলন এবং পরীক্ষা-নিরীক্ষা চালিয়ে যান।