Деревья(бинарные)

import java.util.List;
import java.util.LinkedList;
 
public class SimpleThree<T extends Comparable<T>> {
    private class Node {
        final T value;
        Node left;
        Node right;
 
        public Node(T val) {
            value = val;
            left = null;
            right = null;
        }
    }
 
    private Node root;
 
    private Node appendNode(Node rootNode, T val) {
        if ( rootNode == null )
            return new Node(val);
        else {
            int cmp = rootNode.value.compareTo(val);
            if ( cmp > 0 )
                rootNode.left = appendNode(rootNode.left, val);
            else if ( cmp < 0 )
                rootNode.right = appendNode(rootNode.right, val);
        }
        return rootNode;
    }
 
    private void nodesToList(List<T> list, Node rootNode) {
        if ( rootNode != null ) {
            nodesToList(list, rootNode.left);
            list.add(rootNode.value);
            nodesToList(list, rootNode.right);
        }
    }
 
    public SimpleThree() {
        root = null;
    }
 
    public boolean isEmpty() {
        return root == null;
    }
 
    public void append(T val) {
        root = appendNode(root, val);
    }
 
    public List<T> toList() {
        List<T> list = new LinkedList<>();
        nodesToList(list, root);
        return list;
    }
 
    public static void main(String[] args) {
        SimpleThree<Integer> three = new SimpleThree<>();
        three.append(5);
        three.append(1);
        three.append(4);
        three.append(2);
        three.append(3);
 
        for ( int i: three.toList() )
            System.out.println(i);
    }
}

import java.util.List;
import java.util.LinkedList;
 
//из прочитанной мной информации постораюсь прочитать код
//и хотел бы ваши коментарии.
 
public class SimpleThree<T extends Comparable<T>> {
    
    private class Node { 
        final T value;      //эта переменная должна быть корнем
        Node left;          //левый узел
        Node right;         //правый узел
 
        public Node(T val) {        //конструктор класса
            value = val;
            left = null;
            right = null;
        }
    }
 
    private Node root;  //правильно я понял что это абстрактный метод который
                        //запускает класс Node с корня
 
    private Node appendNode(Node rootNode, T val) {
        if ( rootNode == null )     //если следующее значение нулевое создаем узел
            return new Node(val);   
        else {
            int cmp = rootNode.value.compareTo(val);
            if ( cmp > 0 )          //если значение больше 0 создаем узел с левой стороны
                rootNode.left = appendNode(rootNode.left, val);
            else if ( cmp < 0 )     //если значение меньше 0 создаем узел с правой стороны
                rootNode.right = appendNode(rootNode.right, val);
        }
        return rootNode;
    }
 
    private void nodesToList(List<T> list, Node rootNode) { //в этом еще не разбирался.
        if ( rootNode != null ) {
            nodesToList(list, rootNode.left);
            list.add(rootNode.value);
            nodesToList(list, rootNode.right);
        }
    }
    //с этим тое еще нужно разбираться
    public SimpleThree() {
        root = null;
    }
 
    public boolean isEmpty() {
        return root == null;
    }
 
    public void append(T val) {
        root = appendNode(root, val);
    }
 
    public List<T> toList() {
        List<T> list = new LinkedList<>();
        nodesToList(list, root);
        return list;
    }
 
    public static void main(String[] args) {
        //правильно ли я понимаю то, что тут создается объект SimpleThree и вызывается метод append
        SimpleThree<Integer> three = new SimpleThree<>();
        three.append(5);
        three.append(1);
        three.append(4);
        three.append(2);
        three.append(3);
 
        for ( int i: three.toList() ) //тут печатается уже отсортированное дерево?
            System.out.println(i);
    }
}

import java.util.List;
import java.util.LinkedList;
 
// дженерик-класс Дерево параметром принимает класс, имплементирующий
// интерфейс Comparable, его объекты должны сравниваться друг с другом 
public class SimpleThree<T extends Comparable<T>> {
    // скрытый внутренний класс Узел
    // пользователей класса Дерево не должно волновать, как именно
    // внутри хранятся данные
    private class Node {
        // ссылка на значение, хранящееся в узле
        // значение не должно меняться, поэтому ссылка объявлена, как final
        // инициализируется при создании узла и такой и остаётся
        final T value;
        // ссылка на левый потомок
        Node left;
        // ссылка на правый потомок
        Node right;
 
        // конструктор узла параметром принимает ссылку на значение
        public Node(T val) {
            value = val;
            // при создании узла у него нет потомков, ссылки на них
            // инициализируются значением null
            left = null;
            right = null;
        }
    }
 
    // ссылка на корневой узел дерева
    private Node root;
 
    // скрытая функция для вставки узла в дерево (имя rootNode не слишком удачное и может
    // сбивать с толка), но в любом случае принимает параметрами ссылку на корневой узел
    // и на вставляемое значение
    private Node appendNode(Node rootNode, T val) {
        // если узел, переданный параметром, пуст (отсутствует),
        // создаётся новый узел с переданным значением и ссылка на него возвращается
        if ( rootNode == null )
            return new Node(val);
        // если узел не пустой
        else {
            // его значение сравнивается со значением, переданным параметром
            int cmp = rootNode.value.compareTo(val);
            // если переданное значение меньше
            if ( cmp > 0 )
                // функция рекурсивно вызывается для левого потомка
                rootNode.left = appendNode(rootNode.left, val);
            // если больше
            else if ( cmp < 0 )
                // для правого
                rootNode.right = appendNode(rootNode.right, val);
        }
        // и в любом случае возвращается ссылка на переданный параметром узел
        // такой подход обретает смысл, когда дерево делается балансируемым
        // при вставке нового узла корневой узел может меняться
        return rootNode;
    }
 
    // скрытая функция, рекурсивно добавляющая в переданный параметром список
    // значения, хранящиеся в узлах дерева
    private void nodesToList(List<T> list, Node rootNode) {
        // если узел не пуст, функция вызывается для его левого потомка,
        // потом в список добавляется значение, хранящееся в узле,
        // после чего функция вызывается для правого потомка
        // таким образом значения в списке упорядочены
        if ( rootNode != null ) {
            nodesToList(list, rootNode.left);
            list.add(rootNode.value);
            nodesToList(list, rootNode.right);
        }
    }
 
    // конструктор класса Дерево
    // изначально дерево пустое, корень инициализируется
    // значением null
    public SimpleThree() {
        root = null;
    }
 
    // функция, возвращающая TRUE, если дерево пустое
    // в примере не используется, написал по привычке,
    // в принципе должна присутствовать
    public boolean isEmpty() {
        return root == null;
    }
 
    // пользовательская функция, добавляющая значение в дерево
    public void append(T val) {
        root = appendNode(root, val);
    }
 
    // пользовательская функция, возвращающая список со значениями,
    // хранящимися в дереве
    public List<T> toList() {
        List<T> list = new LinkedList<>();
        nodesToList(list, root);
        return list;
    }
 
    public static void main(String[] args) {
        // создаём экземпляр дерева
        SimpleThree<Integer> three = new SimpleThree<>();
        // вставляем в него какие-то значения
        three.append(5);
        three.append(1);
        three.append(4);
        three.append(2);
        three.append(3);
 
        // в цикле выводим значения, полученные из дерева
        // в виде списка, убеждаемся, что они выводятся отсортированными
        for ( int i: three.toList() )
            System.out.println(i);
    }
}