Два метода реализуют один и тот же алгоритм, один занимает больше времени выполнения, чем другой в Java - PullRequest
Новая
       36

Два метода реализуют один и тот же алгоритм, один занимает больше времени выполнения, чем другой в Java

0 голосов
/ 04 июня 2018

Я пытаюсь рассчитать время работы двух методов, используя new Date().getTime().два метода следуют одному и тому же алгоритму, и один из них увеличивает некоторые шаги, однако метод с меньшим количеством шагов занимает больше времени.

Я путаю это.Вот два метода: Этот первый метод использует меньше шагов и занимает больше времени: 

public void encryptFiles(List<BloomFilter> bfList1) {
    Matrix matrix2 = new Matrix(400,400);
    Matrix matrix3 = new Matrix(400,400);

    matrix2.setMat(value1);
    matrix3.setMat(value2);

    a2= matrix2.transpose();
    b2= matrix3.transpose();

    startTime2=new Date().getTime();
    for (BloomFilter bfList2 : bfList1) {
        Random raa = new Random();
        int g1 = raa.nextInt();
        double m1 = (double) ((double) Math.round(g1 * 10) / 10.0);

        List<double[]>  res1 = new ArrayList<>();
        double[] e1 = new double[400];
        double[] k1 = new double[400];

        Vector<Double> j = new Vector<Double>(400);
        Vector<Double> h = new Vector<Double>(400);

        //System.out.println("bloom filter in bloom filter list:" + Arrays.toString(bfList2.getBitSet().data));
        String bfName= bfList2.getName();
        for (int i = 0; i < s.size(); i++) {
            if (s.get(i) == 1) {
                j.add( (double) bfList2.getBitSet().getWord(i));
                h.add((double) bfList2.getBitSet().getWord(i));
            } else {
                j.add(0.5 * (bfList2.getBitSet().getWord(i))+m1);
                h.add(0.5 * (bfList2.getBitSet().getWord(i))+m1 );
            }
        }

        for (int u = 0; u < 400; u++) {
            for (int y = 0; y < 400; y++) {
                e1[u] +=a2[u][y]*j.get(y);
                k1[u] +=b2[u][y]*h.get(y);
            }
        }
        res1.add(e1);
        res1.add(k1);
        hasssh.put(bfName,res1 );
    }
    encryptedBFListInTime=(new Date().getTime())-startTime2;
    encryptedBFListInTime/=1000.0; 
    System.out.println("encrypt files only in "+encryptedBFListInTime);
}

, а следующий - второй метод использует больше шагов, но меньше времени: 

public  BloomFilterIndex encryptTree(BloomFilterIndex tree) {

    startTime9=new Date().getTime();
    for(int m=0;m<tree.root.children.size();m++){
        BloomFilterIndex.BFINode<Integer> n=(BloomFilterIndex.BFINode<Integer>)tree.root.children.get(m);
        encrypt(n);
    }
    end=new Date().getTime()-startTime9;
    //end1=end-startTime9;
    end/=1000.0;
    System.out.println("encrypt node in :"+end);
    return tree;
}

вызов следующего метода: 

public void encrypt(BloomFilterIndex.BFINode<Integer> root) {

    List<double[]> ress = new ArrayList<>();
    if (!root.isLeaf()) {
        c = new double[root.value.size()];
        // c=new double[4];
        for (int i = 0; i < root.value.size(); i++) {
        //  for(int i=0;i<4;i++){
            c[i] = root.value.getBitSet().getWord(i);
        }
        ress.add(c);
        root.value = null;
        root.value2 = ress;

        for (BloomFilterIndex.BFINode<Integer> g : root.children) {
            encrypt(g);
        }

    } else {
        //String bfName1= root.value.getName(); 
        double[] y = new double[400];
        double[] z = new double[400];
        Random r = new Random();
        Integer g1 = r.nextInt();
        double m5 = (double) ((double) Math.round(g1 * 10) / 10.0);
        Vector<Double> m6 = new Vector<Double>(400);
        Vector<Double> n1 = new Vector<Double>(400);

        for (int i = 0; i < s.size(); i++) {
            //  for(int i=0;i<400;i++){
            if (s.get(i) == 1) {
                m6.add((double) root.value.getBitSet().getWord(i));
                n1.add((double) root.value.getBitSet().getWord(i));
            } else {
                m6.add(0.5 * (root.value.getBitSet().getWord(i)) + m5);
                n1.add(0.5 * (root.value.getBitSet().getWord(i)) + m5);
            }
        }

        for (int i = 0; i < 400; i++) {
            for (int j = 0; j < 400; j++) {
                y[i] += a2[i][j] * m6.get(j);
                z[i] += b2[i][j] * n1.get(j);
            }
        }
        ress.add(y);
        ress.add(z);
        root.value = null;
        root.value2 = ress;
        //  hasssh1.put(bfName1, ress);
    }
}

, где проблема, пожалуйста.

1 Ответ

0 голосов
/ 04 июня 2018

Время выполнения зависит от критических участков кода.Чтобы определить критические разделы, помните, что они содержатся в наиболее глубоко вложенных циклах for или while.Другие строки кода выполняются только один раз!

Во втором методе вы вызываете вспомогательный метод из WITHIN цикла for!Это означает, что вы выполняете ALL циклов for и вложенных циклов for в вспомогательном методе tree.root.children.size() раз, потому что вспомогательный метод вызывается столько раз!

Когда вы думаете о вложенныхциклы, умножение! например, 

for (int i= 0; i < 5; i++) {
  for (int j= 0; j < 5; j++) {
    DOTHING();
  }
}

DOTHING будет выполняться 25 раз!Зачем?Внешний цикл выполняется 5 раз!Вложенный цикл выполняется 5 раз!5 x 5 = 25 раз!

Вы вызываете этот вспомогательный метод и все его вложенные циклы for из цикла for - все равно что добавить еще один вложенный цикл.В этом разница между n * n исполнением и n * n * n или n ^ 2 против n ^ 3!Надеюсь, это поможет!

...