Java 无法平衡二叉树

我是算法新手，我正在学习二叉树以及如何平衡它们。我面临的问题是，即使在平衡了二叉树之后，我得到的树的高度与以前一样。在我看来，在平衡二叉树（有平衡的空间）之后，树的高度会发生变化。以下是我的代码：-

class Node
{
   Node left;
   Node right;
   int info;
   public Node(int info)
   {
      this.info = info;
   }
}
public class NewBST
{
   public Node root;

   public NewBST()
   { }
   // ADD
   public boolean add(int info){
      if( root == null )
      {
         root = new Node(info);
         return true;
      }
      else
         return addRec(info, root);
   }
   public boolean addRec(int info, Node n)
   {
      if( info <= n.info )
      {
         if( n.left == null )
         {
            n.left = new Node(info);
            return true;
         }
         else
         {
            return addRec(info, n.left);
         }
      }
      if( info > n.info )
      {
         if( n.right == null )
         {
            n.right = new Node(info);
            return true;
         }
         else
         {
            return addRec(info, n.right);
         }
      }
      return true;
   }
   // CONTAINS
   public boolean contains( int v )
   {
      return contains(v, root);
   }
   public boolean contains( int v, Node n )
   {
      if(n== null){
        return false;
      }
      else if(v == n.info){
        return true;
      }
      else if(v <n.info){
        return contains(v,n.left);
      }
      else{
        return contains(v, n.right);
      }
      //return true;
    }
// MIN
   public int min(Node n)
   {
      if( n.left != null )
         return min(n.left);
      return n.info;
   }

  //HEIGHT
   public int height(Node n)
   {
      //fix this code!
      if(n==null){
        return 0;
      }
      return 1+ Math.max(height(n.left), height(n.right));
   }
   public int height()
   {
      return height(root);
   }

   // DISPLAY
   public void display( int n ){
      if( n == 0 )
      {
         infix( root );
         System.out.println();
      }
      else if( n == 1 )
      {
         postfix( root );
         System.out.println();
      }
      else if( n == 2 )
      {
         prefix( root );
         System.out.println();
      }
   }
   // TRAVERSE
   public void prefix(Node n)
   {
    if(n!=null)
        System.out.print(n.info +" ");
        prefix(n.left);
        prefix(n.right);
   }

   public void postfix(Node n)
   {
    if(n!=null){
        postfix(n.left);
        postfix(n.right);
        System.out.print(n.info + " ");
    }
   }

    public void infix(Node n)
   {
    if(n!=null){
        infix(n.left);
        System.out.print(n.info + " ");
            infix(n.right);
    }
   }


   public void infix(Node n, ArrayList<Integer> list)
   {
    if(n!=null){
        infix(n.left,list);
        list.add(n.info);
        infix(n.right,list);
    }
   }
//BALANCE
   public void balance()
   {
    ArrayList<Integer> list= new ArrayList<Integer>();
    NewBST bst= new NewBST();
    infix(root, list);

    balRec(list, 0, list.size()-1,bst);

   }

   public void balRec(ArrayList<Integer> list, int low, int high,NewBST bst){
      if( high<low){
         return;
      }
    int mid= (low + high)/2;
    bst.add(list.get(mid));
    balRec(list, low, mid-1,bst);
    balRec(list,mid+1, high,bst);
   }

  //MAIN
   public static void main(String[] args)
   {
      Scanner inp = new Scanner(System.in);
      ArrayList<Integer> store = new ArrayList<Integer>();
      NewBST bst = new NewBST();
      int nCount = 0;
      while( nCount < 32 )
      {
         int t = (int)(Math.random() * 36);
         if( !bst.contains(t) )
         {
            bst.add(t);
            store.add(t);
            nCount++;
         }
      }
      System.out.print( "Height of tree = " + bst.height());
      bst.balance();
      System.out.println();
      System.out.println( "Height of tree = " + bst.height());
      bst.display(0);

   }
}

类节点
{
左淋巴结；
节点权；
国际信息；
公共节点（内部信息）
{
this.info=info；
}
}
公共类纽伯斯特
{
公共节点根；
公共图书馆
{ }
//加
公共布尔添加（整数信息）{
if（root==null）
{
根=新节点（信息）；
返回true；
}
其他的
返回addRec（info，root）；
}
公共布尔addRec（整数信息，节点n）
{
如果（信息）
{
如果（n.right==null）
{
n、 右=新节点（信息）；
返回true；
}
其他的
{
返回addRec（信息，右侧）；
}
}
返回true；
}
//包含
公共布尔包含（int v）
{
返回包含（v，根）；
}
公共布尔包含（int v，节点n）
{
如果（n==null）{
返回false；
}
else if（v==n.info）{
返回true；
}
如果（v首先，让我解释一个平衡二叉搜索树的高度方案。高度平衡二叉树被定义为一个二叉树，其中两个子树（左和右）的高度差永远不会超过一

您的问题是，即使在平衡树之后，您也会得到相同的高度。我发现您的代码中有一个小错误。平衡后，您必须将新值分配给根节点。这是计算平衡二叉树高度所必需的。因此，请在平衡方法代码中添加以下内容：

public void balance(){
    ArrayList<Integer> list= new ArrayList<Integer>();
    NewBST bst= new NewBST();
    infix(root, list);

    balRec(list, 0, list.size()-1,bst);
    root= bst.root;     
}

public void balance（）{
ArrayList=新建ArrayList（）；
NewBST bst=新的NewBST（）；
中缀（根，列表）；
balRec（list，0，list.size（）-1，bst）；
root=bst.root；
}

希望这能有所帮助。
非常感谢！！解决方案成功了。我在调试时发现了一个小错误。太好了！！另一个建议是在代码中添加记录器，这将帮助您了解程序的控制流。