Java 平衡二叉搜索树

我需要建立一个平衡的二进制搜索树。到目前为止，我的程序插入了从1到26的数字，但我的程序没有将其构建到平衡二叉搜索树中。如果有人能看看我的代码并帮助我，我将不胜感激

public class TreeNode {

  TreeNode leftTreeNode, rightTreeNode;// the nodes
  int data;
  //int size;



  public TreeNode(){//Constructer
    leftTreeNode = null;
    rightTreeNode = null;
  }

  public TreeNode(int newData){//Constructer with new Data coming in for comparison
    leftTreeNode = null;
    rightTreeNode = null;
    data = newData;
  }

  public TreeNode getLeft(){
    return leftTreeNode;
  }
  public TreeNode getRight(){
    return rightTreeNode;
  }

  public void setLeft(TreeNode leftTreeNode){
    this.leftTreeNode = leftTreeNode;
  }
  public void setRight(TreeNode rightTreeNode){
    this.rightTreeNode = rightTreeNode;
  }
  public int getData(){
    return data;
  }

//    public boolean isEmpty(){//Checking to see if the the root is empty
//      if(size == 0) return true;
//      else return false;



  public void print(){
    System.out.println("Data is: " + getData());
  }
}


//    public void traverse (Node root){ // Each child of a tree is a root of its subtree.
//    if (root.getLeft() != null){
//        traverse (root.getLeft());
//    }
//    System.out.println(root.data);
//    if (root.getRight() != null){
//        traverse (root.getRight());
//    }
//}









public class BinarySearchTree {
  TreeNode root;

  public BinarySearchTree(){
    root = null;
  }

  public TreeNode getRoot(){
    return root;
  }
  public void insert(int data) { //Insert method checking to see where to put the nodes
    TreeNode node1 = new TreeNode(data);
    if (root == null) { 
      root = node1; 
    } 
    else{
      TreeNode parIns = root;//Parent
      TreeNode insNode = root;//Insertion Node

      while(insNode != null){
        parIns = insNode;

        if(data < insNode.getData()){//If the data is less than the data coming in place it on the left
          insNode = insNode.getLeft();
        }else{//Place it on the right
          insNode = insNode.getRight();
        }
      }//Searching where to put the node

      if(data < parIns.getData()){
        parIns.setLeft(node1);
      }else{
        parIns.setRight(node1);
      }

    }
  }

  public void printInorder(TreeNode n){
    if(n != null){
      printInorder(n.getLeft());//L
      n.print();//N
      printInorder(n.getRight());//R
    }
  }
//    public TreeNode balance(tree, int start, int end){
//      if(start > end) return null;
//      int mid = (start + end) /2;
//      TreeNode node;
//      TreeNode leftChild;
//      TreeNode rightChild;
//      
//      if(node <= mid){
//        leftChild = balance(arr[mid -1], start, end);/*Make the left child if the node coming in is
//        less than the mid node */
//        
//        
//      }else{
//        rightChild = balance(arr[mid]+1, start, end);/*Make the rigth child if the node is
//          greater than the mid node*/
//        
//      }
//      return node;
//  }


  public static void main(String[] args) {
    BinarySearchTree tree = new BinarySearchTree();
    tree.insert(1);
    tree.insert(2);
    tree.insert(3);
    tree.insert(4);
    tree.insert(5);
    tree.insert(6);
    tree.insert(7);
    tree.insert(8);
    tree.insert(9);
    tree.insert(10);
    tree.insert(11);
    tree.insert(12);
    tree.insert(13);
    tree.insert(14);
    tree.insert(15);
    tree.insert(16);
    tree.insert(17);
    tree.insert(18);
    tree.insert(19);
    tree.insert(20);
    tree.insert(21);
    tree.insert(22);
    tree.insert(23);
    tree.insert(24);
    tree.insert(25);
    tree.insert(26);
    tree.printInorder(tree.getRoot());



  }



}



