Student info BST

import java.util.*;

class node <T extends Comparable<T>>{
    public T data;
    public node left;
    public node right;
    public node(){
        left = null;
        right = null;
    }
    public node(T data){
        this.data = data;
    }
    public void setLeft(node<T> child){
        this.left = child;
    }
    public void setRight(node<T> child){
        this.right = child;
    }
    public void setData(T data){
        this.data = data;
    }
    public node<T> getLeft(){
        return left;
    }
    public node<T> getRight(){
        return right;
    }
    public T getData(){
        return data;
    }
    public boolean isLeaf(){
        return (getLeft()==null&&getRight()==null);
    }
    public boolean oneChild(){
        return ((getLeft()==null&&getRight()!=null)||(getLeft()!=null&&getRight()==null));
    }
}

public class StudentInfo implements Comparable<StudentInfo> {
    public Integer studentNo;
    public String firstName;
    public String lastName;
    public StudentInfo(){
        studentNo = 0;
        firstName = "";
        lastName = "";
    }
    public StudentInfo(Integer studentNo, String firstName,String lastName){
        this.studentNo = studentNo;
        this.firstName = firstName;
        this.lastName = lastName;
    }
    public int getSN(){
        return studentNo;
    }
    public String getFN(){
        return firstName;
    }
    public String getLN(){
        return lastName;
    }
    @Override
    public int compareTo(StudentInfo t) {
        if(studentNo<t.studentNo)
            return -1;
        else if(studentNo>t.studentNo)
            return 1;
        return 0;
    }
    public void toStr(){
        System.out.println(studentNo+":"+firstName+" "+lastName);
    }
}

class BST<T extends Comparable<T>>{
    Scanner in = new Scanner (System.in);
    private node<T> root;
    private node<T> parent;
    public BST(){
        root = null;
        parent = null;
    }
    public void insert(T data){
        if(root==null){
            root = new node (data);
        }
        else{
            parent = findParent(data);
            node<T> child = new node(data);
            if(child.getData().compareTo(parent.getData()) < 0 && parent.getLeft()==null){
                parent.setLeft(child);
            }
            else if(child.getData().compareTo(parent.getData()) > 0 && parent.getRight()==null){
                parent.setRight(child);
            }
        }
    }
    public node<T> findParent(T data){
        node<T> temp = root;
        node<T> prev = null;
        while(temp!=null){
            prev = temp;
            if(data.compareTo(temp.getData())<0){
                temp = temp.getLeft();
            }
            else if(data.compareTo(temp.getData())>0){
                temp = temp.getRight();
            }
        }
        return prev;
    }
    public node<T> findParent2(T data){
        node<T> temp = root;
        node<T> prev = null;
        while(temp!=null){
            if(temp.isLeaf() || temp.getData() == data){
                return prev;
            }
            prev = temp;
            if(data.compareTo(temp.getData())<0){
                temp = temp.getLeft();
            }
            else if(data.compareTo(temp.getData())>0){
                temp = temp.getRight();
            }
        }
        return prev;
    }
    public node<T> find(T key){
        node<T> n = root;
        while(n!=null){
            if(key.compareTo(n.getData())>0){
                n = n.getRight();
            }
            else if(key.compareTo(n.getData())<0){
                n = n.getLeft();
            }
            else{
                return n;
            }
        }
        return null;
    }
    public node<T> findSmallest(node<T> n){
        if(n.getLeft()==null){
            return n;
        }
        else{
            return findSmallest(n.getLeft());
        }
    }
    public boolean delete(T n){
        if(find(n)==null){
            return false;
        }
        node<T> deleteNode = find(n);
        parent = findParent2(deleteNode.getData());
        if(deleteNode.isLeaf()){
            if(deleteNode==root)
                root = null;
            else if(parent.getLeft()==deleteNode)
                parent.setLeft(null);
            else
                parent.setRight(null);
        }
        else if(deleteNode.oneChild()){
            node<T> child;
            if(deleteNode.getLeft()!=null)
                child = deleteNode.getLeft();
            else
                child = deleteNode.getRight();
            if(deleteNode == root){
                root = child;
            }
            else if(parent.getLeft().getData()==deleteNode.getData()){
                parent.setLeft(child);
            }
            else{
                parent.setRight(child);
            }
        }
        else{
            node<T> sub = findSmallest(deleteNode.getRight());
            node<T> p = findParent2(sub.getData());
            deleteNode.setData(sub.getData());
            if(p.getLeft().getData()==sub.getData())
                if(sub.oneChild())
                    p.setLeft(sub.getRight());
                else
                    p.setLeft(null);
            else
                if(sub.oneChild())
                    p.setRight(sub.getRight());
                else
                    p.setRight(null);
        }
        return true;
    }
    public void inorderTraverse(node<T> current){
        if(current != null){
            inorderTraverse(current.getLeft());
            System.out.print(current.getData()+" ");
            inorderTraverse(current.getRight());
        }
    }
    public void preorderTraverse(node<T> current){
        if(current != null){
            System.out.print(current.getData()+" ");
            preorderTraverse(current.getLeft());
            preorderTraverse(current.getRight());
        }
    }
    public void postorderTraverse(node<T> current){
        if(current != null){
            postorderTraverse(current.getLeft());
            postorderTraverse(current.getRight());
            System.out.print(current.getData()+" ");
        }
    }
    public void level(node<T> current){
        Queue<node> q = new LinkedList<>();
        q.add(current);
        while(!q.isEmpty()){
            node<T> temp = q.remove();
            System.out.print(temp.getData()+" ");
            if(temp.getLeft()!=null && temp.getRight()!=null){
                q.add(temp.getLeft());
                q.add(temp.getRight());
            }
            else if(temp.getLeft()!=null){
                q.add(temp.getLeft());
            }
            else if(temp.getRight()!=null){
                q.add(temp.getRight());
            }
        }
    }
    public void s_order_traverse(node<T> current){
        Queue<node<T>> q = new LinkedList<>();
        q.add(current);
        int level = 1;
        while(!q.isEmpty()){
            int a = 0;
            int b = q.size();
            while(a < b){
                node<T> temp = q.remove();
                System.out.print(temp.getData()+" ");
                if(level%2==0 || level==1){
                    if(temp.getLeft()!=null){
                        q.add(temp.getLeft());
                    }
                    if(temp.getRight()!=null){
                        q.add(temp.getRight());
                    }
                }
                else{
                    if(temp.getRight()!=null){
                        q.add(temp.getRight());
                    }
                    if(temp.getLeft()!=null){
                        q.add(temp.getLeft());
                    }
                }
                a++;
            }
            if(level!=1)
                reverseQ(q);
            level++;
        }
    }
    public void reverseQ(Queue<node<T>> q){
        Stack<node<T>> st = new Stack<>();
        while (!q.isEmpty()) {
            st.add(q.peek());
            q.remove();
        }
        while (!st.isEmpty()) {
            q.add(st.peek());
            st.pop();
        }
    }
    public void createTree(BST list){
        int[] stNo = new int[]{12,18,15,11,17,10,13,16,19,14};
        String[] FN = new String[]{"a","b","c","d","e","f","g","h","i","j"};
        String[] LN = new String[]{"a","b","c","d","e","f","g","h","i","j"};
        for(int i=0;i<stNo.length;i++){
            StudentInfo info = new StudentInfo(stNo[i],FN[i],LN[i]);
            list.insert(info);
        }
        list.inorderTraverse(root);
    }
    public static void main(String[]args){
        BST<StudentInfo> list = new BST<>();
        list.createTree(list);
    }
}