Danh sách Big-O cho các hàm PHP

Sau khi sử dụng PHP được một lúc, tôi nhận thấy rằng không phải tất cả các hàm PHP tích hợp đều nhanh như mong đợi. Hãy xem xét hai triển khai có thể có của một hàm tìm thấy nếu một số là số nguyên tố bằng cách sử dụng một mảng các số nguyên tố được lưu trữ.

//very slow for large $prime_array
$prime_array = array( 2, 3, 5, 7, 11, 13, .... 104729, ... );
$result_array = array();
foreach( $prime_array => $number ) {
    $result_array[$number] = in_array( $number, $large_prime_array );
}

//speed is much less dependent on size of $prime_array, and runs much faster.
$prime_array => array( 2 => NULL, 3 => NULL, 5 => NULL, 7 => NULL,
                       11 => NULL, 13 => NULL, .... 104729 => NULL, ... );
foreach( $prime_array => $number ) {
    $result_array[$number] = array_key_exists( $number, $large_prime_array );
}

Điều này là do in_arrayđược thực hiện với tìm kiếm tuyến tính O (n) sẽ chậm tuyến tính khi $prime_arrayphát triển. Trường hợp array_key_existshàm được thực hiện với tra cứu băm O (1) sẽ không bị chậm lại trừ khi bảng băm trở nên cực kỳ đông dân (trong trường hợp đó chỉ là O (n)).

Cho đến nay tôi đã phải khám phá các big-O thông qua thử nghiệm và lỗi, và thỉnh thoảng nhìn vào mã nguồn . Bây giờ cho câu hỏi ...

Có một danh sách các thời gian O lớn về mặt lý thuyết (hoặc thực tế) cho tất cả * các hàm PHP tích hợp không?

* hoặc ít nhất là những người thú vị

Ví dụ, tôi thấy nó rất khó để dự đoán O lớn các chức năng được liệt kê bởi vì việc thực hiện có thể phụ thuộc vào cấu trúc dữ liệu cốt lõi không rõ của PHP: array_merge, array_merge_recursive, array_reverse, array_intersect, array_combine, str_replace(với đầu vào mảng) vv

Vì dường như không có ai đã làm điều này trước khi tôi nghĩ rằng nên để nó tham khảo ở đâu đó. Tôi đã đi và thông qua điểm chuẩn hoặc đọc mã để mô tả các array_*chức năng. Tôi đã cố gắng đưa Big-O thú vị hơn lên gần đỉnh. Danh sách này không đầy đủ.

Lưu ý: Tất cả các Big-O được tính toán giả sử tra cứu băm là O (1) mặc dù nó thực sự là O (n). Hệ số của n rất thấp, chi phí ram của việc lưu trữ một mảng đủ lớn sẽ làm bạn tổn thương trước khi các đặc điểm tra cứu Big-O bắt đầu có hiệu lực. Ví dụ: sự khác biệt giữa một cuộc gọi đến array_key_existstại N = 1 và N = 1.000.000 là tăng 50% thời gian.

Điểm thú vị :

1. isset/ array_key_existsnhanh hơn nhiều so với in_arrayvàarray_search
2. +(union) nhanh hơn một chút so với array_merge(và trông đẹp hơn). Nhưng nó hoạt động khác nhau nên hãy ghi nhớ điều đó.
3. shuffle ở cùng tầng với Big-O như array_rand
4. array_pop/ array_pushlà nhanh hơn array_shift/ array_unshiftdo hình phạt chỉ số lại

Tra cứu :

array_key_existsO (n) nhưng thực sự gần với O (1) - điều này là do bỏ phiếu tuyến tính trong các va chạm, nhưng vì cơ hội va chạm là rất nhỏ, nên hệ số này cũng rất nhỏ. Tôi thấy bạn coi các tra cứu băm là O (1) để tạo ra một O lớn thực tế hơn. Ví dụ, sự khác nhau giữa N = 1000 và N = 100000 chỉ chậm khoảng 50%.

isset( $array[$index] )O (n) nhưng thực sự gần với O (1) - nó sử dụng tra cứu tương tự như mảng_key_exists. Vì ngôn ngữ của nó được xây dựng, sẽ lưu trữ bộ đệm tra cứu nếu khóa được mã hóa cứng, dẫn đến tăng tốc trong trường hợp sử dụng cùng một khóa.

in_array O (n) - điều này là do nó thực hiện tìm kiếm tuyến tính qua mảng cho đến khi tìm thấy giá trị.

array_search O (n) - nó sử dụng chức năng cốt lõi giống như in_array nhưng trả về giá trị.

Hàm hàng đợi :

array_push O (∑ var_i, cho tất cả i)

array_pop Ô (1)

array_shift O (n) - nó phải reindex tất cả các phím

array_unshift O (n + var_i, với tất cả i) - nó phải reindex tất cả các khóa

Giao lộ mảng, Liên minh, Phép trừ :

array_intersect_key nếu giao lộ 100% làm O (Tối đa (param_i_size) * param_i_count, cho tất cả i), nếu giao lộ 0% giao nhau O (param_i_size, cho tất cả i)

array_intersect nếu giao nhau 100% làm O (n ^ 2 * param_i_count, với tất cả i), nếu giao lộ 0% giao nhau O (n ^ 2)

array_intersect_assoc nếu giao lộ 100% làm O (Tối đa (param_i_size) * param_i_count, cho tất cả i), nếu giao lộ 0% giao nhau O (param_i_size, cho tất cả i)

