二叉搜索树中的插入方法

Question

when I insert nodes into the binary tree and go test it out in the main by printing it in order the output is always wrong I have tried other solutions but it just keeps getting into bigger problems and in the output, it will be displayed in the wrong order I check the display its perfect but the problem is with the insert method (insert method insert non repeated keys).

class BSTNode<T> {
    public int key;
    public T data;
    public BSTNode<T> left, right;

    
    public BSTNode(int k, T val) {
        key = k;
        data = val;
        left = right = null;
    }

    public BSTNode(int k, T val, BSTNode<T> l, BSTNode<T> r) {
        key = k;
        data = val;
        left = l;
        right = r;
    }
}

public class BST<T> {
    BSTNode<T> root, current;

    public BST() {
        root = current = null;
    }

    public boolean empty() {
        return root == null;
    }

    public boolean full() {
        return false;
    }

    public T retrieve() {
        return current.data;
    }

    public boolean findkey(int tkey) {
        BSTNode<T> p = root, q = root;

        if (empty())
            return false;
        int nb = 0;
        while (p != null) {
            q = p;
            nb++;
            if (p.key == tkey) {
                current = p;
                return true;
            } else if (tkey < p.key)
                p = p.left;
            else
                p = p.right;
        }

        current = q;
        return false;
    }
    
    public boolean insert(int key, T val) {
        BSTNode<T> p = current, q = current;

        while (p != null) {
            q = p;
            if (p.key == key) {
                return false;
            } else if (key < p.key)
                p = p.left;
            else
                p = p.right;
        }

        p = new BSTNode<T>(key, val);
        if (empty()) {
            root = current = p;
            return true;
        } else {
            // current is pointing to parent of the new key
            if (key < current.key)
                current.left = p;
            else
                current.right = p;
            current = p;
            return true;
        }
    }

    public void display() {
        if (root == null)
            System.out.println("BST IS EMPTY");
        else
            displayin(root);
        System.out.println();
    }

    private void displayin(BSTNode<T> p) {
        if (p != null) {
            displayin(p.left);
            System.out.print(p.key + " " + p.data + " ,  ");
            displayin(p.right);
        }
    }
}

Answer 1

In your insert method, the first code part:

        while (p != null) {
            q = p;
            if (p.key == key) {
                current = p;
                return true;
            } else if (key < p.key)
                p = p.left;
            else
                p = p.right;
        }

simply returns true when the key you want to write to is found. It does however not insert val here at all. You could have detected this by calling the insert method on some tree and then printing that tree, comparing the outcome that you had expected with the actual outcome. In automated form, you could do this with JUnit tests.

Answer 2

I think I know want you want (now). I have changed the "display"-Method to toString, rewrote insert and implemented a form of bfs for toString.

import java.util.ArrayList;

class BSTNode<T> {

    public int key;
    public T data;
    public BSTNode<T> left, right;

    public BSTNode(int k, T val) {
        key = k;
        data = val;
        left = right = null;
    }

    public BSTNode(int k, T val, BSTNode<T> l, BSTNode<T> r) {
        key = k;
        data = val;
        left = l;
        right = r;
    }

    @Override
    public String toString() {
        return "[" + key + ":" + data + "]";
    }
}

public class BST<T> {

    BSTNode<T> root, current;

    public BST() {
        root = current = null;
    }

    public boolean empty() {
        return root == null;
    }

    public T retrieve() {
        return current.data;
    }

    public boolean findkey(int tkey) {
        BSTNode<T> current = root;
        while (current != null) {
            if (current.key == tkey)
                return true;
            if (tkey < current.key)
                current = current.left;
            else
                current = current.right;
        }
        return false;
    }
    
    public boolean insert(int key, T val) {
        BSTNode<T> node = new BSTNode<>(key, val);
        if (root == null) {
            root = node;
        } else {
            BSTNode<T> current = root;
            while (current != null) {
                if (key == current.key)
                    return false;
                if (key < current.key) {
                    if (current.left == null) {
                        current.left = node;
                        return true;
                    }
                    current = current.left;
                } else {
                    if (current.right == null) {
                        current.right = node;
                        return true;
                    }
                    current = current.right;
                }
            }
        }
        return false;
    }

    public String toString() {
        if (root == null)
            return "BST IS EMPTY";
        ArrayList<BSTNode<T>> visited = new ArrayList<>();
        ArrayList<BSTNode<T>> queue = new ArrayList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            BSTNode<T> vertex = queue.remove(0);
            if (vertex != null) {
                queue.add(vertex.left);
                queue.add(vertex.right);
            }
            visited.add(vertex);
        }
        return visited.toString();
    }
}