Comment utiliser les algorithmes en programmation PHP ?

Avec le développement continu de la technologie informatique, le rôle des algorithmes dans la programmation devient non seulement de plus en plus important, mais attire également de plus en plus l'attention des programmeurs. Dans la programmation PHP, l'utilisation d'algorithmes peut nous aider à accomplir des tâches plus rapidement et plus efficacement. Cet article explorera comment utiliser les algorithmes dans la programmation PHP.

1. Introduction aux algorithmes

Un algorithme est une méthode de résolution de problèmes. Il s'agit d'une série d'étapes opérationnelles ordonnées utilisées pour résoudre un certain problème ou accomplir une certaine tâche. En programmation, les algorithmes peuvent nous aider à résoudre les problèmes plus rapidement et plus efficacement.

Dans la programmation PHP, les algorithmes couramment utilisés incluent les algorithmes de tri, les algorithmes de recherche, les algorithmes de correspondance de chaînes, etc.

2. Algorithme de tri

L'algorithme de tri est un algorithme qui trie un ensemble de données selon certaines règles. Les algorithmes de tri couramment utilisés incluent le tri à bulles, le tri par insertion, le tri par sélection, le tri rapide et le tri par fusion.

1. Tri à bulles

Le tri à bulles est un algorithme de tri simple. Son principe est de parcourir le tableau à plusieurs reprises et de comparer à chaque fois deux éléments adjacents si leur ordre ne correspond pas à l'ordre spécifié, échangez-les.

Exemple de code :

function bubbleSort($arr){
    $len = count($arr);
    for($i=0;$i<$len;$i++){
        for($j=0;$j<$len-$i-1;$j++){
            if($arr[$j] > $arr[$j+1]){
                $temp = $arr[$j];
                $arr[$j] = $arr[$j+1];
                $arr[$j+1] = $temp;
            }
        }
    }
    return $arr;
}

2. Tri par insertion

Le tri par insertion est un algorithme de tri qui insère des données non triées dans une séquence de données triées. Son principe est de partir du premier élément et d'insérer les éléments suivants dans la séquence de données triées.

Exemple de code :

function insertionSort($arr){
    $len = count($arr);
    for($i=1;$i<$len;$i++){
        $temp = $arr[$i];
        for($j=$i-1;$j>=0;$j--){
            if($arr[$j] > $temp){
                $arr[$j+1] = $arr[$j];
            }else{
                break;
            }
        }
        $arr[$j+1] = $temp;
    }
    return $arr;
}

3. Tri par sélection

Le tri par sélection est un algorithme de tri simple. Son principe est de sélectionner une valeur minimale à partir des données non triées, puis de la placer dans la séquence de données triées.

Exemple de code :

function selectionSort($arr){
    $len = count($arr);
    for($i=0;$i<$len-1;$i++){
        $minIndex = $i;
        for($j=$i+1;$j<$len;$j++){
            if($arr[$j] < $arr[$minIndex]){
                $minIndex = $j;
            }
        }
        $temp = $arr[$i];
        $arr[$i] = $arr[$minIndex];
        $arr[$minIndex] = $temp;
    }
    return $arr;
}

4. Tri rapide

Le tri rapide est un algorithme de tri efficace. Son principe est de diviser en continu les données, de déplacer les données volumineuses vers la droite, les petites données vers la gauche et enfin de diviser les données en. deux parties.

Exemple de code :

function quickSort($arr){
    $len = count($arr);
    if($len <= 1){
        return $arr;
    }
    $pivot = $arr[0];
    $left = $right = array();
    for($i=1;$i<$len;$i++){
        if($arr[$i] < $pivot){
            $left[] = $arr[$i];
        }else{
            $right[] = $arr[$i];
        }
    }
    $left = quickSort($left);
    $right = quickSort($right);
    return array_merge($left,array($pivot),$right);
}

5. Tri par fusion

Le tri par fusion est un algorithme de tri qui s'appuie sur l'idée de « diviser pour mieux régner ». Son cœur est de diviser les données en deux parties, de les trier séparément et de les diviser. combinez enfin les deux parties. Les combinaisons ordinales sont combinées dans un tableau ordonné.

Exemple de code :

