title: Null pointer error. Binary search tree program
body: <p>I'm trying to program a binary tree. Everything works fine except when I try to delete the root node.</p>
  
  <p>Returning the following error. I have no idea how to fix this. Please help.</p>
  
  <p>Every other function like Add, Statistics, Balance, ect works fine. Only when I try to perform the Delete on the root node the program returns.</p>
  
  <pre><code>Exception in thread "main" java.lang.NullPointerException
      at TreeClass$BinarySearchTree.Delete(TreeClass.java:147)
      at TreeClass$BinarySearchTree.fnHandler(TreeClass.java:292)
      at TreeClass.main(TreeClass.java:341)
  </code></pre>
  
  <p>However, delete works on other nodes in the tree. Only runs into problems with the root node.
  Here's my code</p>
  
  <pre><code>import java.util.*;
  
  public class TreeClass 
  {
      //--------------------------------------------------------------
      static Scanner scanner = new Scanner(System.in);
      static BinarySearchTree BST = new BinarySearchTree();
      //--------------------------------------------------------------
      public static class TreeNode
      {
          TreeNode    Parent;
          TreeNode    LChild;
          TreeNode    RChild;
          Integer     Data;
  
          public TreeNode(int cbData)
          {
              this.Data = cbData;
              this.LChild = null;
              this.RChild = null;
              this.Parent = null;
          }
  
          public void SetParent(TreeNode parent)
          {
              this.Parent = parent;
          }
      }
  
      public static class BinarySearchTree
      {
          int         size;
          TreeNode    Root;
  
          public BinarySearchTree()
          {
              this.size = 0;
              this.Root = null;
          }
  
          public void Allocate(TreeNode node, ArrayList&lt;Integer&gt; DataList)
          {
              if (node.LChild != null)
                  Allocate(node.LChild, DataList);
  
              DataList.add(node.Data);
  
              if (node.RChild != null)
                  Allocate(node.RChild, DataList);        
          }
  
          public void Add(int cbData)
          {
              TreeNode    temp = null;
              TreeNode    node = new TreeNode(cbData);
  
              if(this.size == 0)
              {
                  this.Root = node;
              }
              else
              {
                  temp = this.Root;
  
                  while(temp != null)
                  {               
                      if(cbData &gt; temp.Data)
                      {
                          if(temp.RChild == null)
                          {
                              temp.RChild = node;
                              node.Parent = temp;
                              break;
                          }
                          temp = temp.RChild;
                      }
                      else if(cbData &lt; temp.Data)
                      {
                          if(temp.LChild == null)
                          {
                              temp.LChild = node;
                              node.Parent = temp;
                              break;
                          }
                          temp = temp.LChild;
                      }
                      else 
                      {
                          //System.out.printf("[Error] %d already exists!\n", cbData);
                          return;
                      }
                  }
              }
  
              if(size == 0)
                  System.out.printf("[Success] %d has been added as root\n", node.Data);
              else
                  System.out.printf("[Success] %d has been added - Parent: %d\n", node.Data, node.Parent.Data);
  
              ++this.size;
          }
  
          public void AddReBalance(int[] List, int min, int max)
          {
              if(min &lt;= max)
              {
                  int current = (max+min)/2;
  
                  Add(List[current]);
                  AddReBalance(List, min, current-1);
                  AddReBalance(List, current+1, max);
              }
          }
  
          public void Delete(int cbData)
          {
              TreeNode    temp = null;
  
              if(this.size &gt; 0)
              {
                  temp = this.Root;
  
                  while(temp != null)
                  {               
                      if(cbData &gt; temp.Data)
                          temp = temp.RChild;
                      else if(cbData &lt; temp.Data)
                          temp = temp.LChild;
                      else 
                      {
                          System.out.printf("[Success] %d found and deleted!\n", cbData);
  
                          if(temp.LChild != null)
                          {
                              temp.LChild.Parent = temp.Parent;
  
                              if(temp == temp.Parent.RChild)
                                  temp.Parent.RChild = temp.LChild;
                              else if(temp == temp.Parent.LChild)
                                  temp.Parent.LChild = temp.LChild;
                          }
                          else if(temp.RChild != null)
                          {
                              temp.RChild.Parent = temp.Parent;
  
                              if(temp == temp.Parent.LChild)
                                  temp.Parent.LChild = temp.RChild;
                              else if(temp == temp.Parent.RChild)
                                  temp.Parent.RChild = temp.RChild;
                          }
                          else
                          {
                              if(temp == temp.Parent.LChild)
                                  temp.Parent.LChild = null;
                              else if(temp == temp.Parent.RChild)
                                  temp.Parent.RChild = null;
  
                              temp.Parent = null;
                          }
  
                          --this.size;
                          return;
                      }
                  }
              }
              System.out.printf("[Error] %d not found!\n", cbData);
          }
  
          public int Find(int cbData)
          {
              int         Level = 0;
              TreeNode    temp = this.Root;
  
              while(temp != null)
              {               
                  if(cbData &gt; temp.Data)
                  {
                      temp = temp.RChild;
                      ++Level;
                  }
                  else if(cbData &lt; temp.Data)
                  {
                      temp = temp.LChild;
                      ++Level;
                  }
                  else if(cbData == temp.Data)
                  {
                      return ++Level;
                  }
              }
              return -1;
          }
  
          public void Rebalance()
          {
              int[]   cbList = new int[this.size];
              ArrayList&lt;Integer&gt; DataList = new ArrayList();
  
              Allocate(this.Root, DataList);
  
              for(int i = 0; i &lt; DataList.size(); ++i)
                  cbList[i] = DataList.get(i);
  
              this.size = 0;
  
              if(cbList.length &gt; 0) 
                  AddReBalance(cbList, 0, cbList.length-1); 
              else
                  System.out.print("[Error] You do not have any nodes to balance!\n");
          }
  
          public void DisplayContent(TreeNode node)
          {
              ArrayList&lt;Integer&gt; DataList = new ArrayList();
  
              Allocate(this.Root, DataList);
              System.out.printf("Tree Content: ");
  
              for(int i = 0; i &lt; DataList.size(); ++i)
                  System.out.printf("%d ", DataList.get(i));
  
              System.out.printf("\n");
          }
  
          public void GetPathData(TreeNode node, ArrayList&lt;Integer&gt; DepthList, int Level)
          {
              ++Level;
  
              if(node.RChild != null | node.LChild != null)
              {
                  if (node.LChild != null)
                      GetPathData(node.LChild, DepthList, Level);
  
                  if (node.RChild != null)
                      GetPathData(node.RChild, DepthList, Level);     
              }
              else
              {
                  DepthList.add(Level);
                  Level = 0;
              }
  
          }
  
          public void DisplayStats()
          {
              int Level = 0, Max = 0, Min = 0;
              ArrayList&lt;Integer&gt; DList = new ArrayList();
  
              GetPathData(this.Root, DList, Level);
  
              for(int i = 0; i &lt; DList.size(); ++i)
              {
                  int TempPath = DList.get(i);
  
                  if(i == 0)
                  {
                      Min = TempPath; 
                      Max = TempPath;
                  }
                  else
                  {
                      if(Min &gt; TempPath)
                          Min = TempPath;
                      if(Max &lt; TempPath)
                          Max = TempPath;
                  }
              }
  
              System.out.printf("Root Data: %d\nItem Count: %d\nShortest Path: %d" +
                      "\nLongest Path: %d\n\n", this.Root.Data, this.size, Min, Max);
          }
  
          public boolean fnHandler(int cbIn)
          {
              int cbInItem = 0;
              int cbTempRetn = 0;
              boolean retn = false;
  
              switch(cbIn)
              {
              case 1:
                  System.out.printf("Input an integer to add: ");
                  cbInItem = scanner.nextInt();
                  Add(cbInItem);
                  break;
  
              case 2:
                  System.out.printf("Input an integer to delete: ");
                  cbInItem = scanner.nextInt();
                  Delete(cbInItem);
                  break;
  
              case 3:
                  System.out.printf("Input an integer to find:");
                  cbInItem = scanner.nextInt();
                  cbTempRetn = BST.Find(cbInItem);
  
                  if(cbTempRetn == -1)
                      System.out.printf("[Error] This item was not found!\n");
                  else
                      System.out.printf("[Success] Item was found on level: %d\n", cbTempRetn);
  
                  break;
  
              case 4:
                  BST.Rebalance();
                  System.out.printf("[Success] Tree has been balanced!\n");
                  break;
  
              case 5:
                  BST.DisplayContent(BST.Root);   
                  break;
  
              case 6:
                  BST.DisplayStats();
                  break;
  
              case 7:
                  retn = true;
                  System.out.printf("[Exitting...]\n");
                  break;
              }
  
              return retn;
          }
      }
  
      public static void main(String[] args) 
      {
          int     cbInput = 0;
          boolean exit = false;
  
          while(exit == false)
          {
              System.out.printf("\n1. Add Entry - 2. Delete Item - 3. Find Item - 4. Balance Tree"
                              + "\n5. List Data - 6. Statistics  - 7. Exit\n\nInput: ");
  
              cbInput = scanner.nextInt();
              exit = BST.fnHandler(cbInput);
          }
      }
  
  }
  </code></pre>