Java 我调用一个方法，它会给我一个错误

我的源代码：

import java.util.*;

public class Arvore {

    public Arvore() {
        root = null;
    }

    public void inserir(String x) {
        root = insert(x, root);
    }

    public void remove(String x) {
        root = remove(x, root);
    }

    private No remove(String x, No t) {
        if (t == null) {
            return t;
        }

        int comp = x.compareTo(t.str);

        if (comp < 0) {
            t.left = remove(x, t.left);
        } else if (comp > 0) {
            t.right = remove(x, t.right);
        } else if (t.left != null && t.right != null) {
            t.str = findMin(t.right).str;
            t.right = remove(t.str, t.right);
        } else {
            t = (t.left != null) ? t.left : t.right;
        }
        return balance(t);
    }

    public String findMin() {
        return findMin(root).str;
    }

    public String findMax() {
        return findMax(root).str;
    }

    public boolean contains(String x) {
        return contains(x, root);
    }

    public void makeEmpty() {
        root = null;
    }

    public boolean isEmpty() {
        return root == null;
    }
    private static final int maxBal = 1;

    private No balance(No t) {
        if (t == null) {
            return t;
        }

        if (height(t.left) - height(t.right) > maxBal) {
            if (height(t.left.left) >= height(t.left.right)) {
                t = rotateWithLeftChild(t);
            } else {
                t = doubleWithLeftChild(t);
            }
        } else if (height(t.right) - height(t.left) > maxBal) {
            if (height(t.right.right) >= height(t.right.left)) {
                t = rotateWithRightChild(t);
            } else {
                t = doubleWithRightChild(t);
            }
        }

        t.height = Math.max(height(t.left), height(t.right)) + 1;
        return t;
    }

    public void checkBalance() {
        checkBalance(root);
    }

    private int checkBalance(No t) {
        if (t == null) {
            return -1;
        }

        if (t != null) {
            int hl = checkBalance(t.left);
            int hr = checkBalance(t.right);
            if (Math.abs(height(t.left) - height(t.right)) > 1
                    || height(t.left) != hl || height(t.right) != hr) {
                System.out.println("OOPS!!");
            }
        }

        return height(t);
    }

    private No insert(String x, No t) {
        if (t == null) {
            return new No(x, null, null);
        }

        int comp = x.compareTo(t.str);

        if (comp < 0) {
            t.left = insert(x, t.left);
        } else if (comp > 0) {
            t.right = insert(x, t.right);
        } else
            ;

        t.occ+=1;

        return balance(t);
    }

    private No findMin(No t) {
        if (t == null) {
            return t;
        }

        while (t.left != null) {
            t = t.left;
        }
        return t;
    }

    private No findMax(No t) {
        if (t == null) {
            return t;
        }

        while (t.right != null) {
            t = t.right;
        }
        return t;
    }

    private boolean contains(String x, No t) {
        while (t != null) {
            int comp = x.compareTo(t.str);

            if (comp < 0) {
                t = t.left;
            } else if (comp > 0) {
                t = t.right;
            } else {
                return true;
            }
        }

        return false;
    }

    private void printTree(No t) {
        if (t != null) {
            printTree(t.left);
            System.out.println(t.str + ": " + t.occ);
            printTree(t.right);
        }
    }

    private int height(No t) {
        return t == null ? -1 : t.height;
    }

    private No rotateWithLeftChild(No k2) {
        No k1 = k2.left;
        k2.left = k1.right;
        k1.right = k2;
        k2.height = Math.max(height(k2.left), height(k2.right)) + 1;
        k1.height = Math.max(height(k1.left), k2.height) + 1;
        return k1;
    }

    private No rotateWithRightChild(No k1) {
        No k2 = k1.right;
        k1.right = k2.left;
        k2.left = k1;
        k1.height = Math.max(height(k1.left), height(k1.right)) + 1;
        k2.height = Math.max(height(k2.right), k1.height) + 1;
        return k2;
    }

    private No doubleWithLeftChild(No k3) {
        k3.left = rotateWithRightChild(k3.left);
        return rotateWithLeftChild(k3);
    }

    private No doubleWithRightChild(No k1) {
        k1.right = rotateWithLeftChild(k1.right);
        return rotateWithRightChild(k1);
    }


    private class No {

        No(String tStr) {
            this(tStr, null, null);
        }

        No(String tStr, No lt, No rt) {
            str = tStr;
            left = lt;
            right = rt;
            height = 0;
            occ = 1;
        }
        String str;
        No left;
        No right;
        int height;
        int occ = 0;
    }
    private No root;

    public static void main(String[] args) {
        Arvore t = new Arvore();
        System.out.println("AVL TREE TEST\n");
        String msg;
        String[] inputs;
        Scanner sc = new Scanner(System.in);
        ArrayList palavras = new ArrayList();
        int i = 0;

        while (true) {
            msg = sc.nextLine();
            if (msg.equals("")) {
                break;
            }


            inputs = msg.split(" ");

            i = 0;

            while (i < inputs.length) {
                palavras.add(inputs[i]);
            }

        }

        i = 0;
        while (i < palavras.size()) {
            if (palavras.get(i).equals("REMOVE")) {
                palavras.remove(palavras.get(i));
                palavras.remove(palavras.get(i + 1));
                i += 2;
            } else {
                t.insert(palavras.get(i));
            }
            i++;
        }




    t.printTree();
    }
}

