如何显示（输出）在二进制搜索树中查找值所需的迭代次数？

Question

我已经编写了这个程序来创建一个BST，用户可以创建一个树，以及在BST中搜索一个值，但我需要帮助来输出找到这个数字所需的迭代次数而我不这样做知识。我已经创建了一个变量“迭代”，但我不知道如何创建一个方法来收集这个数字。任何想法如何在我的程序中实现这一点，如何找到该数字并打印出来？

 import java.util.Scanner;  


 /* Class Node */
 class Node  


{
 Node left, right;
 int data;



 /* Constructor */
 public Node(int n)
 {
     left = null;
     right = null;
     data = n;
 }         

/* Function to get data from node */
public int getData() 
{
    return data;
}

/* Function to get left node */
public Node getLeft() 
{
    return left;
}

  /* Function to get right node */
public Node getRight()
{
    return right;
}
}

/* Class BST */
class BST

{

 private Node root;
 private int iterations;
 /* Constructor */
 public BST()
 {
     root = null;
 }
 /* Functions to insert data */
 public void insert(int data)
 {
     root = insert(root, data);
 }
 /* Function to insert data recursively */
 private Node insert(Node node, int data)
 {
     if (node == null)
         node = new Node(data);
     else
     {
         if (data <= node.data)
             node.left = insert(node.left, data);
         else
             node.right = insert(node.right, data);
     }
     return node;
 }


  /* Functions to search for an element */
public boolean search(int val) 
{
    iterations=0;
    iterations++;
    return search(root, val);
}



/* Function to search for an element recursively */
private boolean search(Node r, int val) 
{
    iterations=0;
    boolean found = false;
    while ((r != null) && !found) 
    {
        int rval = r.getData();
        if (val < rval){
            r = r.getLeft();
        }

        else if (val > rval){   
            r = r.getRight();
        }

        else 
        {
            found = true;
            break;
        }
        found = search(r, val);

    }

    return found;
}

  public int getLastIterationCount(){
return iterations;
 }

 }
 /* Class LinkedListBST */
 public class LinkedListBST
 {


 public static void main(String[] args)

 {  


     Scanner scan = new Scanner(System.in);
     /* Creating object of BST */
     BST bst = new BST(); 
     System.out.println("Linked List Binary Search Tree Test\n");          
     char ch;
     /*  Accept input  */
     do    
     {
         System.out.println("Enter integer element to insert");
         bst.insert( scan.nextInt() );                     



         System.out.println("\nDo you want to continue (Type y or n) \n");
         ch = scan.next().charAt(0);  


     } while (ch == 'Y'|| ch == 'y');   
     System.out.println("\nEnter an element to be searched: ");
    Scanner sc = new Scanner(System.in);
    System.out.println("Search result : " + bst.search(sc.nextInt()));

    System.out.println(getLastIterationCount()); //ISSUE IS HERE

    sc.close();

 }

}

Answer 1

我会创建一个名为iterations的全局int变量，该变量最初为零。

然后，在你拥有的每个方法的循环中，增加iterations。在每个方法的开头，您必须将iterations重置为零。

然后，编写一个名为getLastIterationCount的方法，它返回迭代：

public int getLastIterationCount(){
    return iterations;
}

如果要查找使用了多少次迭代，请调用getIterationCount()并打印结果。例如，要查看preorder（）需要多少次迭代，请写下：

preorder(...);
System.out.println(bst.getLastIterationCount());

以下是您的BST类的外观：

/* Class BST */
class BST
{
 private Node root;
 private int iterations;

... 

  /* Functions to search for an element */
public boolean search(int val) 
{
    iterations=0;
    iterations++;
    return search(root, val);
}

/* Function to search for an element recursively */
private boolean search(Node r, int val) 
{
    iterations=0;
    ...
    return found;
}

public int getLastIterationCount(){
    return iterations;
}

}

Answer 2

定义一个名为SearchResult的辅助类，它包含两个成员：found和iterations。

你的search(..)方法返回这个类，而不是boolean。

Answer 3

我只需要设置iterations = 1然后稍后递增并使用'bst.getLastIterationCount（）'而不是'getLastIterationCount（）'打印出来，因为该方法在bst类中。