Una soluzione carina è quella di fissare un indice valido per tutti gli array, fare un controllo su tutti gli array su questo indice aumentandolo di passo in passo:
$array1[$i] === $elemento ,
$array2[$i] === $elemento ,
...,
$arrayN[$i] === $elemento .
In questo modo hai un solo ciclo che muove l'indice (finché è inferiore al massimo della lunghezza dei 3 array), all'interno fai i controlli sui tuoi 3 array.
Volendo si può fare una soluzione generica valevole per N array (non solo 3), in tal caso bisogna usare un altro ciclo (innestato); in ogni caso la complessità computazionale dell'algoritmo è invariata.
Devi muovere l'indice un numero massimo di max(count($array1), count($array2), count($array3)) e fare 3 controlli per capire dove si trova l'elemento.
Per farti un esempio di algoritmo:
Codice PHP:
$array1 = array(5,5,7,9);
$array2 = array(2,4,6,8,10);
$array3 = array(11,13,15,17,19,51,68,21);
$arrays = array($array1, $array2, $array3);
$limit = max(count($array1), count($array2), count($array3)); // l'indice non può andare oltre a questo valore
$needle = 21; // elemento da trovare (questo è il caso pessimo, l'elemento da trovare è in coda)
$found = false; // conterrà l'esito della ricerca
$i = 0;
while($i < $limit && $found === false) {
foreach($arrays as $n => $array) {
if(isset($array[$i])) {
if($array[$i] === $needle) {
$found = $n;
break;
}
} else {
// rimuove l'array tra gli 'arrays', in questo modo le iterazioni su di esso si riducono al prossimo $i
unset($arrays[$n]);
}
}
$i++;
}
var_dump($found);
In questo caso l'array più lungo è $array3 con 8 elementi ($limit = 8).
Il foreach innestato ciclerà su 3 array e man mano che l'indice supererà la loro lunghezza verranno rimossi da $arrays, questo implica meno iterazioni la prossima voltà che verrà raggiunto il foreach.
Nel momento in cui l'elemento è stato trovato, si esce subito fuori dal ciclo.
Per fare qualche conto, in totale abbiamo bisogno di circa max(5, 5, 8) * 3 (24) iterazioni per trovare l'elemento nella posizione più scomoda, ma 2 per trovare l'elemento in posizione ottima (primo del primo array). Negli altri casi dipende dalla posizione, ma comunque è minore di 24.