二叉搜索树通用

Question

我有以下类，我想让用户选择是要创建带有整数的 BST 还是带有字符串的 BST。当用户选择 5 时如何从整数创建 BST，或者当用户按 6 时如何从字符串创建 BST？另外，如果有人发现我的泛型有问题，请告诉我！

非常感谢

    public class BSTNode <T extends Comparable<T>>
{ 
       T value; 
        BSTNode<T> left; 
        BSTNode<T> right; 

      public BSTNode(T value, BSTNode<T> l,BSTNode<T> r) 
      { 
            this.value = value; 
            left = l; 
            right = r; 
      } 

      public BSTNode(T value) 
      { 
            this(value,null,null);
      } 

      public T getValue() 
      {
          return value;
      }

      public void setValue(T value) 
      {
          this.value = value;
      }

      public BSTNode<T> getLeftChild() 
      {
          return left;
      }

      public BSTNode<T> getRightChild() 
      {
          return right;
      }

      public void setLeftChild(BSTNode<T> node) 
      {
          left = node;
      }

      public void setRightChild(BSTNode<T> node) 
      {
          right = node;
      }

      public boolean search(T value) 
      { 
            if (value.equals(this.value)) 
                  return true; 
            else if (value.compareTo(this.value) < 0) 
            { 
                  if (left == null) 
                        return false; 
                  else 
                        return left.search(value); 
            } else if (value.compareTo(this.value) > 0) 
            { 
                  if (right == null) 
                        return false; 
                  else 
                        return right.search(value); 
            } 
            return false; 
      }

      public boolean add(T value) 
      { 
            if (value.compareTo(this.value)==0) 
                  return false; 
            else if (value.compareTo(this.value) < 0) 
            { 
                  if (left == null) 
                  { 
                        left = new BSTNode<T>(value); 
                        return true; 
                  } else 
                        return left.add(value); 
            } 
            else if (value.compareTo(this.value) > 0) 
            { 
                  if (right == null) 
                  { 
                        right = new  BSTNode<T>(value); 
                        return true; 
                  } 
                  else 
                        return right.add(value); 
            } 
            return false; 
      } 



     public boolean remove(T value2, BSTNode<T> parent) 
      { 
        if (value2.compareTo(this.value)<0) 
        { 
           if (left != null) 
              return left.remove(value2, this); 
           else 
              return false; 
       }
        else if (value2.compareTo(this.value)>0) 
        { 
           if (right != null) 
              return right.remove(value2, this); 
           else 
              return false; 
        }
       else 
       { 
           if (left != null && right != null) 
           { 
               this.value = right.minValue(); 
               right.remove(this.value, this); 
           } 
           else if (parent.left == this) 
           { 
               parent.left = (left != null) ? left : right; 
           } 
           else if (parent.right == this) 
           { 
               parent.right = (left != null) ? left : right; 
           } 
           return true; 
       }
    } 

    public T minValue() 
    { 
         if (left == null) 
             return value; 
         else 
             return left.minValue(); 
    }

 }

     public class BinarySearchTree <T extends Comparable<T>>
{ 
      private BSTNode<T> root; 

      public BinarySearchTree(T value) 
      { 
          root = new BSTNode<T>(value);
      } 


      public BSTNode getRoot() 
      {
          return root;
      }

      public boolean search(T value) 
      { 
          if (root.equals(null)) 
              return false; 
        else 
              return root.search(value); 
  }

      public boolean add(T value) 
      { 
          if (root == null) { 
              root = new BSTNode(value); 
              return true; 
        } else 
              return root.add(value); 
      } 

      public boolean remove(T value) { 
            if (root == null) 
               return false; 
            else { 
               if (root.getValue() == value) { 
                   BSTNode auxRoot = new BSTNode(null); 
                   auxRoot.setLeftChild(root); 
                   boolean result = root.remove(value, auxRoot); 
                   root = auxRoot.getLeftChild(); 
                   return result; 
               } else { 
                   return root.remove(value, null); 
               } 
             } 
          }

     public static void displayInorder(BSTNode T)
      {
          if (T!=null)
          {
              if (T.getLeftChild()!=null)
              {               
                  displayInorder(T.getLeftChild());               
              }
              System.out.print(T.getValue() + "  ");
              if(T.getRightChild()!=null)
              {
                  displayInorder(T.getRightChild());
              }
          }

      }
  }

import java.util.Scanner;

