Question

所以我本周一在Java上有一个决赛，在课堂上我们讨论了仿制药，我觉得它看起来很简单。我想用本书中的一个例子来试一试。所以我试图制作一个通用树。问题是我的代码看起来几乎与课堂上使用的例子完全相同，除了我的工作。我为何感到困惑。它告诉我，我在insert方法中缺少一个标识符。但就像我说的那样，它看起来像教授所做的和书籍例子之间的完美结合。我尝试查找其他人关于泛型的问题，但我更加困惑。有人可以用简单的术语（在合理范围内）向我解释我做错了什么吗？如果您对Deitel和Deitel编写的Java如何编程的教科书感到疑惑

// Tree.java
// Definition of class TreeNode and class Tree.
// class TreeNode definition
class TreeNode<E extends Comparable<TreeNode<E>>>
{

   TreeNode<E> leftNode; // left node  
   E data; // node value
   TreeNode<E> rightNode; // right node

   // constructor initializes data and makes this a leaf node
   public TreeNode( E nodeData )
   { 
      data = nodeData;              
      leftNode = rightNode = null; // node has no children
   } // end TreeNode constructor

   // locate insertion point and insert new node; ignore duplicate values
   public void <E extends Comparable<TreeNode<E>>> insert( E insertValue )
   {
      // insert in left subtree
      if ( data.compareTo(insertValue) > 0 ) 
      {
         // insert new TreeNode
         if ( leftNode == null )
            leftNode = new TreeNode<E>( insertValue );
         else // continue traversing left subtree
            leftNode.insert( insertValue ); 
      } // end if
      else if ( data.compareTo(insertValue) < 0 ) // insert in right subtree
      {
         // insert new TreeNode
         if ( rightNode == null )
            rightNode = new TreeNode<E>( insertValue );
         else // continue traversing right subtree
            rightNode.insert( insertValue ); 
      } // end else if
   } // end method insert
} // end class TreeNode

// class Tree definition
public class Tree<E>
{
   private TreeNode<E> root;

   // constructor initializes an empty Tree of integers
   public Tree() 
   { 
      root = null; 
   } // end Tree no-argument constructor

   // insert a new node in the binary search tree
   public void insertNode( E insertValue )
   {
      if ( root == null )
         root = new TreeNode<E>( insertValue ); // create the root node here
      else
         root.insert( insertValue ); // call the insert method
   } // end method insertNode

   // begin preorder traversal
   public void preorderTraversal()
   { 
      preorderHelper( root ); 
   } // end method preorderTraversal

   // recursive method to perform preorder traversal
   private void preorderHelper( TreeNode<E> node )
   {
      if ( node == null )
         return;

      System.out.printf( "%d ", node.data ); // output node data
      preorderHelper( node.leftNode );       // traverse left subtree
      preorderHelper( node.rightNode );      // traverse right subtree
   } // end method preorderHelper

   // begin inorder traversal
   public void inorderTraversal()
   { 
      inorderHelper( root ); 
   } // end method inorderTraversal

   // recursive method to perform inorder traversal
   private void inorderHelper( TreeNode<E> node )
   {
      if ( node == null )
         return;

      inorderHelper( node.leftNode );        // traverse left subtree
      System.out.printf( "%d ", node.data ); // output node data
      inorderHelper( node.rightNode );       // traverse right subtree
   } // end method inorderHelper

   // begin postorder traversal
   public void postorderTraversal()
   { 
      postorderHelper( root ); 
   } // end method postorderTraversal

   // recursive method to perform postorder traversal
   private void postorderHelper( TreeNode<E> node )
   {
      if ( node == null )
         return;

      postorderHelper( node.leftNode );      // traverse left subtree
      postorderHelper( node.rightNode );     // traverse right subtree
      System.out.printf( "%d ", node.data ); // output node data
   } // end method postorderHelper
} // end class Tree

这是我的驱动程序类，这是本书作为示例使用的片段：

// This program tests class Tree.
import java.util.Random;

public class TreeTest 
{
   public static void main( String args[] )
   {
      Tree tree = new Tree<E>();
      E value;
      Random randomNumber = new Random();

      System.out.println( "Inserting the following values: " );

      // insert 10 random integers from 0-99 in tree 
      for ( int i = 1; i <= 10; i++ ) 
      {
         value = randomNumber.nextInt( 100 );
         System.out.print( value + " " );
         tree.insertNode( value );
      } // end for

      System.out.println ( "\n\nPreorder traversal" );
      tree.preorderTraversal(); // perform preorder traversal of tree

      System.out.println ( "\n\nInorder traversal" );
      tree.inorderTraversal(); // perform inorder traversal of tree

      System.out.println ( "\n\nPostorder traversal" );
      tree.postorderTraversal(); // perform postorder traversal of tree
      System.out.println();
   } // end main
} // end class TreeTest

Answer 1

您的实施中几乎没有明显的错误。

首先，TreeNode和Tree类的泛型类型定义似乎是错误的。类似TreeNode和E的{{1}}具有可比性（即实现E接口。

因此，我认为您应该按照以下方式定义Comparable<E>和TreeNode类。

Tree

然后，当您使用class TreeNode<E extends Comparable<E>> { //other code } public class Tree<E extends Comparable<E>> { //other code }时，您应指定实际的泛型类型。

例如，您可以按如下方式使用树。

Tree

Answer 2

以下行错误

public void <E extends Comparable<TreeNode<E>>> insert( E insertValue )

应该是

public <E extends Comparable<TreeNode<E>>> void insert( E insertValue )

相反，但这不会解决你所有的问题。正确的TreeNode类应该如下所示

class TreeNode<E extends Comparable<E>> {

    TreeNode<E> leftNode; // left node
    E data; // node value
    TreeNode<E> rightNode; // right node

    // constructor initializes data and makes this a leaf node
    public TreeNode(E nodeData) {
        data = nodeData;
        leftNode = rightNode = null; // node has no children
    } // end TreeNode constructor

    // locate insertion point and insert new node; ignore duplicate values
    public void insert(E insertValue) {
        // insert in left subtree
        if (data.compareTo(insertValue) > 0) {
            // insert new TreeNode
            if (leftNode == null)
                leftNode = new TreeNode<E>(insertValue);
            else // continue traversing left subtree
                leftNode.insert(insertValue);
        } // end if
        else if (data.compareTo(insertValue) < 0) // insert in right subtree
        {
            // insert new TreeNode
            if (rightNode == null)
                rightNode = new TreeNode<E>(insertValue);
            else // continue traversing right subtree
                rightNode.insert(insertValue);
        } // end else if
    } // end method insert
} // end class TreeNode

您还需要将Tree的类定义更改为

public class Tree<E extends Comparable<E>> {

Answer 3

主要错误是：

public void <E extends Comparable<TreeNode<E>>> insert( E insertValue )

仅为方法定义新的通用参数E.它应该是唯一的：

public void insert( E insertValue )

然后：

  Tree<Integer> tree = new Tree<>();

向Tree提供实际的泛型类型参数。

BTW 稍短（new s）会更短：

树：

public void insertNode( E insertValue )
{
    root = insert( root, insertValue );
}

树节点：

public static TreeNode<E> insert( TreeNode<E> node, E insertValue )
{
    if (node == null)
    {
        return new TreeNode<E>( insertValue );
    }
    if ( data.compareTo(insertValue) > 0 ) 
    {
        node.leftNode = insert( node.leftNode, insertValue ); 
    }
    else if ( data.compareTo(insertValue) < 0 )
    {
        node.rightNode = insert( node.rightNode, insertValue );
    }
    return node;
}

Java Generic Tree Comparable

3 个答案: