如何创建一个在Java中生成随机值的方法？

Question

我有二进制搜索树代码（它是硬代码）做（插入，删除，最大值，最小值，排序和查找），我想为BST学习效率。我想要创建一个随机方法来生成1000个数字，而不是输入数字。 如何创建此方法？

public class BinarySearchTree { 


private Node root; 

    private static class Node { 
     Node parent; 
     Node left; 
     Node right; 
     int data; 

     Node(int data) { 
      this.data = data; 
     } 

     @Override 
     public String toString() { 
      return "" + data; 
     } 
    } 


    public void insert(int data) { 
     root = insert(root, data); 
    } 

    public Node insert(Node node, int data) { 
     if(node == null) { 
      node = new Node(data); 
     } else if(data < node.data) { 
      node.left = insert(node.left, data); 
      node.left.parent = node; 
     } else { 
      node.right = insert(node.right, data); 
      node.right.parent = node; 
     } 
     return node; 
    } 

    private void swap(Node a, Node b) { 

     if(a.parent == null) { 
      root = b; 
     } else if(a == a.parent.left) { 
      a.parent.left = b; 
     } else { 
      a.parent.right = b; 
     } 

     if(b != null) { 
      b.parent = a.parent; 
     } 
    } 

    public void delete(int data) { 
     delete(root, data); 
    } 

    public void delete(Node node, int data) { 

     if(node == null) { 
      return; 
     } 
     else if (data == node.data) { 
      if(node.left == null) { 
       swap(node, node.right); 
      } 
      else if(node.right == null) { 
       swap(node, node.left); 
      } 
      else { 
       Node minNode = node.right; 
       while(minNode.left != null) { 
        minNode = minNode.left; 
       } 
       if(minNode.parent != node) { 
        swap(minNode, minNode.right); 
        minNode.right = node.right; 
        minNode.right.parent = minNode; 
       } 

       swap(node, minNode); 
       minNode.left = node.left; 
       minNode.left.parent = minNode; 
      } 
     } 
     // Continue searching in the left subtree. 
     else if(data < node.data) { 
      delete(node.left, data); 
     } 
     // Continue searching in the right subtree. 
     else { 
      delete(node.right, data); 
     } 
    } 

    public boolean lookup(int data) { 
     return lookup(root, data); 
    } 

    public boolean lookup(Node node, int data) { 
     if(node == null) { 
      // Can't find it. 
      return false; 
     } else if(data == node.data) { 
      // Found it. 
      return true; 
     } else if(data < node.data) { 
      // Search left subtree. 
      return lookup(node.left, data); 
     } else { 
      // Search right subtree. 
      return lookup(node.right, data); 
     } 
    } 

    public int minValue() { 
     return minValue(root); 
    } 

    public int minValue(Node node) { 
     Node cursor = node; 
     while(cursor.left != null) { 
      cursor = cursor.left; 
     } 
     return cursor.data; 
    } 

    public int maxValue() { 
     return maxValue(root); 
    } 

    public int maxValue(Node node) { 
     Node cursor = node; 
     while(cursor.right != null) { 
      cursor = cursor.right; 
     } 
     return cursor.data; 
    } 

    public void inorderTraversal() { 
     inorderTraversal(root); 
    } 

    private void inorderTraversal(Node node) { 
     if(node != null) { 
      inorderTraversal(node.left); 
      System.out.print(node.data + " "); 
      inorderTraversal(node.right); 
     } 
    } 

    public static void main(String[ ] args) { 
     BinarySearchTree bst = new BinarySearchTree(); 
     int[ ] input = new int[ ] { 5, 10, 3, 9, 7, 8 , 1 , 4 , 6 , 10}; 

     for(int i : input) { 
      bst.insert(i); 
     } 

     bst.delete(5); 
     bst.delete(10); 
     bst.delete(3); 
     bst.delete(7); 

     System.out.println("\n Sorted :"); 
     bst.inorderTraversal(); 

     System.out.println("\nMax Value:"); 
     System.out.println(bst.maxValue()); 
     System.out.println("\n Min Value:"); 
     System.out.println(bst.minValue()); 

     System.out.println(bst.lookup(1)); 
    } 
} 

Answer 1

这会给你MIN和MAX 1000个之间的随机整数，包括MIN但不包括MAX。

int MIN; 
int MAX; 
int[] randoms = new int[1000]; 
Random randGen = new Random(); 

for(int i = 0; i < randoms.length; i++) 
{ 
    randoms[i] = MIN + randGen.nextInt(MAX - MIN)); 
} 

Answer 2

您可能会感兴趣的java.util.Random：

import java.util.Random; 
... 
Random random = new Random(System.currentTimeMillis()); 
random.nextInt(); 

注意Random只创建伪随机数，所以你必须使用足够独特的种子。

Answer 3

我第二个java.util.Random建议。你真的想存储它们的一个数组还是你想要随机发生器的随机数在0和999之间，1000次？这里有一个函数来获取它们的数组，但我只是放弃数组并循环遍历Random 1000次。

public static int[] generateRandomNumbers(int size) { 
    if (size <= 0) { 
     throw new IllegalArgumentException("size must be greater than 0"); 
    } 
    Random random = new Random(System.currentTimeMillis()); 
    int[] results = new int[ size ]; 
    for (int i = 0; i < size; i++) { 
     results[ i ] = random.nextInt(size); 
    } 
    return results; 
} 

......其他所有事情都是平等的，让你的主人这样，你有一个工作程序。我不知道这是否正确，它的工作原理...

public static void main(String[] args) { 
    BinarySearchTree bst = new BinarySearchTree(); 
    int[] randoms = generateRandomNumbers(1000); 
    for (int i : randoms) { 
     bst.insert(i); 
    } 

    bst.delete(randoms[ 5 ]); 
    bst.delete(randoms[ 10 ]); 
    bst.delete(randoms[ 3 ]); 
    bst.delete(randoms[ 7 ]); 

    System.out.println("\n Sorted :"); 
    bst.inorderTraversal(); 

    System.out.println("\nMax Value:"); 
    System.out.println(bst.maxValue()); 
    System.out.println("\n Min Value:"); 
    System.out.println(bst.minValue()); 

    System.out.println(bst.lookup(randoms[ 1 ])); 
    System.out.println(bst.lookup(randoms[ 999 ])); 
}