//for(int i = 1; i <= 26; i++)
  //tree.insert(i);


         public void balance(TreeNode tree, int start, int end){
      TreeNode tree1 = new TreeNode(data);
      if(start <= end){
      int mid = (start + end) /2;
      //TreeNode node;
      TreeNode leftChild;
      TreeNode rightChild;

      if(tree1.getData() <= mid){
        leftChild = balance(tree1(mid -1), start, end);/*Make the left child if the node coming in is
        less than the mid node */


      }else{
        rightChild = balance(tree1(mid+1), start, end);/*Make the rigth child if the node is
          greater than the mid node*/

      }

      }
}

公共类树节点{
TreeNode leftTreeNode，rightTreeNode；//节点
int数据；
//整数大小；
公共树节点（）{//构造函数
leftTreeNode=null；
rightTreeNode=null；
}
公共树节点（int newData）{//constructor，新数据用于比较
leftTreeNode=null；
rightTreeNode=null；
数据=新数据；
}
公共TreeNode getLeft（）{
返回leftTreeNode；
}
公共TreeNode getRight（）{
返回右树节点；
}
公共void setLeft（TreeNode leftTreeNode）{
this.leftTreeNode=leftTreeNode；
}
公共无效设置权（TreeNode rightTreeNode）{
this.rightTreeNode=rightTreeNode；
}
公共int getData（）{
返回数据；
}
//公共布尔值isEmpty（）{//正在检查根是否为空
//if（size==0）返回true；
//否则返回false；
公开作废印刷品（）{
System.out.println（“数据为：+getData（））；
}
}
//公共void遍历（节点根）{//树的每个子节点都是其子树的根。
//if（root.getLeft（）！=null）{
//遍历（root.getLeft（））；
//    }
//System.out.println（root.data）；
//if（root.getRight（）！=null）{
//遍历（root.getRight（））；
//    }
//}
公共类二进制搜索树{
树根；
公共二进制搜索树（）{
root=null；
}
公共树节点getRoot（）{
返回根；
}
public void insert（int data）{//insert方法检查以查看节点的放置位置
树节点1=新树节点（数据）；
如果（root==null）{
根=节点1；
} 
否则{
TreeNode parIns=root；//父
TreeNode insNode=root；//插入节点
while（insNode！=null）{
parIns=insNode；
如果（data结束）返回null；
//int mid=（开始+结束）/2；
//树节点；
//树形左儿童；
//特雷诺德右童；
//      
//如果（node由于树没有自平衡，它是否平衡将取决于元素的插入顺序

如果您想让您的树保持平衡，则需要注意类中的平衡。例如，请查看数据结构。
公共类BinarySearchTree{
public class BinarySearchTree {
  TreeNode root;

  public BinarySearchTree(){
    root = new TreeNode();
  }

  public TreeNode getRoot(){
    return root;
  }
  public void insert(int data) {
    root = insert(root, data);
  }//Insert method checking to see where to put the nodes

//  public void insert(TreeNode node, int data){
//    TreeNode node1 = new TreeNode(data);
//    if (root == null) { 
//      root = node1; 
//    } 
//    else{
//      TreeNode parIns = root;//Parent
//      TreeNode insNode = root;//Insertion Node
//      
//      while(insNode != null){
//        parIns = insNode;
//        
//        if(data < insNode.getData()){//If the data is less than the data coming in place it on the left
//          insNode = insNode.getLeft();
//        }else{//Place it on the right
//          insNode = insNode.getRight();
//        }
//      }//Searching where to put the node
//      
//      if(data < parIns.getData()){
//        parIns.setLeft(node1);
//      }else{
//        parIns.setRight(node1);
//      }
//      
//    }
//  }

  private TreeNode insert(TreeNode node, int data) { 
    if(root.data == 0)
      root.data = data;
    else if (node==null) { 
      node = new TreeNode(data); 
    } 
    else { 
      if (data <= node.data) { 
        node.leftTreeNode = insert(node.leftTreeNode, data); 
      } 
      else { 
        node.rightTreeNode = insert(node.rightTreeNode, data); 
      } 
    } 

    return(node); // in any case, return the new pointer to the caller 
  } 
  public void printPreOrder(){
    printPreOrder(root);
  }
  public void printPreOrder(TreeNode n){
    if(n != null){
      n.print();//N
      printPreOrder(n.getLeft());//L
      printPreOrder(n.getRight());//R
    }
  }

    public TreeNode balance(int[] a, int start, int end){
    TreeNode node = new TreeNode();
    if(start <= end){
      int mid = start + (end - start) /2;
      node.data = a[mid];

      if(root.data == 0)
        root = node;
      node.leftTreeNode = balance(a, start, mid -1);/*Make the left child if the node coming in is
       less than the mid node */


      node.rightTreeNode = balance(a, mid + 1, end);/*Make the rigth child if the node is
       greater than the mid node*/
    }
      else{
      return null;
      }


    return node;
  }



  public static void main(String[] args) {
    BinarySearchTree tree = new BinarySearchTree();
    //int[] a = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,21,22,23,24,25,26};
    int[] a = new int[26];
    for(int i = 0; i < 26; i++){
      a[i] = i + 1;
    }
    for(int i = 1; i <= 26; i++)
      tree.insert(i);

    tree.printPreOrder();
    BinarySearchTree tree2 = new BinarySearchTree();
    tree2.balance(a, 0, 25);
    System.out.println("Now I am going to balance my tree");
    tree2.printPreOrder();

  }

}



public class TreeNode {

  TreeNode leftTreeNode, rightTreeNode;// the nodes
  int data;
  //int size;



  public TreeNode(){//Constructer
    leftTreeNode = null;
    rightTreeNode = null;
    data = 0;
  }

  public TreeNode(int newData){//Constructer with new Data coming in for comparison
    leftTreeNode = null;
    rightTreeNode = null;
    data = newData;
  }

  public TreeNode getLeft(){
    return leftTreeNode;
  }
  public TreeNode getRight(){
    return rightTreeNode;
  }

  public void setLeft(TreeNode leftTreeNode){
    this.leftTreeNode = leftTreeNode;
  }
  public void setRight(TreeNode rightTreeNode){
    this.rightTreeNode = rightTreeNode;
  }
  public int getData(){
    return data;
  }


//    public boolean isEmpty(){//Checking to see if the the root is empty
//      if(size == 0) return true;
//      else return false;



  public void print(){
    System.out.println("Data is: " + getData());
  }


}

树根；
公共二进制搜索树（）{
根=新树节点（）；
}
公共树节点getRoot（）{
返回根；
}
公共空白插入（整型数据）{
根=插入（根，数据）；
}//插入方法检查以查看节点的放置位置
//公共void插入（TreeNode节点，int数据）{
//树节点1=新树节点（数据）；
//如果（root==null）{
//根=节点1；
//    } 
//否则{
//TreeNode parIns=root；//父
//TreeNode insNode=root；//插入节点
//      
//while（insNode！=null）{
//parIns=insNode；
//        
//如果（data如果（数据抱歉，看起来我喜欢我的大部分程序哈哈，但我只是添加了我所添加的其余部分。您添加的其余部分不会改变我的答案。您有一个基本的二元搜索树，您永远不会重新平衡。然后您按顺序插入一组数字。除非您按顺序插入元素，否则将导致b平衡树或以编程方式平衡树，它将不会被平衡。是的，我明白，这就是我需要帮助的地方。你需要帮助实现自平衡树吗？这是一个非常重要的问题。看看我链接的维基百科文章。有更多的例子。普通的二元搜索树不是自平衡的。你当前的代码将被删除首先，创建一个值的链接列表。尝试查看2-3棵树或红黑树。