A **binary tree** is a hierarchical **data structure** in which each **node** has a **value** (in this case, it is also a key) and **links** to the **left** and **right** **children**. The **node** that is at the topmost level (which is not someone else's child) is called the **root**. **Nodes** that have no children are called **leaves**.

A **binary search tree** is a **binary tree** with additional properties: the value of the **left** child is **less** than the value of the parent, and the value of the **right** child is **greater** than the value of the parent for each tree **node**. That is, the data in the binary search tree is stored sorted. Each time you **add** a new or **remove** an existing node, the sorted order of the tree is preserved. When **searching** for an element, the search value is compared with the root. If the desired is **greater** than the root, then the search continues in the **right** child of the root, if **less**, then in the **left**, if **equal**, then the value is **found** and the search stops.

Your task is to implement the class `BinarySearchTree`.

Each instance of `BinarySearchTree` must have following methods:

* `root` — return **root node** of the tree

* `add(data)` — add **node** with `data` to the tree

* `has(data)` — returns `true` if **node** with the `data` exists in the tree and `false` otherwise

* `find(data)` — returns **node** with the `data` if **node** with the `data` exists in the tree and `null` otherwise

* `remove(data)` — removes **node** with the `data` from the tree if **node** with the `data` exists

* `min` — returns **minimal** **value** stored in the tree (or `null` if tree has no **nodes**)

* `max` — returns **maximal** **value** stored in the tree (or `null` if tree has no **nodes**)

For example:

`tree.root().data` => `1;`

`tree.min()` => `1`

`tree.max()` => `5`

`tree.has(5)` => `false`

`tree.max()` => `4`

Write your code in `src/binary-search-tree.js`.

Given a **singly linked list** of integers `l` and an integer `k`, remove all elements from list `l` that have a value equal to `k`.

For example, for `l` = `[3, 1, 2, 3, 4, 5]` and `k` = `3`,

the output should be `[1, 2, 4, 5]`

**Singly linked lists** are already defined with this interface

function ListNode(x) {

this.value = x;

this.next = null;

}

Write your code in `src/st-remove-from-list.js`.

Implement the **Stack** with a given interface via **array**.

For example:

const stack = new Stack();

stack.push(1); // adds the element to the stack

stack.peek(); // returns the peek, but doesn't delete it, returns 1

stack.pop(); // returns the top element from stack and deletes it, returns 1

stack.pop(); // undefined

Write your code in `src/st-stack.js`.

Implement the **Queue** with a given interface via **linked list** (use `ListNode` extension).

Each instance of queue must have 3 methods:

* `enqueue(value)` — puts the `value` at the end of the **queue**

* `deque` — retrieves a value from the head of the **queue** and deletes it

* `getUnderlyingList` - returns underlying **linked list**

For example:

const queue = new Queue();

queue.enqueue(1); // adds the element to the queue

queue.enqueue(3); // adds the element to the queue

queue.dequeue(); // returns the top element from queue and deletes it, returns 1

queue.getUnderlyingList() // returns { value: 3, next: null }

Write your code in `src/st-queue.js`.


**Бинарное дерево** — это иерархическая **структура данных**, в которой каждый **узел** имеет **значение** (оно же является в данном случае и ключом) и **ссылки** на **левого** и **правого** **потомка**. **Узел**, находящийся на самом верхнем уровне (не являющийся чьим либо потомком) называется **корнем**. **Узлы**, не имеющие потомков, называются **листьями**.

**Бинарное дерево поиска** — это **бинарное дерево**, обладающее дополнительными свойствами: значение **левого** потомка **меньше** значения родителя, а значение **правого** потомка **больше** значения родителя для каждого **узла** дерева. То есть, данные в бинарном дереве поиска хранятся в отсортированном виде. При каждой операции **вставки** нового или **удаления** существующего узла отсортированный порядок дерева сохраняется. При **поиске** элемента сравнивается искомое значение с корнем. Если искомое **больше** корня, то поиск продолжается в **правом** потомке корня, если **меньше**, то в **левом**, если **равно**, то значение **найдено** и поиск прекращается.

Ваша задача — реализовать класс `BinarySearchTree`.

Каждый экземпляр `BinarySearchTree` должен обладать следующими методами:

* `root` — возвращает **корневой узел** дерева

* `add(data)` — добавляет **узел** с `data` к дереву

* `has(data)` — возвращает `true`, если **узел** с `data` имеется в дереве и `false`, если нет

* `find(data)` — возвращает **узел** с `data`, если **узел** с `data` имеется в дереве и `null`, если нет

* `remove(data)` — удаляет **узел** с `data` из дерева, если **узел** с `data` имеется в дереве

* `min` — возвращает **минимальное** **значение**, хранящееся в дереве (или `null`, если у дерева нет **узлов**)

* `max` — возвращает **максимальное** **значение**, хранящееся в дереве (или `null`, если у дерева нет **узлов**)

Например:

`tree.root().data` => `1;`

`tree.min()` => `1`

`tree.max()` => `5`

`tree.has(5)` => `false`

`tree.max()` => `4`

Напишите свой код в `src/binary-search-tree.js`.

Дан **односвязный связный список** целых чисел (`l`) и целое число (`k`), удалите все элементы из списка `l`, содержащие значение `k`.

Например, для `l` = `[3, 1, 2, 3, 4, 5]` и `k` = `3`,

результат будет `[1, 2, 4, 5]`

Узлы односвязного связного списка определяются интерфейсом:

function ListNode(x) {

this.value = x;

this.next = null;

}

Напишите свой код в `src/st-remove-from-list.js`.

Реализуйте **стек** с заданным интерфейсом на основе **массива**.

Например:

const stack = new Stack();

stack.push(1); // добавляет элемент в стек

stack.peek(); // возвращает верхний элемент, но не удаляет его, возвращает 1

stack.pop(); // возвращает верхний элемент и удаляет его, возвращает 1

stack.pop(); // undefined

Напишите свой код в `src/st-stack.js`.

Реализуйте **очередь** с заданным интерфейсом на основе **связного списка** (используйте `ListNode`, расположенный в папке `extensions`).

Каждый экземпляр очереди должен иметь 3 метода:

* `enqueue(value)` — помещает `value` в конец **очереди**

* `deque` — извлекает значение с начала **очереди** и удаляет его

* `getUnderlyingList` - возвращает **связный список**, лежащий в основе данной **очереди**

Например:

const queue = new Queue();

queue.enqueue(1); // добавляет элемент в очередь

queue.enqueue(3); // добавляет элемент в очередь

queue.dequeue(); // возвращает элемент из начала очереди и удаляет его, возвращает 1

queue.getUnderlyingList() // возвращает { value: 3, next: null }

import { ListNode } from './list-node.js';

ListNode