รายการฟังก์ชั่น Big-O สำหรับ PHP

หลังจากใช้ PHP มาระยะหนึ่งผมสังเกตว่าฟังก์ชั่น PHP ในตัวบางตัวนั้นไม่เร็วเท่าที่ควร พิจารณาการประยุกต์ใช้ที่เป็นไปได้ทั้งสองอย่างของฟังก์ชั่นที่ค้นหาว่าตัวเลขนั้นสำคัญเพียงใดโดยใช้อาเรย์แคชของช่วงเวลา

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

เพราะนี่คือin_arrayการดำเนินการกับการค้นหาเชิงเส้น O (n) ซึ่งจะชะลอตัวลงเชิงเส้นเป็น$prime_arrayเติบโต ในกรณีที่array_key_existsฟังก์ชั่นถูกนำไปใช้กับการค้นหา hash O (1) ซึ่งจะไม่ทำให้ช้าลงเว้นแต่ว่าตารางแฮชจะได้รับการเติมข้อมูลอย่างมาก (ในกรณีนี้เป็นเพียง O (n))

จนถึงขณะนี้ผมได้มีการค้นพบที่ยิ่งใหญ่-O ผ่านการทดลองและข้อผิดพลาดและบางครั้งมองรหัสที่มา ตอนนี้สำหรับคำถาม ...

มีรายการของ O (หรือปฏิบัติ) ครั้งใหญ่ทางทฤษฎีสำหรับทุก * ฟังก์ชั่น PHP ในตัว?

* หรืออย่างน้อยน่าสนใจ

ตัวอย่างเช่นผมพบว่ามันยากมากที่จะทำนายโอใหญ่ของฟังก์ชั่นที่ระบุไว้เพราะการดำเนินการที่เป็นไปได้ขึ้นอยู่กับโครงสร้างข้อมูลที่ไม่รู้จักหลักของ PHP: array_merge, array_merge_recursive, array_reverse, array_intersect, array_combine, str_replace(กับปัจจัยการผลิตอาร์เรย์) ฯลฯ

เนื่องจากดูเหมือนว่าไม่มีใครทำสิ่งนี้มาก่อนฉันจึงคิดว่าควรมีไว้เพื่อใช้อ้างอิง ฉันเคยไปแล้วและอาจผ่านเกณฑ์มาตรฐานหรือการคัดลอกโค้ดเพื่ออธิบายลักษณะการarray_*ทำงาน ฉันพยายามทำให้ Big-O ที่น่าสนใจใกล้กับด้านบนสุด รายการนี้ไม่สมบูรณ์

หมายเหตุ: Big-O ทั้งหมดที่คำนวณจากการค้นหา hash คือ O (1) แม้ว่าจะเป็น O (n) จริงๆ ค่าสัมประสิทธิ์ของ n นั้นต่ำมากหน่วยความจำ RAM ที่เก็บอาร์เรย์ขนาดใหญ่พอจะทำร้ายคุณก่อนที่ลักษณะของการค้นหา Big-O จะเริ่มมีผล ตัวอย่างเช่นความแตกต่างระหว่างการโทรไปarray_key_existsที่ N = 1 และ N = 1,000,000 คือเพิ่มขึ้น 50%

จุดที่น่าสนใจ :

1. isset/ array_key_existsเร็วกว่าin_arrayและมากarray_search
2. +(รวมกัน) นั้นเร็วกว่าarray_merge(และดูดีกว่าเล็กน้อย) แต่มันทำงานแตกต่างกันดังนั้นจำไว้
3. shuffle อยู่ในระดับเดียวกับ Big-O array_rand
4. array_pop/ array_pushเร็วกว่าarray_shift/ array_unshiftเนื่องจากปรับบทลงโทษใหม่

การค้นหา :

array_key_existsO (n) แต่จริง ๆ แล้วใกล้กับ O (1) - นี่เป็นเพราะการทำโพลเชิงเส้นในการชน แต่เนื่องจากโอกาสของการชนมีน้อยมากค่าสัมประสิทธิ์ก็น้อยมากเช่นกัน ฉันพบว่าคุณปฏิบัติต่อการค้นหาแบบแฮชในฐานะ O (1) เพื่อให้บิ๊กโอที่สมจริงยิ่งขึ้น ตัวอย่างเช่นความแตกต่างระหว่าง N = 1,000 และ N = 100000 จะช้าลงประมาณ 50% เท่านั้น

isset( $array[$index] )O (n) แต่จริง ๆ แล้วใกล้กับ O (1) - มันใช้การค้นหาเดียวกันกับ array_key_exists เนื่องจากเป็นภาษาที่สร้างขึ้นจะแคชการค้นหาหากคีย์เป็นฮาร์ดโค้ดทำให้เกิดความเร็วในกรณีที่ใช้คีย์เดิมซ้ำหลายครั้ง

in_array O (n) - นี่เป็นเพราะมันทำการค้นหาเชิงเส้นแม้ว่าอาร์เรย์จนกว่ามันจะหาค่า

array_search O (n) - มันใช้ฟังก์ชั่นหลักเช่นเดียวกับ in_array แต่ส่งกลับค่า

ฟังก์ชั่นคิว :

array_push O (∑ var_i สำหรับทุกคนฉัน)

array_pop O (1)

array_shift O (n) - จะต้องทำดัชนีคีย์ทั้งหมดใหม่อีกครั้ง

array_unshift O (n + ∑ var_i, สำหรับ i ทั้งหมด) - จะต้องทำดัชนีคีย์ทั้งหมดใหม่อีกครั้ง

Array Intersection, Union, การลบ :