public class main {
    public  static void main(String[] args) {
        BinarySearchTree b = new BinarySearchTree(null);
        boolean flag = true;
        while (flag) {
        Scanner scan = new Scanner(System.in);
          System.out.println("Select 1 to add values in to BST\n"
                + "Select 2 to delete values from the BST \n"
                + "Select 3 to search for a value\n"
                + "Select 4 to display te values held in the BST\n"
                + "Select 5 to create a BST of strings\n"
                + "Select 6 to create a BST of integers\n"
                + "Select 7 to exit" );
          int opt = scan.nextInt();

    switch (opt) {
    case 1: System.out.println("Insert the value of your choice: ");
            String str = scan.next();
            b.add(str);
            break;
    case 2: System.out.println("Insert the value of your choice: ");
              str = scan.next();
              b.remove( str);
            break;
    case 3:
        System.out.println("Insert the value of your choice: ");
          str = scan.next();
          b.search(str);
        break;
    case 4:
        BinarySearchTree.displayInorder(b.getRoot());
        break;
    case 5:

    case 7:
        flag=false;
        break;
    }
  }
 }
}

Answer 1

为了在您的代码中充分利用泛型，这是我的建议：

我会在树类中添加一个将字符串（用户输入）处理为适当类型的方法：

...
import java.util.function.Function;
...

public class BinarySearchTree <T extends Comparable<T>>
{ 
      private BSTNode<T> root; 
      private Function<String,T> valueDecoder

      public BinarySearchTree(final Function<String,T> valueDecoder) 
      { 
          this.valueDecoder = valueDecoder; 
          root = new BSTNode<T>(null);
      } 

      ... 
      public boolean decodeAndAdd(final String encodedValue) {
          return add(valueDecoder.apply(encodedValue));
      }

      public boolean decodeAndRemove(final String encodedValue) {
          return remove(valueDecoder.apply(encodedValue));
      }
}

```

然后，您将保留 b 变量 undefined/null ，直到您实际上现在给出用户提供的选择的树类型。由于它可能包含String 或Integer 在这里你只能使用? 作为类型参数，也许? extends Comparable<?> 因为这是约束的一部分...... ? 在这种情况下很好：

BinarySearchTree<?> b = null;

现在，当用户请求 String 或 Integer 树时，您需要提供适当的 lambda 以将扫描的字符串转换为实际的元素值：

case 5:
   b = new BinarySearchTree<>(scanStr -> scanStr);
   break;
case 6:
   b = new BinarySearchTree<>(scanStr -> Integer.parseInt(scanStr));
   break;

现在添加和删除是微不足道的：

case 1:
     b.decodeAndAdd(scan.next());
     break;

case 2:
     b.decodeAndRemove(scan.next());
     break;

如果用户在树是Integer 树时提供了一个无效的整数字符串值，则会导致NumberFormatException 并且程序将停止。也许您更愿意显示一条错误消息并允许用户执行其他操作。为此：

case 6:
    b = new BinarySearchTree<>(scanStr -> {
       try {
          return Integer.parseInt(scanStr);
       } catch (NumberFormatException ex) {
          throw new IllegalArgumentException("you must provide a valid integer value: '" + scanStr + "'");
       }
    });
    break;
...

case 1:
     try {
       b.decodeAndAdd(scan.next());
     } catch (final IllegalArgumentException ex) {
       System.err.println("ERROR: " + ex.getMessage());
     }
     break;

case 2:
     try {
       b.decodeAndRemove(scan.next());
     } catch (final IllegalArgumentException ex) {
       System.err.println("ERROR: " + ex.getMessage());
     }
     break;

如果您想让事情更加模块化，那么将 decodeAndAdd 和 decodeAndRemove 添加到 BinarySearchTree 类可能并不理想，因为 BST 可能会在问题中描述的用户命令行上下文之外使用。

在这种情况下，您可以定义一个通用的“结构”类，该类包含一个引用，该引用包含对 BST 的引用和解码 lambda，其元素类型使用类型参数绑定为相同。您还可以在添加此功能的另一个用户界面专用 BST 中扩展 BST 类：

class CommandLineBST<T> {

  public final BST<T> tree;
  public final Function<String, T> valueDecoder;

  public CommandLineBST(final BST<T> tree, final Function<String, T> decoder) {
      this.tree = tree;
      this.valueDecoder = decoder;
  }

  public boolean add(final String scanStr) { 
     return tree.add(valueDecoder.apply(scanStr)); 
  }

  public boolean remove(final String scanStr) {
     return tree.remove(valueDecoder.apply(scanStr));
  }

}

或

class CommandLineBST<T> extends BST<T> {
    private Function<String, T> valueDecoder;

    public CommandLineBST(final Function<String, T> valueDecoder) {
       super(null);
       this.valueDecoder = valueDecoder;
    }

    public boolean decodeAndAdd(final String scanStr) { ... }
    public boolean decodeAndRemove(final String scanStr) { ... }
}