64ビットWindows10でJavaプロセスあたりの最大メモリ量は？

Question

私は8GBのRAMを搭載した64bit windows10オペレーティングシステムを使用しています。私のeclipse.iniファイルは以下の通りです：

-startup 
plugins/org.eclipse.equinox.launcher_1.3.100.v20150511-1540.jar 
--launcher.library 
plugins/org.eclipse.equinox.launcher.win32.win32.x86_64_1.1.300.v20150602-1417 
-product 
org.eclipse.epp.package.jee.product 
--launcher.defaultAction 
openFile 
--launcher. 
-XX:MaxPermSize 
-Xms4000m 
-Xmx8000m 
-showsplash 
org.eclipse.platform 
--launcher.XXMaxPermSize 
-Xms4000m 
-Xmx8000m 
--launcher.defaultAction 
openFile 
-vm C:\Program Files\Java\jre1.8.0_91\bin\javaw.exe 
--launcher.appendVmargs 
-vmargs 
-Dosgi.requiredJavaVersion=1.7 
-Xms4000m 
-Xmx8000m 

バイナリ検索ツリーに100000の値を挿入しようとしています。私はBSTで10000の値を入力しようとすると問題なく動作しますが、BSTに100000の値を挿入しようとすると、JVMのヒープサイズの問題に直面しています。私はまた、次のことを行っていることは ステップ - 構成 を実行するために行く - VM引数セクション で - - 引数 に行く、私は次のように私のコードがある-Xms4000m -Xmx8000m

を追加しました：

public class BinarySearchTree<AnyType extends Comparable<? super AnyType>> 
{ 
/** 
    * Construct the tree. 
    */ 
public BinarySearchTree() 
{ 
    root = null; 
} 

/** 
    * Insert into the tree; duplicates are ignored. 
    * @param x the item to insert. 
    */ 
public void insert(AnyType x) 
{ 
    root = insert(x, root); 
} 

/** 
    * Remove from the tree. Nothing is done if x is not found. 
    * @param x the item to remove. 
    */ 
public void remove(AnyType x) 
{ 
    root = remove(x, root); 
} 

/** 
    * Find the smallest item in the tree. 
    * @return smallest item or null if empty. 
    */ 
public AnyType findMin() 
{ 
    if(isEmpty()) 
     return null; 
    return findMin(root).element; 
} 

/** 
    * Find the largest item in the tree. 
    * @return the largest item of null if empty. 
    */ 
public AnyType findMax() 
{ 
    if(isEmpty()) 
     return null; 
    return findMax(root).element; 
} 

/** 
    * Find an item in the tree. 
    * @param x the item to search for. 
    * @return true if not found. 
    */ 
public boolean contains(AnyType x) 
{ 
    return contains(x, root); 
} 

/** 
    * Make the tree logically empty. 
    */ 
public void makeEmpty() 
{ 
    root = null; 
} 

/** 
    * Test if the tree is logically empty. 
    * @return true if empty, false otherwise. 
    */ 
public boolean isEmpty() 
{ 
    return root == null; 
} 

/** 
    * Print the tree contents in sorted order. 
    */ 
public void printTree() 
{ 
    if(isEmpty()) 
     System.out.println("Empty tree"); 
    else 
     printTree(root); 
} 

/** 
    * Internal method to insert into a subtree. 
    * @param x the item to insert. 
    * @param t the node that roots the subtree. 
    * @return the new root of the subtree. 
*/ 
private BinaryNode<AnyType> insert(AnyType x, BinaryNode<AnyType> t) 
{ 
    if(t == null) 
     return new BinaryNode<>(x, null, null); 

    int compareResult = x.compareTo(t.element); 

    if(compareResult < 0) 
     t.left = insert(x, t.left); 
    else if(compareResult > 0) 
     t.right = insert(x, t.right); 
    else 
     ; // Duplicate; do nothing 
    return t; 
} 

/** 
    * Non recursive method, created by LR - 29-092014 

private BinaryNode<AnyType> insert(AnyType x, BinaryNode<AnyType> t) 
{ 
    if(t == null) 
     return new BinaryNode<>(x, null, null); 

    while (t != null) {  
     int compareResult = x.compareTo(t.element); 

     if(compareResult < 0) 
      t = t.left; 
     else if(compareResult > 0) 
      t = t.right; 
     else 
      ; // Duplicate; do nothing 
    } 
     return t; 
}*/ 

/** 
    * Internal method to remove from a subtree. 
    * @param x the item to remove. 
    * @param t the node that roots the subtree. 
    * @return the new root of the subtree. 
    */ 
private BinaryNode<AnyType> remove(AnyType x, BinaryNode<AnyType> t) 
{ 
    if(t == null) 
     return t; // Item not found; do nothing 

    int compareResult = x.compareTo(t.element); 

    if(compareResult < 0) 
     t.left = remove(x, t.left); 
    else if(compareResult > 0) 
     t.right = remove(x, t.right); 
    else if(t.left != null && t.right != null) // Two children 
    { 
     t.element = findMin(t.right).element; 
     t.right = remove(t.element, t.right); 
    } 
    else 
     t = (t.left != null) ? t.left : t.right; 
    return t; 
} 

/** 
    * Internal method to find the smallest item in a subtree. 
    * @param t the node that roots the subtree. 
    * @return node containing the smallest item. 
    */ 
private BinaryNode<AnyType> findMin(BinaryNode<AnyType> t) 
{ 
    if(t == null) 
     return null; 
    else if(t.left == null) 
     return t; 
    return findMin(t.left); 
} 

/** 
    * Internal method to find the largest item in a subtree. 
    * @param t the node that roots the subtree. 
    * @return node containing the largest item. 
    */ 
private BinaryNode<AnyType> findMax(BinaryNode<AnyType> t) 
{ 
    if(t != null) 
     while(t.right != null) 
      t = t.right; 

    return t; 
} 

/** 
    * Internal method to find an item in a subtree. 
    * @param x is item to search for. 
    * @param t the node that roots the subtree. 
    * @return node containing the matched item. 
    */ 
private boolean contains(AnyType x, BinaryNode<AnyType> t) 
{ 
    if(t == null) 
     return false; 

    int compareResult = x.compareTo(t.element); 

    if(compareResult < 0) 
     return contains(x, t.left); 
    else if(compareResult > 0) 
     return contains(x, t.right); 
    else 
     return true; // Match 
} 

/** 
    * Internal method to print a subtree in sorted order. 
    * @param t the node that roots the subtree. 
    */ 
private void printTree(BinaryNode<AnyType> t) 
{ 
    if(t != null) 
    { 
     printTree(t.left); 
     System.out.println(t.element); 
     printTree(t.right); 
    } 
} 

/** 
    * Internal method to compute height of a subtree. 
    * @param t the node that roots the subtree. 
    */ 
private int height(BinaryNode<AnyType> t) 
{ 
    if(t == null) 
     return -1; 
    else 
     return 1 + Math.max(height(t.left), height(t.right));  
} 

// Basic node stored in unbalanced binary search trees 
private static class BinaryNode<AnyType> 
{ 
     // Constructors 
    BinaryNode(AnyType theElement) 
    { 
     this(theElement, null, null); 
    } 

