2012-10-01 2 views
1

J'écris un programme qui compte les opérations de mergesort et de quicksort. Je ne sais pas où je devrais mettre le compte ++; (pour compter les opérations) dans. Quelqu'un peut-il m'aider avec ceci?comment compter les opérations de mergesort et quicksort en Java?

Voici les codes pour le tri par fusion et le tri rapide.

MERGE SORT:

public void mergeSort(int [] data, int first, int n){ 

    int n1; 
    int n2; 

    if (n>1) { 
     n1 = n/2; 
     n2 = n-n1;   
     mergeSort(data,first,n1); 
     mergeSort(data,first+n1,n2); 
     merge(data,first,n1,n2); 
    } 

}//ends mergeSort method. 

public void merge(int [] data, int first, int n1, int n2){ 
    int [] temp = new int[n1+n2]; 
    int copied = 0, copied1 = 0, copied2 = 0, i; 

    while((copied1<n1) && (copied2<n2)){ 

     if(data[first+copied1] < data[first + n1 + copied2]) 
     temp[copied++] = data[first + (copied1++)]; 
     else 
     temp[copied++] = data[first + n1 + (copied2++)]; 
    } 

    while (copied1<n1) 
     temp[copied++] = data[first + (copied1++)]; 
    while(copied2<n2) 
     temp[copied++] = data[first + n1 + (copied2++)]; 

    for (i=0;i<n1+n2;i++) 
     data[first+i] = temp[i]; 
}//ends merge method. 

Et voici le code pour SORT RAPIDE:

public void quickSort(int data[], int left, int right){ 

    int index = partition(data, left, right); 
    if (left < index - 1){    
     quickSort(data, left, index - 1);  
    } 
    if (index < right){    
     quickSort(data, index, right); 
    } 
}//ends quickSort method. 

int partition(int data[], int left, int right){ 

    int i = left, j = right; 
    int tmp; 
    int pivot = data[(left + right)/2]; 

    while (i <= j) 
    { 
     while (data[i] < pivot) 
     i++; 
     while (data[j] > pivot) 
     j--; 
     if (i <= j) 
     { 

      tmp = data[i]; 
      data[i] = data[j]; 
      data[j] = tmp; 
      i++; 
      j--; 
     } 
    } 
    return i; 
}//ends partition method. 

Répondre

0

Dans tri par fusion, au-dessous méthode est exactement celui qui fait les choses: -

merge(data,first,n1,n2); 

Donc, mettez-en un count ++ .. il

Et tri rapide .. il est: -

partition(data, left, right) 

Alors, ajoutez nombre ++ .. il

Votre autre méthode appelle: - mergesort() et quicksort() sont juste appels récursifs .. Ils conduiront finalement à ces deux seuls methods seulement ..

Mais finalement, tout dépend de ce que vous entendez mon « compte les opérations » .. Qu'est-ce que vous prenez comme operation d'être est cruciale ..

Il est peut-être un method execution ou every statement peut être une opération .. Ou votre boucle .. Cela peut signifier n'importe quoi ..

3

Vous devez mettre le ++ où vous avez une "opération". Ce que vous appelez une opération est à vous. Je pourrais être une comparaison, un échange ou chaque ligne. Vous avez le choix de ce qui vous convient.

1

En supposant que vous faites une analyse "big O", votre "count of operations" est le nombre d'itérations de la boucle la plus interne.

  • Pour votre exemple QuickSort, c'est facile: mettre votre compteur après while (i <= j)
  • Pour votre exemple mergesort, vous aurez besoin de mettre votre compteur dans chacune des while boucles (je ne l'ai pas regardé de près ces boucles, mais ils semblent faire beaucoup plus que nécessaire).

Ce nombre ne pas vous dire le nombre d'opérations que vous réalisez, juste le nombre « grand O » des opérations. Alors que MergeSort et QuickSort peuvent avoir les mêmes caractéristiques de "gros O" (et devraient donc avoir des comptes similaires), la quantité de travail effectuée à l'intérieur de la boucle la plus interne sera différente.