php 常用算法和时间复杂度_php技巧
按数量级递增排列,常见的时间复杂度有:常数阶O(1),对数阶O(log2n),线性阶O(n),线性对数阶O(nlog2n),平方阶O(n2),立方阶O(n3)
//二分查找O(log2n)
function erfen($a,$l,$h,$f){
if($l >$h){ return false;}
$m = intval(($l+$h)/2);
if ($a[$m] == $f){
return $m;
}elseif ($f return erfen($a, $l, $m-1, $f);
}else{
return erfen($a, $m+1, $h, $f);
}
}
$a = array(1,12,23,67,88,100);
var_dump(erfen($a,0,5,1));
//遍历树O(log2n)
function bianli($p){
$a = array();
foreach (glob($p.'/*') as $f){
if(is_dir($f)){
$a = array_merge($a,bianli($f));
}else{
$a[] = $f;
}
}
return $a;
}
//阶乘O(log2n)
function jc($n){
if($n return 1;
}else{
return $n*jc($n-1);
}
}
//快速查找 O(n *log2(n))
function kuaisu($a){
$c = count($a);
if($c $l = $r = array();
for ($i=1;$i if($a[$i] $l[] = $a[$i];
}else{
$r[] = $a[$i];
}
}
$l = kuaisu($l);
$r = kuaisu($r);
return array_merge($l,array($a[0]),$r);
}
//插入排序 O(N*N)
function charu($a){
$c = count($a);
for($i=1;$i $t = $a[$i];
for($j=$i;$j>0 && $a[$j-1]>$t;$j--){
$a[$j] = $a[$j-1];
}
$a[$j] = $t;
}
return $a;
}
//选择排序O(N*N)
function xuanze($a){
$c = count($a);
for($i=0;$i for ($j=$i+1;$j if($a[$i]>$a[$j]){
$t = $a[$j];
$a[$j] = $a[$i];
$a[$i] = $t;
}
}
}
return $a;
}
//冒泡排序 O(N*N)
function maopao($a){
$c = count($a);
for($i=0;$i for ($j=$c-1;$j>$i;$j--){
if($a[$j] $t = $a[$j-1];
$a[$j-1] = $a[$j];
$a[$j] = $t;
}
}
}
return $a;
}
/**
* 排列组合
* 采用二进制方法进行组合的选择,如表示5选3时,只需有3位为1就可以了,所以可得到的组合是 01101 11100 00111 10011 01110等10种组合
*
* @param 需要排列的数组 $arr
* @param 最小个数 $min_size
* @return 满足条件的新数组组合
*/
function plzh($arr,$size=5) {
$len = count($arr);
$max = pow(2,$len);
$min = pow(2,$size)-1;
$r_arr = array();
for ($i=$min; $i $count = 0;
$t_arr = array();
for ($j=0; $j $a = pow(2, $j);
$t = $i&$a;
if($t == $a){
$t_arr[] = $arr[$j];
$count++;
}
}
if($count == $size){
$r_arr[] = $t_arr;
}
}
return $r_arr;
}
$pl = pl(array(1,2,3,4,5,6,7),5);
var_dump($pl);

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Sujets chauds

L'analyse de la complexité temporelle des fonctions récursives implique : l'identification des cas de base et des appels récursifs. Calculez la complexité temporelle du cas de base et de chaque appel récursif. Additionnez la complexité temporelle de tous les appels récursifs. Considérez la relation entre le nombre d'appels de fonction et la taille du problème. Par exemple, la complexité temporelle de la fonction factorielle est O(n) car chaque appel récursif augmente la profondeur de récursion de 1, donnant une profondeur totale de O(n).

La complexité temporelle est une mesure du temps nécessaire à l'exécution d'une fonction. Les problèmes courants de complexité temporelle des fonctions PHP incluent les boucles imbriquées, les parcours de grands tableaux et les appels récursifs. Les techniques d'optimisation de la complexité temporelle comprennent : l'utilisation de la mise en cache pour réduire le nombre de boucles la simplification des algorithmes à l'aide du traitement parallèle

Go est un langage de programmation de plus en plus populaire, conçu pour être facile à écrire, à lire et à entretenir, tout en prenant également en charge des concepts de programmation avancés. La complexité temporelle et la complexité spatiale sont des concepts importants dans l'analyse des algorithmes et de la structure des données. Ils mesurent l'efficacité d'exécution et la taille de la mémoire d'un programme. Dans cet article, nous nous concentrerons sur l’analyse de la complexité temporelle et spatiale dans le langage Go. Complexité temporelle La complexité temporelle fait référence à la relation entre le temps d'exécution d'un algorithme et la taille du problème. Le temps est généralement exprimé en notation Big O

Comment analyser des algorithmes en utilisant la complexité temporelle et la complexité spatiale en C++ La complexité temporelle et la complexité spatiale sont des mesures de la durée d'exécution d'un algorithme et de l'espace dont il a besoin. Dans le développement de logiciels, nous devons souvent évaluer l’efficacité des algorithmes pour choisir la solution optimale. En tant que langage de programmation hautes performances, C++ fournit une riche structure de données et une bibliothèque d'algorithmes, ainsi que de puissantes capacités informatiques et mécanismes de gestion de la mémoire. Cet article présentera comment utiliser les algorithmes d'analyse de la complexité temporelle et spatiale en C++, et expliquera comment le faire à travers des exemples de code spécifiques.

La complexité temporelle du tri aléatoire des tableaux PHP est O(n) et le temps d'exécution est proportionnel à la taille du tableau. Cas pratique : Créez un tableau et utilisez la fonction shuffle pour perturber le tri et imprimer le tableau mélangé.

Il est crucial de comprendre le piège de la complexité temporelle. Les stratégies d'optimisation incluent : 1. Utiliser le bon algorithme 2. Réduire les copies inutiles ; Des exemples pratiques explorent les méthodes d'optimisation pour calculer la somme des carrés d'un tableau, convertir une chaîne en majuscules et rechercher des éléments dans un tableau non ordonné.

Étant donné un tableau de taille n et plusieurs valeurs entières, nous devons faire pivoter le tableau à partir d’un index k donné. Nous voulons faire pivoter le tableau à partir de l'index k comme indiqué ci-dessous - Exemple d'entrée : arr[]={1,2,3,4,5} K1=1 K2=3 K3=6Sortie : 23451 45123 23451 Algorithme STARTStep1->

Apprenez le principe et l'analyse de la complexité temporelle de l'algorithme de tri par comptage en PHP. Le tri par comptage est un algorithme de tri non comparatif, qui convient aux situations où la plage de données est petite et connue. Son idée de base est de compter le nombre d'occurrences de chaque élément, puis de le remplir dans le tableau de sortie afin de réaliser le tri. Cet article présentera les principes, les étapes et l'analyse de la complexité temporelle du tri par comptage, et fournira des exemples de code PHP spécifiques. Principe : Le principe du tri par comptage est relativement simple. Supposons que le tableau à trier est un tableau et que la plage d'éléments est [0,k].
