标准偏差小数位？

Question

谁能帮我弄清楚为什么最后一行输出的小数点是错误的？？

这是我的输出：

Sum of duration of Linkedlist: 3111480
Mean of LinkedList: 31114
SD of LinkedList: 9.65113011397E12

Sum of time for Tree: 74628
Mean of Tree: 1184
SD of Tree: 5.486010029E9
Number of variables in Tree: 63

Sum of time for HashSet: 33189
Mean of HashSet: 526
Std Dev of HashSet: 1.085445182E9
Number of variables in HashSet: 63

The maximum sum of time for LinkedList(3111480),Tree(74628) and HashSet(33189) is 3111480

The maximum mean of time for LinkedList(31114),Tree(1184) and HashSet(526) is 31114

Maximum standard deviation for LinkedList(9651130113970.000000), Tree(5486010029.00) and HashSet(1085445182.00) is 9651130113970.00 line that is wrong

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);

标准偏差小数位？

standard deviation decimal places?

java

linked-list