遇上一个空指针报错不知道如何处理，没发现问题所在

问题遇到的现象和发生背景

遇上一个空指针报错，可是eclipse没有对代码显示警告

问题相关代码，请勿粘贴截图

package sheji;

import java.util.ArrayList;
import java.util.Scanner;

import sheji.RecordNode;
import sheji.BSTree;
import sheji.KeyType;
import sheji.ElementType;
public class action {
    public static <ReacordNode> void main(String[] args) {
        boolean flag = true;
        while (flag) {
            System.out.println("=================================================");
            System.out.println("请输入下列数字选择相应的操作：");
            System.out.println("1.建立家谱成员信息");
            System.out.println("2.查找家谱成员信息");
            System.out.println("3.插入家谱成员信息");
            System.out.println("4.修改家谱成员信息");
            System.out.println("5.删除家谱成员信息");
            System.out.println("6.显示所有家谱成员");
            System.out.println("7.退出");
            System.out.println("=================================================");
            System.out.print("输入的数字为：");
            Scanner sc = new Scanner(System.in);
            int num = sc.nextInt();
            BSTree bstree=new BSTree();
            switch (num) {
            case 1:
                String[][]item= {
                                {"小明","男"},
                                {"大明","男"},
                                {"中明","女"}
                                              };
                int[]k= {1002, 1001,1003};   //关键字数组
                KeyType[] key = new KeyType[k. length]; //关键字数组
                ElementType[]elem=new ElementType[k.length];  //记录数据数组
                for (int i = 0; i<k. length; i++) 
                {
                    key[i] = new KeyType(k[i]);          //创建关键字对象
                    elem[i] = new ElementType(item[i]);  //创建记录数据对象
                System.out.println("家谱成员信息建立成功");
                if(bstree.insertBST(key[i],elem[i])) {    //若插入对象成功
                    System.out.print("["+key[i]+","+elem[i]+"]");
                }
                }    
            
            case 2:
                System.out.println("\n 中序遍历二叉排序树");
                bstree.inOrderTraverse(bstree.root);
                System.out.println();
                KeyType keyvalue =new KeyType();
                keyvalue.key=1002;
                RecordNode found =(RecordNode)bstree.searchBST(keyvalue);
                if(found!=null) {
                    System.out.println("按编号查找:"+keyvalue+",成功！对应家族成员为:"+found.element);
                }else {
                    System.out.println("按编号查找:"+keyvalue+",失败！");
                }
                keyvalue.key=1005;
                found=(RecordNode)bstree.searchBST(keyvalue);
                if(found!=null) {
                    System.out.println("按编号查找:"+keyvalue+",成功！对应家族成员为:"+found.element);
                }else {
                    System.out.println("按编号查找:"+keyvalue+",失败！");
                }
                break;
default:
                flag = false;
                System.out.println("退出成功");
                break;
            }
        }
    }

    }

package sheji;
import sheji.BSTree;
public class BSTree {
public BiTreeNode root;
public BSTree() {
    root=null;
}
public void inOrderTraverse(BiTreeNode p) {
    if(p !=null);
    inOrderTraverse(p.lchild);
    System.out.print(((RecordNode)p.data).toString()+" ");
    inOrderTraverse(p.rchild);
}

public Object searchBST(Comparable key) {
    if(key==null||!(key instanceof Comparable)) {
        return null;
    }
    return searchBST(key);
}
private Object searchBST(BiTreeNode p,Comparable key) {
    if(p!=null) {
        if(key.compareTo(((RecordNode)p.data).key)==0)
        {return p.data;
    }
        System.out.print(((RecordNode)p.data).key+"?");
        if(key.compareTo(((RecordNode)p.data).key)<0) {
            return searchBST(p.lchild,key);
        }else {
            return searchBST(p.rchild,key);
        }
}
    return null;
}
public boolean insertBST(KeyType keyType, ElementType elementType) {
    // TODO Auto-generated method stub
    return false;
}
}

运行结果及报错内容

=================================================
请输入下列数字选择相应的操作：
1.建立家谱成员信息
2.查找家谱成员信息
3.插入家谱成员信息
4.修改家谱成员信息
5.删除家谱成员信息
6.显示所有家谱成员
7.退出
=================================================
输入的数字为：1
家谱成员信息建立成功
家谱成员信息建立成功
家谱成员信息建立成功

