标准偏差的小数位数

Question

有人能帮我弄清楚为什么我的小数在最后一行输出是错误的吗?

下面是我的输出:

Linkedlist持续时间总和:3111480
LinkedList平均值:31114
SD of LinkedList: 9.65113011397E12

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

HashSet: 33189
HashSet的均值:526
HashSet的Std Dev: 1.085445182E9
HashSet中变量个数:63

LinkedList(3111480)，Tree(74628)和HashSet(33189)的最大时间总和为3111480

LinkedList(31114)，Tree(1184)和HashSet(526)的最大平均时间是31114

LinkedList(9651130113970.000000)， Tree(5486010029.00)和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);