answer:class TreeNode: def __init__(self, key): self.left = None self.right = None self.val = key class BinarySearchTree: def __init__(self): self.root = None def insert(self, key): if self.root is None: self.root = TreeNode(key) else: self._insert_rec(self.root, key) def _insert_rec(self, node, key): if key < node.val: if node.left is None: node.left = TreeNode(key) else: self._insert_rec(node.left, key) else: if node.right is None: node.right = TreeNode(key) else: self._insert_rec(node.right, key) def search(self, key): return self._search_rec(self.root, key) def _search_rec(self, node, key): if node is None or node.val == key: return node if key < node.val: return self._search_rec(node.left, key) return self._search_rec(node.right, key) def delete(self, key): self.root = self._delete_rec(self.root, key) def _delete_rec(self, node, key): if node is None: return node if key < node.val: node.left = self._delete_rec(node.left, key) elif key > node.val: node.right = self._delete_rec(node.right, key) else: if node.left is None: return node.right elif node.right is None: return node.left temp = self._min_value_node(node.right) node.val = temp.val node.right = self._delete_rec(node.right, temp.val) return node def _min_value_node(self, node): current = node while current.left is not None: current = current.left return current def in_order_traversal(self): result = [] self._in_order_rec(self.root, result) return result def _in_order_rec(self, node, result): if node: self._in_order_rec(node.left, result) result.append(node.val) self._in_order_rec(node.right, result)

answer:class ListNode: def __init__(self, value=0, next=None): self.value = value self.next = next def has_cycle(head): Detects if there's a cycle in a linked list using Floyd's Tortoise and Hare algorithm. Returns True if a cycle is detected, otherwise False. if not head or not head.next: return False slow = head fast = head.next while slow != fast: if not fast or not fast.next: return False slow = slow.next fast = fast.next.next return True

answer:def generate_fibonacci(n): Generates the first n Fibonacci numbers. if n <= 0: return [] if n == 1: return [0] fib_sequence = [0, 1] while len(fib_sequence) < n: fib_sequence.append(fib_sequence[-1] + fib_sequence[-2]) return fib_sequence # Generate the first 10 Fibonacci numbers first_10_fibonacci = generate_fibonacci(10) print(first_10_fibonacci)

answer:from math import factorial from collections import Counter def distinct_permutations_count(s): Returns the total number of distinct permutations of a given string `s`. # Count the frequency of each character in the string freq = Counter(s) # Calculate the denominator product of factorials of the frequencies denominator = 1 for count in freq.values(): denominator *= factorial(count) # Calculate the number of distinct permutations return factorial(len(s)) // denominator