中序遍历二叉排序树
Exception in thread "main" java.lang.NullPointerException
at sheji.BSTree.inOrderTraverse(BSTree.java:10)
at sheji.action.main(action.java:52)

我的解答思路和尝试过的方法

我想要达到的结果

不报错，顺利运行

报错了啊。
在中序遍历二叉排序树 下面那行inOrderTraverse的代码里。
NULL是因为你传了空对象。而且调用了方法，空对象没有方法所以报错。

参考这个

package com.zw.dataStructure;

/**
 * 链表实现二叉树
 */
public class NodeTree {

    static class Node {
        int index;
        int data;
        Node parent;
        Node left;
        Node right;

        public Node(int data) {
            this.data = data;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "index=" + index +
                    ", data=" + data +
                    '}';
        }
    }

    Node root;

    public NodeTree(Node root) {
        this.root = root;
        this.root.index = 0;
        this.root.parent = null;
        this.root.left = null;
        this.root.right = null;
    }

    public Node searchNode(int index) {
        return search(root, index);
    }

    private Node search(Node node, int targetIndex) {
        if (node.index == targetIndex) {
            return node;
        } else {
            if (node.left != null) {

                Node leftSearch = search(node.left, targetIndex);
                if (leftSearch != null) {
                    return leftSearch;
                }
            }
            if (node.right != null) {
                Node rightSearch = search(node.right, targetIndex);
                if (rightSearch != null) {
                    return rightSearch;
                }
            }
            return null;
        }
    }

    public boolean addNode(int index, int direction, Node newNode) {
        Node node = searchNode(index);
        if (node == null) {
            return false;
        }
        //插左边
        if (direction == 0) {
            node.left = newNode;
            newNode.index = node.index * 2 + 1;
        } else {
            //右边
            node.right = newNode;
            newNode.index = node.index * 2 + 2;
        }
        newNode.parent = node;
        return true;
    }

    public boolean deleteNode(int index) {
        Node node = searchNode(index);
        if (node == null) {
            return false;
        }
        Node parent = node.parent;
        if (parent != null) {
            if (parent.left == node) {
                parent.left = null;
            } else if (parent.right == node) {
                parent.right = null;
            }
            return true;
        }
        return true;
    }

    /**
     * 前序遍历    中 左 右
     */
    public void preOrderTraverse() {
        preOrder(root);
    }

    private void preOrder(Node node) {
        System.out.print(node.data + "  ");
        if (node.left != null) {
            preOrder(node.left);
        }
        if (node.right != null) {
            preOrder(node.right);
        }
    }

    /**
     * 中序遍历    左 中 右
     */
    public void inOrderTraverse() {
        inOrder(root);
    }

    private void inOrder(Node node) {
        if (node.left != null) {
            inOrder(node.left);
        }
        System.out.print(node.data + "  ");
        if (node.right != null) {
            inOrder(node.right);
        }
    }

    /**
     * 后序遍历   左右中
     */
    public void postOrderTraverse() {
        postOrder(root);
    }

    private void postOrder(Node node) {
        if (node.left != null) {
            postOrder(node.left);
        }
        if (node.right != null) {
            postOrder(node.right);
        }
        System.out.print(node.data+"  ");
    }

    public static void main(String[] args) {

        Node root = new Node(3);
        NodeTree tree = new NodeTree(root);

        tree.addNode(0, 0, new Node(5));
        tree.addNode(0, 1, new Node(8));

        tree.addNode(1, 0, new Node(2));
        tree.addNode(1, 1, new Node(6));

        tree.addNode(2, 0, new Node(9));
        tree.addNode(2, 1, new Node(7));

//        System.out.println("111");
//        System.out.println(tree.searchNode(0));
//        System.out.println(tree.searchNode(1));
//        System.out.println(tree.searchNode(2));
//        System.out.println(tree.searchNode(3));
//        System.out.println(tree.searchNode(4));
//        System.out.println(tree.searchNode(5));
//        System.out.println(tree.searchNode(6));
//        System.out.println(tree.searchNode(7));

        tree.deleteNode(3);

        System.out.println("3  5  8  2  6  9  7");
        System.out.println("\npreOrderTraverse:");
        tree.preOrderTraverse();
        System.out.println("\ninOrderTraverse:");
        tree.inOrderTraverse();
         System.out.println("\npostOrderTraverse:");
        tree.postOrderTraverse();
    }

}