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);

Heiße KI -Werkzeuge

Undresser.AI Undress
KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover
Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool
Ausziehbilder kostenlos

Clothoff.io
KI-Kleiderentferner

AI Hentai Generator
Erstellen Sie kostenlos Ai Hentai.

Heißer Artikel

Heiße Werkzeuge

Notepad++7.3.1
Einfach zu bedienender und kostenloser Code-Editor

SublimeText3 chinesische Version
Chinesische Version, sehr einfach zu bedienen

Senden Sie Studio 13.0.1
Leistungsstarke integrierte PHP-Entwicklungsumgebung

Dreamweaver CS6
Visuelle Webentwicklungstools

SublimeText3 Mac-Version
Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

Heiße Themen

Die Zeitkomplexitätsanalyse rekursiver Funktionen umfasst Folgendes: Identifizieren von Basisfällen und rekursiven Aufrufen. Berechnen Sie die zeitliche Komplexität des Basisfalls und jedes rekursiven Aufrufs. Summieren Sie die zeitliche Komplexität aller rekursiven Aufrufe. Berücksichtigen Sie den Zusammenhang zwischen der Anzahl der Funktionsaufrufe und der Größe des Problems. Beispielsweise beträgt die zeitliche Komplexität der Fakultätsfunktion O(n), da jeder rekursive Aufruf die Rekursionstiefe um 1 erhöht, was eine Gesamttiefe von O(n) ergibt.

Zeitkomplexität ist ein Maß dafür, wie lange die Ausführung einer Funktion dauert. Zu den häufigsten Problemen mit der Zeitkomplexität von PHP-Funktionen gehören verschachtelte Schleifen, große Array-Durchläufe und rekursive Aufrufe. Zu den Techniken zur Optimierung der Zeitkomplexität gehören: Verwendung von Caching zur Reduzierung der Anzahl von Schleifen, Vereinfachung von Algorithmen durch Parallelverarbeitung

Go ist eine immer beliebter werdende Programmiersprache, die einfach zu schreiben, leicht zu lesen und zu warten ist und gleichzeitig fortgeschrittene Programmierkonzepte unterstützt. Zeitkomplexität und Raumkomplexität sind wichtige Konzepte in der Algorithmen- und Datenstrukturanalyse. Sie messen die Ausführungseffizienz und die Speichergröße eines Programms. In diesem Artikel konzentrieren wir uns auf die Analyse der Zeitkomplexität und Raumkomplexität in der Go-Sprache. Zeitkomplexität Zeitkomplexität bezieht sich auf die Beziehung zwischen der Ausführungszeit eines Algorithmus und der Größe des Problems. Die Zeit wird normalerweise in der Big-O-Notation ausgedrückt

So analysieren Sie Algorithmen mithilfe von Zeitkomplexität und Raumkomplexität in C++. Zeitkomplexität und Raumkomplexität sind Maße dafür, wie lange die Ausführung eines Algorithmus dauert und wie viel Platz er benötigt. Bei der Softwareentwicklung müssen wir häufig die Effizienz von Algorithmen bewerten, um die optimale Lösung auszuwählen. Als leistungsstarke Programmiersprache bietet C++ eine umfangreiche Datenstruktur und Algorithmenbibliothek sowie leistungsstarke Rechenfunktionen und Speicherverwaltungsmechanismen. In diesem Artikel wird die Verwendung von Algorithmen zur Zeitkomplexitäts- und Raumkomplexitätsanalyse in C++ vorgestellt und die Vorgehensweise anhand spezifischer Codebeispiele erläutert

Die zeitliche Komplexität der PHP-Array-Shuffle-Sortierung beträgt O(n) und die Ausführungszeit ist proportional zur Array-Größe. Praktischer Fall: Erstellen Sie ein Array und verwenden Sie die Shuffle-Funktion, um die Sortierung zu unterbrechen und das gemischte Array zu drucken.

Es ist wichtig, die Zeitkomplexitätsfalle zu verstehen: 1. Verwenden Sie den richtigen Algorithmus. 2. Reduzieren Sie unnötige Kopien. In praktischen Beispielen werden Optimierungsmethoden zum Berechnen der Quadratsumme eines Arrays, zum Konvertieren einer Zeichenfolge in Großbuchstaben und zum Suchen von Elementen in einem ungeordneten Array untersucht.

Lernen Sie das Prinzip und die Zeitkomplexitätsanalyse des Zählsortieralgorithmus in PHP kennen. Die Zählsortierung ist ein nicht vergleichender Sortieralgorithmus, der für Situationen geeignet ist, in denen der Datenbereich klein und bekannt ist. Seine Grundidee besteht darin, die Anzahl der Vorkommen jedes Elements zu zählen und es dann in das Ausgabearray einzutragen, um eine Sortierung zu erreichen. In diesem Artikel werden die Prinzipien, Schritte und Zeitkomplexitätsanalyse der Zählsortierung vorgestellt und spezifische PHP-Codebeispiele bereitgestellt. Prinzip: Das Prinzip der Zählsortierung ist relativ einfach. Angenommen, das zu sortierende Array ist ein Array und der Elementbereich ist [0, k].

Bei einem Array der Größe n und mehreren ganzzahligen Werten müssen wir das Array ausgehend von einem gegebenen Index k drehen. Wir möchten das Array beginnend mit Index k wie unten gezeigt drehen – Beispieleingabe: arr[]={1,2,3,4,5} K1=1 K2=3 K3=6Ausgabe: 23451 45123 23451 Algorithmus STARTStep1->