    BinaryNode(AnyType theElement, BinaryNode<AnyType> lt, BinaryNode<AnyType> rt) 
    { 
     element = theElement; 
     left  = lt; 
     right = rt; 
    } 

    AnyType element;   // The data in the node 
    BinaryNode<AnyType> left; // Left child 
    BinaryNode<AnyType> right; // Right child 
} 


    /** The tree root. */ 
private BinaryNode<AnyType> root; 


} 

そして、ここにある私のメイン（）

public static void main(String [ ] args) 
{ 
    BinarySearchTree<Integer> t = new BinarySearchTree<>(); 
    final int NUMS = 100000; // must be even 
    for(int i = 1; i <= NUMS; i++) 
    { 
     t.insert(i); 
    } 

} 

と、私は次の例外を取得しています

Exception in thread "main" java.lang.StackOverflowError 

以下の方法では、具体的に太線で

private BinaryNode<AnyType> insert(AnyType x, BinaryNode<AnyType> t) 
{ 
    if(t == null) 
     return new BinaryNode<>(x, null, null); 

    int compareResult = x.compareTo(t.element); 

    if(compareResult < 0) 
     t.left = insert(x, t.left); 
    else if(compareResult > 0) 
     **t.right = insert(x, t.right);** 
    else 
     ; // Duplicate; do nothing 
    return t; 
} 

しかし残念ながら、私は同じエラーを取得しています。誰かが、コード、構成、またはeclipse.iniファイルで何が問題なのかを教えてください。

Answer 1

StackOverflowErrorは、メソッドの再帰が深すぎることを意味します。これは、10k +深さなどの深い再帰を必要とするか、バグがあることを示します。

OutOfMemoryErrorでヒープが不足している場合は、ヒープサイズを修正するか、ヒープを少なくするようにプログラムを修正することが考えられます。

この場合、バランスのとれたツリーの場合、奥行きはO（log2（n））でなければなりませんが、ツリーのバランスが取れていません。

すなわち、あなたのツリーは、効果的に、それがリンクされたリストになっており、この

1 \ 
    2 \ 
    3 \ 
     4 \ 
     5 \ 
      6 \ always more to the right. 

のように見え、そして、リスト内の要素の数は、スタックが1つの以上の要素を追加して行く必要が深さです。

プログラムではスタックの深さを-Xssに増やすことができます（eclipseではなく）。ただし、計画がリンクリストではなくツリーを実装する場合は、バランスの取れたツリーにすることをお勧めします（または、 ）