Nota: la presunta domanda duplicata è, penso, principalmente correlata al confronto "<" e ">", ma non al confronto "==" e quindi non risponde alla mia domanda sulle prestazioni dell'operatore "=="."==" nella matrice ordinata non è più veloce della matrice non ordinata?
Per molto tempo ho creduto che "l'elaborazione" di una matrice ordinata dovesse essere più veloce di una matrice non ordinata. In un primo momento ho pensato che l'utilizzo di "==" in array ordinato dovrebbe essere più veloce di in ordine indifferenziati perché - immagino - di come funziona la predizione dei salti:
UNSORTEDARRAY:
5 == 100 F
43 == 100 F
100 == 100 T
250 == 100 F
6 == 100 F
(other elements to check)
SortedArray:
5 == 100 F
6 == 100 F
43 == 100 F
100 == 100 T
(no need to check other elements, so all are F)
quindi suppongo che SORTEDARRAY dovrebbe essere più veloce di UNSORTEDARRAY, ma oggi ho usato il codice per generare 2 array in un'intestazione da testare e la previsione delle filiali sembrava non funzionare come pensavo.
ho generato un array misti e un array ordinato di prova:
srand(time(NULL));
int UNSORTEDARRAY[524288];
int SORTEDARRAY[sizeof(UNSORTEDARRAY)/sizeof(int)];
for(int i=0;i<sizeof(SORTEDARRAY)/sizeof(int);i++){
SORTEDARRAY[i]=UNSORTEDARRAY[i]=rand();
}
sort(SORTEDARRAY,SORTEDARRAY+sizeof(SORTEDARRAY)/sizeof(int));
string u="const int UNSORTEDARRAY[]={";
string s="const int SORTEDARRAY[]={";
for(int i=0;i<sizeof(UNSORTEDARRAY)/sizeof(int);i++){
u+=to_string(UNSORTEDARRAY[i])+",";
s+=to_string(SORTEDARRAY[i])+",";
}
u.erase(u.end()-1);
s.erase(s.end()-1);
u+="};\n";
s+="};\n";
ofstream out("number.h");
string code=u+s;
out << code;
out.close();
modo per testare, basta contare se il valore è == RAND_MAX/2 così:
#include "number.h"
int main(){
int count;
clock_t start = clock();
for(int i=0;i<sizeof(SORTEDARRAY)/sizeof(int);i++){
if(SORTEDARRAY[i]==RAND_MAX/2){
count++;
}
}
printf("%f\n",(float)(clock()-start)/CLOCKS_PER_SEC);
}
esecuzione 3 orari:
UNSORTEDARRAY
0.005376
0.005239
0.005220
SortedArray
0.005334
0.005120
0.005223
sembra una piccola differenza di prestazioni, quindi non ci credevo e poi ha cercato di cambiare "SortedArray [i] == RAND_MAX/2" a "SortedArray [i]> RAND_MAX/2" per vedere se ha fatto la differenza:
UNSORTEDARRAY
0.008407
0.008363
0.008606
SortedArray
0.005306
0.005227
0.005146
questa volta c'è una grande differenza.
"==" nella matrice ordinata non è più veloce della matrice non ordinata? Se sì, perché ">" nella matrice ordinata è più veloce di una matrice non ordinata, ma "==" non lo è?
relativi ad una delle domande più upvoted di tutti i tempi: http://stackoverflow.com/questions/11227809/why-is- elaborazione-a-ordinata-matrice-più veloce-di-un-unsorted-array –
"Credo che" l'elaborazione "di una matrice ordinata dovrebbe essere più veloce della matrice non ordinata": prova a rispondere a te stesso perché pensi che sia vero per questo algoritmo. Cioè - che tipo di lavoro e quanto ne fai per ogni caso. Potresti capire quale sia la risposta. – viraptor
'string' non è un tipo standard in C, e usa l'operatore' + = 'con un operando di tipo' stringa' e l'altro 'char *' non ha senso. Sei sicuro che questo non sia un codice C++? – Sebivor