Bagaimana untuk menggunakan algoritma dalam pengaturcaraan PHP?

Dengan perkembangan teknologi komputer yang berterusan, peranan algoritma dalam pengaturcaraan bukan sahaja menjadi semakin penting, tetapi juga menarik lebih banyak perhatian daripada pengaturcara. Dalam pengaturcaraan PHP, menggunakan algoritma boleh membantu kami menyelesaikan tugasan dengan lebih pantas dan cekap. Artikel ini akan meneroka cara menggunakan algoritma dalam pengaturcaraan PHP.

1. Pengenalan kepada Algoritma

Algoritma ialah kaedah penyelesaian masalah Ia adalah satu siri langkah operasi yang teratur yang digunakan untuk menyelesaikan masalah tertentu atau menyelesaikan tugasan tertentu. Dalam pengaturcaraan, algoritma boleh membantu kita menyelesaikan masalah dengan lebih cepat dan lebih cekap.

Dalam pengaturcaraan PHP, algoritma yang biasa digunakan termasuk algoritma pengisihan, algoritma carian, algoritma padanan rentetan, dsb.

2. Algoritma pengisihan

Algoritma pengisihan ialah algoritma yang mengisih set data mengikut peraturan tertentu. Algoritma pengisihan yang biasa digunakan termasuk isihan gelembung, isihan sisipan, isihan pemilihan, isihan pantas dan isihan gabungan.

1. Isih gelembung

Isih buih ialah algoritma pengisihan yang mudah adalah berulang kali melintasi tatasusunan, setiap kali membandingkan dua elemen bersebelahan, jika susunannya tidak mematuhi tatasusunan. perintah yang ditetapkan, mereka ditukar.

Kod contoh:

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. Isih sisipan

Isihan sisipan ialah algoritma isihan yang memasukkan data yang tidak diisih ke dalam urutan data yang diisih. Prinsipnya adalah bermula dari elemen pertama dan memasukkan elemen berikutnya ke dalam urutan data yang diisih.

Kod contoh:

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 Isih pilihan

Isih pilihan ialah algoritma pengisihan yang mudah ialah memilih nilai minimum daripada data yang tidak diisih ia ke dalam urutan data yang diisih.

Kod contoh:

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. Isih cepat

Isih cepat ialah algoritma pengisihan yang cekap adalah untuk membahagikan data yang besar kepada Alih ke kanan, pergerakan data yang kecil ke kiri, dan akhirnya data dibahagikan kepada dua bahagian.

Kod contoh:

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. Isih Gabung

Isih gabung ialah algoritma pengisihan yang menggunakan idea "bahagi dan takluk". bahagikan data kepada dua Bahagian diisih secara berasingan, dan akhirnya dua tatasusunan tersusun digabungkan menjadi satu tatasusunan tertib.

Kod sampel:

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. Algoritma carian

Algoritma carian ialah algoritma untuk mencari elemen tertentu dalam set data. Algoritma carian yang biasa digunakan termasuk carian berjujukan, carian binari, carian hash, dsb.

1. Carian berjujukan

Carian berurutan ialah algoritma carian mudah adalah untuk memulakan carian dari elemen pertama tatasusunan sehingga elemen sasaran atau penghujung tatasusunan ditemui .

Kod contoh:

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

2. Carian binari

Carian binari ialah algoritma carian yang cekap adalah untuk membahagikan tatasusunan kepada dua bahagian dalam Jika elemen sasaran berada di separuh masa kedua, teruskan mencari separuh masa pertama jika elemen sasaran berada pada separuh masa kedua, teruskan mencari separuh masa kedua.

Kod contoh:

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. Algoritma pemadanan rentetan

Algoritma pemadanan rentetan ialah algoritma untuk mencari subrentetan lain dalam rentetan panjang. Algoritma padanan rentetan yang biasa digunakan termasuk algoritma padanan kekerasan, algoritma KMP dan algoritma Boyer-Moore.

1. Algoritma pemadanan daya kasar

Algoritma pemadanan rentetan yang ringkas Prinsipnya ialah bermula daripada setiap aksara dalam rentetan utama dan memadankan aksara rentetan mengikut watak. perlawanan.

Kod contoh:

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

Algoritma 2.KMP

Algoritma KMP ialah algoritma pemadanan rentetan yang cekap Prinsipnya ialah menggunakan maklumat yang diketahui untuk meminimumkan bilangan padanan. Teras algoritma KMP adalah untuk membina jadual awalan untuk pemadanan aksara.

Kod contoh:

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

Di atas ialah pengenalan kepada menggunakan algoritma dalam pengaturcaraan PHP. Dalam pengaturcaraan sebenar, memilih algoritma yang sesuai mengikut situasi yang berbeza boleh meningkatkan kecekapan program dengan berkesan. Pada masa yang sama, kita juga perlu terus belajar dan menguasai lebih banyak algoritma untuk menghadapi pengaturcaraan yang lebih kompleks.

Atas ialah kandungan terperinci Bagaimana untuk menggunakan algoritma dalam pengaturcaraan PHP?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!