function mergeSort($arr){
    $len = count($arr);
    if($len <= 1){
        return $arr;
    }
    $mid = intval($len/2);
    $left = array_slice($arr,0,$mid);
    $right = array_slice($arr,$mid);
    $left = mergeSort($left);
    $right = mergeSort($right);
    $mergeArr = array();
    while(count($left) && count($right)){
        $mergeArr[] = $left[0] < $right[0] ? array_shift($left) : array_shift($right);
    }
    return array_merge($mergeArr,$left,$right);
}

3. Algorithme de recherche

L'algorithme de recherche est un algorithme permettant de trouver un élément spécifique dans un ensemble de données. Les algorithmes de recherche couramment utilisés incluent la recherche séquentielle, la recherche binaire, la recherche par hachage, etc.

1. Recherche séquentielle

La recherche séquentielle est un algorithme de recherche simple. Son principe est de rechercher à partir du premier élément du tableau jusqu'à ce que l'élément cible ou la fin du tableau soit trouvé.

Exemple de code :

function sequentialSearch($arr,$target){
    $len = count($arr);
    for($i=0;$i<$len;$i++){
        if($arr[$i] == $target){
            return $i;
        }
    }
    return -1;
}

2. Recherche binaire

La recherche binaire est un algorithme de recherche efficace. Son principe est de diviser le tableau en deux parties. Si l'élément cible est dans la première moitié, continuez à rechercher la première moitié. ; si l'élément cible est Dans la seconde moitié, continuez à rechercher la seconde moitié.

Exemple de code :

function binarySearch($arr,$target){
    $len = count($arr);
    $left = 0;
    $right = $len - 1;
    while($left <= $right){
        $mid = intval(($left+$right)/2);
        if($arr[$mid] == $target){
            return $mid;
        }elseif($arr[$mid] > $target){
            $right = $mid - 1;
        }else{
            $left = $mid + 1;
        }
    }
    return -1;
}

4. Algorithme de correspondance de chaînes

L'algorithme de correspondance de chaînes est un algorithme permettant de trouver une autre sous-chaîne dans une longue chaîne. Les algorithmes de correspondance de chaînes couramment utilisés incluent l'algorithme de correspondance par force brute, l'algorithme KMP, l'algorithme de Boyer-Moore, etc.

1. Algorithme de correspondance par force brute

L'algorithme de correspondance par force brute est un algorithme de correspondance de chaîne simple. Son principe est de partir de chaque caractère de la chaîne principale et de faire correspondre la chaîne de modèle caractère par caractère.

Exemple de code :

function bruteForce($str,$subStr){
    $len1 = strlen($str);
    $len2 = strlen($subStr);
    for($i=0;$i<=$len1-$len2;$i++){
        for($j=0;$j<$len2;$j++){
            if($str[$i+$j] != $subStr[$j]){
                break;
            }
        }
        if($j == $len2){
            return $i;
        }
    }
    return -1;
}

2.Algorithme KMP

L'algorithme KMP est un algorithme de correspondance de chaînes efficace. Son principe est d'utiliser des informations connues pour minimiser le nombre de correspondances. Le cœur de l'algorithme KMP est de créer une table de préfixes pour la correspondance des caractères.

Exemple de code :

function KMP($str,$subStr){
    $next = getNext($subStr);
    $i = $j = 0;
    $len1 = strlen($str);
    $len2 = strlen($subStr);
    while($i<$len1 && $j<$len2){
        if($j == -1 || $str[$i] = $subStr[$j]){
            $i++;
            $j++;
        }else{
            $j = $next[$j];
        }
    }
    if($j == $len2){
        return $i - $j;
    }else{
        return -1;
    }
}

function getNext($subStr){
    $len = strlen($subStr);
    $next[0] = -1;
    $i = 0;
    $j = -1;
    while($i<$len-1){
        if($j == -1 || $subStr[$i] == $subStr[$j]){
            $i++;
            $j++;
            $next[$i] = $j;
        }else{
            $j = $next[$j];
        }
    }
    return $next;
}

Ce qui précède est une introduction à l'utilisation d'algorithmes dans la programmation PHP. Dans la programmation réelle, choisir l'algorithme approprié en fonction de différentes situations peut améliorer efficacement l'efficacité du programme. Dans le même temps, nous devons également continuer à apprendre et à maîtriser davantage d’algorithmes pour faire face à une programmation plus complexe.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!