Untitled

package de.s3lection.teamspeak.chatgpt;

import java.util.ArrayList;
import java.util.List;

public class BinaryIntTree {
    private Node root;

    public BinaryIntTree() {
        root = null;
    }

    public boolean insertValue(int value) {
        if (root == null) {
            root = new Node(value);
            return true;
        }

        return insertNode(root, value);
    }

    private boolean insertNode(Node node, int value) {
        if (value == node.value) {
            return false;
        }

        if (value < node.value) {
            if (node.leftChild == null) {
                node.leftChild = new Node(value);
                return true;
            } else {
                return insertNode(node.leftChild, value);
            }
        } else {
            if (node.rightChild == null) {
                node.rightChild = new Node(value);
                return true;
            } else {
                return insertNode(node.rightChild, value);
            }
        }
    }

    public boolean containsValue(int value) {
        return searchValue(root, value);
    }

    private boolean searchValue(Node node, int value) {
        if (node == null) {
            return false;
        }

        if (value == node.value) {
            return true;
        } else if (value < node.value) {
            return searchValue(node.leftChild, value);
        } else {
            return searchValue(node.rightChild, value);
        }
    }

    public int getNodeCount() {
        return getNodeCount(root);
    }

    private int getNodeCount(Node node) {
        if (node == null) {
            return 0;
        }

        return 1 + getNodeCount(node.leftChild) + getNodeCount(node.rightChild);
    }

    public int[] toIntArray() {
        List<Integer> list = new ArrayList<>();
        inOrderTraversal(root, list);

        int[] result = new int[list.size()];
        for (int i = 0; i < list.size(); i++) {
            result[i] = list.get(i);
        }

        return result;
    }

    private void inOrderTraversal(Node node, List<Integer> list) {
        if (node == null) {
            return;
        }

        inOrderTraversal(node.leftChild, list);
        list.add(node.value);
        inOrderTraversal(node.rightChild, list);
    }

    public boolean isPerfect(){
        int treeHeight = getHeight(root);
        return isPerfect(root, 0, treeHeight);
    }

    private boolean isPerfect(Node node, int level, int treeHeight){
        if(node == null) return true;

        if(node.leftChild == null && node.rightChild == null){
            return level == treeHeight -1;
        }

        if(node.leftChild == null || node.rightChild == null) return false;

        return isPerfect(node.leftChild, level + 1, treeHeight) && isPerfect(node.rightChild, level + 1, treeHeight);
    }

    public boolean isFull(){
        return isFull(root);
    }

    private boolean isFull(Node node){
        if(node == null) return true;

        if((node.leftChild == null && node.rightChild != null) || (node.leftChild != null && node.rightChild == null)) return false;

        return isFull(node.leftChild) && isFull(node.rightChild);
    }


    private int getHeight(Node node){
        if(node == null) return 0;

        int leftHeight = getHeight(node.leftChild);
        int rightHeight = getHeight(node.rightChild);

        return Math.max(leftHeight, rightHeight) + 1;
    }

    private class Node {
        int value;
        Node leftChild;
        Node rightChild;

        Node(int value) {
            this.value = value;
            leftChild = null;
            rightChild = null;
        }
    }
}