array_diff O (π param_i_size, cho tất cả i) - Đó là sản phẩm của tất cả các param_sizes

array_diff_key O (∑ param_i_size, for i! = 1) - điều này là do chúng ta không cần lặp lại mảng đầu tiên.

array_merge O (∑ mảng_i, i! = 1) - không cần lặp lại mảng đầu tiên

+ (union) O (n), trong đó n là kích thước của mảng thứ 2 (tức là mảng_first + mảng_second) - ít chi phí hơn mảng_merge vì nó không phải đánh số lại

array_replace O (∑ mảng_i, cho tất cả i)

Ngẫu nhiên :

shuffle Trên)

array_rand O (n) - Yêu cầu một cuộc thăm dò tuyến tính.

Rõ ràng Big-O :

array_fill Trên)

array_fill_keys Trên)

range Trên)

array_splice O (bù + chiều dài)

array_slice O (offset + length) hoặc O (n) nếu length = NULL

array_keys Trên)

array_values Trên)

array_reverse Trên)

array_pad O (pad_size)

array_flip Trên)

array_sum Trên)

array_product Trên)

array_reduce Trên)

array_filter Trên)

array_map Trên)

array_chunk Trên)

array_combine Trên)

Tôi muốn cảm ơn Eureqa vì đã giúp dễ dàng tìm thấy Big-O của các chức năng. Đây là một chương trình miễn phí tuyệt vời có thể tìm thấy chức năng phù hợp nhất cho dữ liệu tùy ý.

BIÊN TẬP:

Đối với những người nghi ngờ rằng việc tìm kiếm mảng PHP là O(N), tôi đã viết một điểm chuẩn để kiểm tra điều đó (chúng vẫn hiệu quả O(1)đối với hầu hết các giá trị thực tế).

$tests = 1000000;
$max = 5000001;


for( $i = 1; $i <= $max; $i += 10000 ) {
    //create lookup array
    $array = array_fill( 0, $i, NULL );

    //build test indexes
    $test_indexes = array();
    for( $j = 0; $j < $tests; $j++ ) {
        $test_indexes[] = rand( 0, $i-1 );
    }

    //benchmark array lookups
    $start = microtime( TRUE );
    foreach( $test_indexes as $test_index ) {
        $value = $array[ $test_index ];
        unset( $value );
    }
    $stop = microtime( TRUE );
    unset( $array, $test_indexes, $test_index );

    printf( "%d,%1.15f\n", $i, $stop - $start ); //time per 1mil lookups
    unset( $stop, $start );
}

Giải thích cho trường hợp bạn mô tả cụ thể là các mảng kết hợp được triển khai dưới dạng bảng băm - vì vậy tra cứu theo khóa (và tương ứng, array_key_exists) là O (1). Tuy nhiên, mảng không được lập chỉ mục theo giá trị, vì vậy cách duy nhất trong trường hợp chung là khám phá xem giá trị có tồn tại trong mảng hay không là tìm kiếm tuyến tính. Không có gì bất ngờ ở đó.

Tôi không nghĩ có tài liệu toàn diện cụ thể về độ phức tạp thuật toán của các phương thức PHP. Tuy nhiên, nếu đó là một mối quan tâm đủ lớn để đảm bảo nỗ lực, bạn luôn có thể xem qua mã nguồn .

Bạn hầu như luôn muốn sử dụng issetthay vì array_key_exists. Tôi không nhìn vào phần bên trong, nhưng tôi khá chắc chắn đó array_key_existslà O (N) vì nó lặp lại qua từng phím của mảng, trong khi issetcố gắng truy cập phần tử bằng thuật toán băm tương tự được sử dụng khi bạn truy cập một chỉ số mảng. Đó phải là O (1).

Một "gotcha" cần chú ý là:

$search_array = array('first' => null, 'second' => 4);

// returns false
isset($search_array['first']);

// returns true
array_key_exists('first', $search_array);

Tôi tò mò, vì vậy tôi đã điểm chuẩn sự khác biệt:

<?php

$bigArray = range(1,100000);

$iterations = 1000000;
$start = microtime(true);
while ($iterations--)
{
    isset($bigArray[50000]);
}

echo 'is_set:', microtime(true) - $start, ' seconds', '<br>';

$iterations = 1000000;
$start = microtime(true);
while ($iterations--)
{
    array_key_exists(50000, $bigArray);
}

echo 'array_key_exists:', microtime(true) - $start, ' seconds';
?>

is_set:0.132308959961 giây
array_key_exists:2.33202195168 giây

Tất nhiên, điều này không thể hiện sự phức tạp về thời gian, nhưng nó cho thấy 2 chức năng so sánh với nhau như thế nào.

Để kiểm tra độ phức tạp của thời gian, hãy so sánh lượng thời gian cần thiết để chạy một trong các chức năng này trên khóa đầu tiên và khóa cuối cùng.

Nếu mọi người gặp rắc rối trong thực tế với các va chạm quan trọng, họ sẽ triển khai các thùng chứa với một tra cứu băm thứ cấp hoặc cây cân bằng. Cây cân bằng sẽ cho O (log n) hành vi trường hợp xấu nhất và O (1) avg. trường hợp (băm chính nó). Chi phí hoạt động không đáng giá trong hầu hết các ứng dụng bộ nhớ, nhưng có lẽ có những cơ sở dữ liệu thực hiện hình thức chiến lược hỗn hợp này như trường hợp mặc định của chúng.