小数位的标准偏差？

Question

有人可以帮我弄清楚为什么我的小数在输出的最后一行是错误的？

这里是我的输出：

总和的LinkedList的持续时间：3111480
平均的LinkedList的：31114
的LinkedList的SD：9.65113011397E12

总和的时间树：74628
树的平均值：1184
树的SD：5.486010029E9
树中的变量数：63

总和的时间HashSet的：33189
平均一个HashSet：526
标准偏差的HashSet的：1.085445182E9
在HashSet的一些变量：63

的时间链表的最大总和（3111480）树（74628）和HashSet的（33189）是3111480

的时间链表（31114），树（1184）和HashSet的（526）的最大平均为链表31114

最大标准偏差（9651130113970.000000），树（5486010029.0 0）和HashSet的（1085445182.00）是9651130113970.00 线，这是错误

import java.util.*; 
import java.util.TreeSet; 

public class DataStructureTimingChris 
{ 
public static void main(String[] args) 
{ 
int MAXIMUM = 100;//initializing the maximum integer 
int MINIMUM = 1;//initializing the minimum integer 
int mean1 = 0; 
int mean2 = 0; 
int mean3 = 0; 

//initializing the generation of random integers 
Random randomGenerator = new Random(); 

//setting the range of integers from 1 to 1,000,000 
int range = MAXIMUM - MINIMUM + 1; 

//Array list for Hash Codes 
ArrayList<Integer> randomNumbersHashCodes = new ArrayList<Integer>(5); 

//Array list for Storage 
ArrayList<Integer> randomNumbersStorage = new ArrayList<Integer>(5); 

//for loop to generate 1,000,000 integers 

for (int index = 1; index <= 100; ++index) 
{ 
    int randomInt = randomGenerator.nextInt(range) + MINIMUM; 
    randomNumbersStorage.add(randomInt); 
    randomNumbersHashCodes.add(String.valueOf(randomInt).hashCode());//storing randomly generated numbers in a ArrayList 
}//end of for loop for random number generation and storage in an ArrayList 


//array list to make string after converting int 
ArrayList<String> randomNumbersStrg = new ArrayList<String>(randomNumbersHashCodes.size()); 

for (Integer myInt : randomNumbersHashCodes) 

{ 
    randomNumbersStrg.add(String.valueOf(myInt)); 
} 

//initializing LinkedList 

List<String> linkedList = new LinkedList<String>(); 

//adding generated hashcodes to Linked List 

linkedList.addAll(randomNumbersStrg); 

System.out.println(); 

List<Long> durations = new ArrayList<>(randomNumbersHashCodes.size()); 

for (int n : randomNumbersHashCodes) 
{ 
    long start = System.nanoTime(); 
    randomNumbersHashCodes.contains(n); // true 
    long end = System.nanoTime(); 
    durations.add(end - start); 
} 

//Initialize the tree 
TreeSet<String> tree = new TreeSet<String>(); 

//for loop for tree to add randomNumbersStrg to tree 
for (int x = 1; x <= 100; x++) 
{ 
    tree.addAll(randomNumbersStrg); 
} 

//for loop to get times of tree 
List<Long> durations2 = new ArrayList<>(tree.size()); 

for (String m : tree) 

{ 
    long start2 = System.nanoTime(); 
    tree.contains(m); // true 
    long end2 = System.nanoTime(); 
    durations2.add(end2 - start2); 
} 

//to calculate mean and SD of Durations 
int sum = 0; 
double sd = 0; 
for (int toCalcSum = 0; toCalcSum < durations.size(); toCalcSum++) 
{ 
    sum += durations.get(toCalcSum); 
} 

for (int toCalcSD = 0; toCalcSD < durations.size(); toCalcSD++) 
{ 
    sd += ((durations.get(toCalcSD) - sum) * 
     (durations.get(toCalcSD) - sum))/(durations.size() - 1); 
} 

mean1 = sum/durations.size(); 


//to print out the results of Linked List 
System.out.println("Sum of duration of Linkedlist: " + sum); 
System.out.println("Mean of LinkedList: " + mean1); 
System.out.println("SD of LinkedList: " + sd); 
System.out.println(); 



//to calculate mean and SD of Durations2 
int sum2 = 0; 

double sd2 = 0; 

for (int toCalcSum2 = 0; toCalcSum2 < durations2.size(); toCalcSum2++) 

{ 
    sum2 += durations2.get(toCalcSum2); 
} 

for (int toCalcSD2 = 0; toCalcSD2 < durations2.size(); toCalcSD2++) 
{ 

    sd2 += ((durations2.get(toCalcSD2) - sum2) * 
     (durations2.get(toCalcSD2) - sum2))/
     (durations2.size() - 1); 
} 

    mean2 = sum2/durations2.size(); 

    //to print out the results of Tree 

    System.out.println("Sum of time for Tree: " + sum2); 
    System.out.println("Mean of Tree: " + mean2); 
    System.out.println("SD of Tree: " + sd2); 
    System.out.println("# of variables in Tree: " + durations2.size()); 
    System.out.println(); 



//to find Hashset 
HashSet<String> hash = new HashSet<>(); 

for (int x = 1; x < randomNumbersStrg.size(); x++) 

{ 
    hash.addAll(randomNumbersStrg); 
} 

    int sum3 = 0; 
double sd3 = 0; 

//for loop to get times of hash 
List<Long> durationsHashSet = new ArrayList<>(hash.size()); 

for (String x : hash) 
{ 
    long start3 = System.nanoTime(); 
    hash.contains(x); // true 
    long end3 = System.nanoTime(); 
    durationsHashSet.add(end3 - start3); 
} 

for (int toCalcSum3 = 0; toCalcSum3 < durationsHashSet.size(); toCalcSum3++) 

{ 
    sum3 += durationsHashSet.get(toCalcSum3); 
} 

for (int toCalcSD3 = 0; toCalcSD3 < durationsHashSet.size(); toCalcSD3++) 

{ 
    sd3 += ((durationsHashSet.get(toCalcSD3) - sum3) * 
      (durationsHashSet.get(toCalcSD3) - sum3))/(durationsHashSet.size() - 1); 
} 

mean3 = sum3/durationsHashSet.size(); 

//to print out the results of Hashset 
System.out.println("Sum of time for HashSet: " + sum3); 
System.out.println("Mean of HashSet: " + mean3); 
System.out.println("Std Dev of HashSet: " + sd3); 
System.out.println("Number of variables in HashSet: " + durationsHashSet.size()); 



//to compare mean and standard Deviation 
System.out.println(); 
System.out.printf("The maximum sum of time for LinkedList(%d)," 
     + "Tree(%d) and HashSet(%d) is %d%n%n", sum, sum2, sum3, 
     maximum(sum, sum2, sum3)); 
System.out.printf("The maximum mean of time for LinkedList(%d)," 
     + "Tree(%d) and HashSet(%d) is %d%n%n", mean1, mean2, mean3, 
     maximum(mean1, mean2, mean3)); 
System.out.printf("Maximum standard deviation for LinkedList(%f), " 
     + "Tree(%.2f) and HashSet(%.2f) is %.2f%n%n", sd, sd2, sd3, maximum(sd, sd2, sd3)); 



}// end of main method 



public static <T extends Comparable<T>> T maximum(T fromLinkedList, T fromTree, T fromHashSet) 

{ 

    T max = fromLinkedList; // assume fromLinkedList is initially the largest 

    if (fromTree.compareTo(max) > 0) 

    max = fromTree; // fromTree is the largest so far 

    if (fromHashSet.compareTo(max) > 0) 

    max = fromHashSet; // fromHashSet is the largest 

    return max; // returns the largest object 

} 
}//end of class 

Answer 1

你需要计算每个元件与方差贡献时减去平均值（不和） - 然后平方根方差得到标准差。

例如：

mean1 = sum/durations.size(); 
double var = 0; 
for (int toCalcSD = 0; toCalcSD < durations.size(); toCalcSD++) 
{ 
    var += ((durations.get(toCalcSD) - mean1) * 
     (durations.get(toCalcSD) - mean1))/(durations.size() - 1); 
} 
sd = Math.sqrt(var);