import java.util.*；
公营飞机{
公共Arvore（）{
root=null；
}
公共void inserir（字符串x）{
根=插入（x，根）；
}
公共无效删除（字符串x）{
根=移除（x，根）；
}
私有不删除（字符串x，不删除t）{
如果（t==null）{
返回t；
}
int comp=x.compareTo（t.str）；
if（comp<0）{
t、 左=移除（x，t.左）；
}否则如果（补偿>0）{
t、 右=移除（x，t.右）；
}else if（t.left！=null和&t.right！=null）{
t、 str=findMin（t.right）.str；
t、 右=移除（t.str，t.right）；
}否则{
t=（t.left！=null）？t.left:t.right；
}
收益余额（t）；
}
公共字符串findMin（）{
返回findMin（root）.str；
}
公共字符串findMax（）{
返回findMax（root）.str；
}
公共布尔包含（字符串x）{
返回包含（x，根）；
}
公共void makeEmpty（）{
root=null；
}
公共布尔值为空（）{
返回root==null；
}
专用静态最终int maxBal=1；
私人无余额（无t）{
如果（t==null）{
返回t；
}
if（高度（t.左）-高度（t.右）>最大平衡）{
如果（高度（t.左.左）>=高度（t.左.右））{
t=旋转的第1个孩子（t）；
}否则{
t=带leftchild的double（t）；
}
}否则，如果（高度（t.右侧）-高度（t.左侧）>最大值）{
如果（高度（t.右.右）>=高度（t.右.左））{
t=旋转第三个孩子（t）；
}否则{
t=带右子代的双（t）；
}
}
t、 高度=数学最大值（高度（t左），高度（t右））+1；
返回t；
}
公共无效支票余额（）{
支票余额（根）；
}
私人整数支票余额（无t）{
如果（t==null）{
返回-1；
}
如果（t！=null）{
int hl=支票余额（t.左）；
int hr=支票余额（t.右）；
如果（数学绝对值（高度（t.左）-高度（t.右））>1
||高度（t.左）！=hl |高度（t.右）！=hr）{
System.out.println（“OOPS！！”）；
}
}
返回高度（t）；
}
私有无插入（字符串x，无t）{
如果（t==null）{
返回新编号（x，空，空）；
}
int comp=x.compareTo（t.str）；
if（comp<0）{
t、 左=插入（x，t.左）；
}否则如果（补偿>0）{
t、 右=插入（x，t.右）；
}否则
;
t、 occ+=1；
收益余额（t）；
}
私有无findMin（无t）{
如果（t==null）{
返回t；
}
while（t.left！=null）{
t=t左；
}
返回t；
}
私有无findMax（无t）{
如果（t==null）{
返回t；
}
while（t.right！=null）{
t=t右；
}
返回t；
}
私有布尔包含（字符串x，无t）{
while（t！=null）{
int comp=x.compareTo（t.str）；
if（comp<0）{
t=t左；
}否则如果（补偿>0）{
t=t右；
}否则{
返回true；
}
}
返回false；
}
私有void打印树（无t）{
如果（t！=null）{
printree（t.left）；
系统输出打印项次（t.str+“：”+t.occ）；
printree（t.right）；
}
}
私人内部高度（无t）{
返回t==null？-1:t高度；
}
私人无轮换儿童（无k2）{
否k1=k2。左侧；
k2.左=k1.右；
k1.right=k2；
k2.高度=数学最大值（高度（k2.左）、高度（k2.右））+1；
k1.高度=数学最大值（高度（k1.左侧），k2.高度）+1；
返回k1；
}
私人无轮换第三名儿童（无k1）{
否k2=k1。右侧；
k1.右=k2.左；
k2.left=k1；
k1.高度=数学最大值（高度（k1.左）、高度（k1.右））+1；
k2.高度=数学最大值（高度（k2.右侧），k1.高度）+1；
返回k2；
}
private No doubleWithLeftChild（No k3）{
k3.左=第三个旋转儿童（k3.左）；
返回旋转的第三个孩子（k3）；
}
private No doubleWithRightChild（No k1）{
k1.right=旋转到第四个孩子（k1.right）；
返回第三个孩子（k1）；
}
私人舱号{
否（字符串tStr）{
这（tStr，null，null）；
}
否（字符串tStr、无lt、无rt）{
str=tStr；
左=左；
右=rt；
高度=0；
occ=1；
}
字符串str；
没有留下；
没有权利；
内部高度；
int-occ=0；
}
私无根；
公共静态void main（字符串[]args）{
Arvore t=新的Arvore（）；
System.out.println（“AVL树测试”）；
串味精；
字符串[]输入；
扫描仪sc=新的扫描仪（System.in）；
ArrayList palavras=新的ArrayList（）；
int i=0；
while（true）{
msg=sc.nextLine（）；
如果（消息等于（“”）{
打破
}
输入=消息拆分（“”）；
i=0；
while（i

我不明白为什么调用insert和printTree时出错，o

i = 0;

while (i < inputs.length) {
    palavras.add(inputs[i]);
}

ArrayList<String> palavras = new ArrayList<>(); // new ArrayList<String>(); if pre Java 7

i = 0;
while (i < palavras.size()) {
    if (palavras.get(i).equals("REMOVE")) {
        palavras.remove(palavras.get(i));
        palavras.remove(palavras.get(i + 1));
        i += 2;
    } else {
        t.insert(palavras.get(i));
    }
    i++;
}

palavras.remove(palavras.get(i + 1));
palavras.remove(palavras.get(i));

palavras.remove(palavras.get(i));
palavras.remove(palavras.get(i));