array_intersect_key ถ้าการตัดกัน 100% ทำ O (สูงสุด (param_i_size) * ∑param_i_count, สำหรับ i ทั้งหมด), ถ้าแยก 0% ตัด O (∑param_i_size, สำหรับ i ทั้งหมด)

array_intersect ถ้าทางแยก 100% ทำ O (n ^ 2 * ∑param_i_count, สำหรับ i ทั้งหมด), ถ้าทางแยก 0% ตัด O (n ^ 2)

array_intersect_assoc ถ้าการตัดกัน 100% ทำ O (สูงสุด (param_i_size) * ∑param_i_count, สำหรับ i ทั้งหมด), ถ้าแยก 0% ตัด O (∑param_i_size, สำหรับ i ทั้งหมด)

array_diff O (π param_i_size สำหรับทุกคน) - นั่นคือผลงานของ param_sizes ทั้งหมด

array_diff_key O (∑ param_i_size สำหรับ i! = 1) - นี่เป็นเพราะเราไม่จำเป็นต้องวนซ้ำแถวแรก

array_merge O (∑ array_i, i! = 1) - ไม่จำเป็นต้องวนซ้ำในอาร์เรย์แรก

+ (union) O (n) โดยที่ n คือขนาดของอาร์เรย์ที่ 2 (เช่น array_first + array_second) - ค่าใช้จ่ายน้อยกว่า array_merge เนื่องจากไม่ต้องเปลี่ยนหมายเลข

array_replace O (∑ array_i สำหรับทุกคน)

สุ่ม :

shuffle บน)

array_rand O (n) - ต้องการโพลเชิงเส้น

ชัดเจน Big-O :

array_fill บน)

array_fill_keys บน)

range บน)

array_splice O (ออฟเซ็ต + ความยาว)

array_slice O (ออฟเซ็ต + ความยาว) หรือ O (n) ถ้า length = NULL

array_keys บน)

array_values บน)

array_reverse บน)

array_pad O (pad_size)

array_flip บน)

array_sum บน)

array_product บน)

array_reduce บน)

array_filter บน)

array_map บน)

array_chunk บน)

array_combine บน)

ฉันอยากจะขอบคุณEureqa ที่ทำให้การค้นหา Big-O ของฟังก์ชั่นเป็นเรื่องง่าย มันเป็นโปรแกรมฟรีที่น่าทึ่งที่สามารถค้นหาฟังก์ชั่นการฟิตที่ดีที่สุดสำหรับข้อมูลโดยพลการ

แก้ไข:

สำหรับผู้ที่สงสัยว่า PHP การค้นหาอาร์เรย์มีO(N)ผมเคยเขียนมาตรฐานในการทดสอบนั้น (พวกเขายังคงมีประสิทธิภาพO(1)สำหรับค่าที่เหมือนจริงมากที่สุด)

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

คำอธิบายสำหรับกรณีที่คุณอธิบายโดยเฉพาะคืออาร์เรย์ที่เชื่อมโยงถูกนำไปใช้เป็นตารางแฮชดังนั้นการค้นหาโดยใช้คีย์ (และสอดคล้องกันarray_key_exists) คือ O (1) อย่างไรก็ตามอาร์เรย์ไม่ได้จัดทำดัชนีตามค่าดังนั้นวิธีเดียวในกรณีทั่วไปที่จะค้นพบว่ามีค่าอยู่ในอาร์เรย์หรือไม่คือการค้นหาเชิงเส้น ไม่แปลกใจเลย

ฉันไม่คิดว่ามีเอกสารครอบคลุมเฉพาะเกี่ยวกับความซับซ้อนของอัลกอริทึมของวิธีการของ PHP อย่างไรก็ตามหากเป็นเรื่องที่ใหญ่พอที่จะรับประกันความพยายามคุณสามารถดูซอร์สโค้ดได้ตลอดเวลา

คุณมักจะต้องการที่จะใช้แทนisset array_key_existsฉันไม่ได้ดูที่ internals แต่ฉันค่อนข้างแน่ใจว่าarray_key_existsเป็น O (N) เพราะมันวนซ้ำทุกปุ่มทุกแถวในขณะที่issetพยายามเข้าถึงองค์ประกอบโดยใช้อัลกอริทึมแฮชเดียวกันที่ใช้เมื่อคุณเข้าถึง ดัชนีอาร์เรย์ นั่นควรเป็น O (1)

หนึ่ง "gotcha" ที่ต้องระวังคือ:

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

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

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

ฉันอยากรู้อยากเห็นฉันจึงเปรียบเทียบความแตกต่าง:

<?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 วินาที
array_key_exists:2.33202195168 วินาที

แน่นอนว่านี่ไม่ได้แสดงความซับซ้อนของเวลา แต่มันแสดงให้เห็นว่าทั้งสองฟังก์ชั่นเปรียบเทียบกันอย่างไร

ในการทดสอบความซับซ้อนของเวลาให้เปรียบเทียบระยะเวลาที่ใช้ในการเรียกใช้หนึ่งในฟังก์ชันเหล่านี้กับคีย์แรกและคีย์สุดท้าย

หากผู้คนประสบปัญหาในทางปฏิบัติกับการชนที่สำคัญพวกเขาจะใช้ภาชนะที่มีการค้นหาแฮชรองหรือต้นไม้ที่สมดุล ต้นไม้ที่สมดุลจะให้พฤติกรรมกรณีที่เลวร้ายที่สุดของ O (log n) และ O (1) เฉลี่ย กรณี (แฮชตัวเอง) ค่าใช้จ่ายไม่คุ้มกับการใช้งานจริงในแอปพลิเคชันหน่วยความจำ แต่อาจมีฐานข้อมูลที่ใช้กลยุทธ์แบบผสมนี้เป็นกรณีเริ่มต้น