อาร์เรย์ JavaScript ขนาดใหญ่

อาร์เรย์ใน JavaScript สามารถแก้ไขได้ง่ายมากโดยการเพิ่มและลบรายการ ค่อนข้างปกปิดข้อเท็จจริงที่ว่าอาร์เรย์ภาษาส่วนใหญ่มีขนาดคงที่และต้องการการดำเนินการที่ซับซ้อนในการปรับขนาด ดูเหมือนว่า JavaScript ทำให้ง่ายต่อการเขียนโค้ดอาร์เรย์ที่มีประสิทธิภาพต่ำ สิ่งนี้นำไปสู่คำถาม:

ประสิทธิภาพใด (ในแง่ของความซับซ้อนของเวลา O ขนาดใหญ่) ที่ฉันสามารถคาดหวังได้จากการใช้งาน JavaScript เกี่ยวกับประสิทธิภาพของอาร์เรย์

ฉันคิดว่าการใช้งาน JavaScript ที่สมเหตุสมผลทั้งหมดมี O ขนาดใหญ่ดังต่อไปนี้

• การเข้าถึง - O (1)
• ต่อท้าย - O (n)
• ล่วงหน้า - O (n)
• การแทรก - O (n)
• การลบ - O (n)
• การแลกเปลี่ยน - O (1)

JavaScript ให้คุณเติมอาร์เรย์ล่วงหน้าตามขนาดที่กำหนดโดยใช้new Array(length)ไวยากรณ์ (คำถามโบนัส: การสร้างอาร์เรย์ในลักษณะนี้ O (1) หรือ O (n)) นี่เป็นเหมือนอาร์เรย์ทั่วไปและหากใช้เป็นอาร์เรย์ที่มีขนาดล่วงหน้าสามารถอนุญาตให้ O (1) ต่อท้ายได้ หากมีการเพิ่มตรรกะบัฟเฟอร์แบบวงกลมคุณสามารถบรรลุ O (1) prepending หากใช้อาร์เรย์ที่ขยายแบบไดนามิก O (log n) จะเป็นกรณีเฉลี่ยสำหรับทั้งสองตัว

ฉันสามารถคาดหวังประสิทธิภาพที่ดีขึ้นสำหรับบางสิ่งมากกว่าสมมติฐานของฉันได้หรือไม่ ฉันไม่คาดหวังว่าจะมีการระบุไว้ในข้อกำหนดใด ๆ แต่ในทางปฏิบัติอาจเป็นไปได้ว่าการใช้งานที่สำคัญทั้งหมดใช้อาร์เรย์ที่ปรับให้เหมาะสมอยู่เบื้องหลัง มีการขยายอาร์เรย์แบบไดนามิกหรืออัลกอริธึมเพิ่มประสิทธิภาพอื่น ๆ ในที่ทำงานหรือไม่?

ปล

เหตุผลที่ฉันสงสัยคือฉันกำลังค้นคว้าอัลกอริทึมการเรียงลำดับซึ่งส่วนใหญ่ดูเหมือนว่าการต่อท้ายและการลบเป็นการดำเนินการ O (1) เมื่ออธิบาย O ขนาดใหญ่โดยรวมของพวกเขา

_{หมายเหตุ: แม้ว่าคำตอบนี้จะถูกต้องในปี 2012 แต่เอ็นจินใช้การแทนค่าภายในที่แตกต่างกันมากสำหรับทั้งอ็อบเจ็กต์และอาร์เรย์ในปัจจุบัน คำตอบนี้อาจเป็นจริงหรือไม่ก็ได้}

ในทางตรงกันข้ามกับภาษาส่วนใหญ่ซึ่งใช้อาร์เรย์ด้วยอาร์เรย์ใน Javascript Arrays เป็นวัตถุและค่าจะถูกเก็บไว้ในแฮชแท็กเช่นเดียวกับค่าวัตถุทั่วไป ดังต่อไปนี้:

• การเข้าถึง - O (1)
• การต่อท้าย - ค่าตัดจำหน่าย O (1) (บางครั้งจำเป็นต้องปรับขนาดแฮชแท็กโดยปกติจะต้องมีการแทรกเท่านั้น)
• Prepending - O (n) ผ่านunshiftเนื่องจากต้องกำหนดดัชนีทั้งหมดใหม่
• การแทรก - ตัดจำหน่าย O (1) หากไม่มีค่า O (n) หากคุณต้องการเปลี่ยนค่าที่มีอยู่ (เช่นโดยใช้splice)
• การลบ - ตัดบัญชี O (1) เพื่อเอาค่า O (n) spliceถ้าคุณต้องการดัชนีมอบหมายผ่าน
• การแลกเปลี่ยน - O (1)

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

รับประกัน

ไม่มีการรับประกันความซับซ้อนของเวลาที่ระบุสำหรับการดำเนินการอาร์เรย์ใด ๆ การทำงานของอาร์เรย์ขึ้นอยู่กับโครงสร้างข้อมูลพื้นฐานที่เครื่องยนต์เลือกใช้ เครื่องยนต์อาจมีการนำเสนอที่แตกต่างกันและสลับไปมาระหว่างกันขึ้นอยู่กับการวิเคราะห์พฤติกรรมบางอย่าง ขนาดอาร์เรย์เริ่มต้นอาจเป็นหรือไม่ใช่แบบฮิวริสติก

ความเป็นจริง

ตัวอย่างเช่น V8 ใช้ (ณ วันนี้) ทั้งแฮชแท็บและรายการอาร์เรย์เพื่อแสดงอาร์เรย์ นอกจากนี้ยังมีการแทนค่าต่างๆสำหรับวัตถุดังนั้นจึงไม่สามารถเปรียบเทียบอาร์เรย์และวัตถุได้ ดังนั้นการเข้าถึงอาร์เรย์จึงดีกว่า O (n) เสมอและอาจเร็วพอ ๆ กับการเข้าถึงอาร์เรย์ C ++ การต่อท้ายคือ O (1) เว้นแต่คุณจะถึงขนาดของโครงสร้างข้อมูลและจะต้องมีการปรับขนาด (ซึ่งก็คือ O (n)) Prepending แย่กว่า การลบอาจเลวร้ายยิ่งขึ้นหากคุณทำบางอย่างเช่นdelete array[index](อย่า!) เนื่องจากอาจบังคับให้เครื่องยนต์เปลี่ยนการเป็นตัวแทน

คำแนะนำ

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

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