มีอัลกอริทึมอะไรบ้างที่เราใช้ทุกวันซึ่งมีความซับซ้อน O (1), O (n log n) และ O (log n)

หากคุณต้องการตัวอย่างของอัลกอริทึม / กลุ่มงบที่มีความซับซ้อนของเวลาตามที่ระบุในคำถามนี่คือรายการเล็ก ๆ -

O(1) เวลา

• การเข้าถึง Array Index (int a = ARR [5];)
• การแทรกโหนดในรายการที่เชื่อมโยง
• การผลักดันและการแสดงบนกอง
• การแทรกและการนำออกจากคิว
• ค้นหาพาเรนต์หรือชายด์ซ้าย / ขวาของโหนดในทรีที่จัดเก็บใน Array
• ข้ามไปที่องค์ประกอบถัดไป / ก่อนหน้าในรายการที่เชื่อมโยงเป็นทวีคูณ

O(n) เวลา

สรุปได้ว่าอัลกอริทึม Brute Force ทั้งหมดหรือ Noob ที่ต้องการความเป็นเชิงเส้นจะขึ้นอยู่กับความซับซ้อนของเวลา O (n)

• ข้ามอาร์เรย์
• ข้ามผ่านรายการที่เชื่อมโยง
• การค้นหาเชิงเส้น
• การลบองค์ประกอบเฉพาะในรายการที่เชื่อมโยง (ไม่เรียงลำดับ)
• การเปรียบเทียบสองสาย
• กำลังตรวจสอบ Palindrome
• การนับ / การจัดเรียงถังและที่นี่คุณจะพบตัวอย่างอีกนับล้านตัวอย่าง ....

O(log n) เวลา

• การค้นหาแบบไบนารี
• การค้นหาจำนวนที่มากที่สุด / น้อยที่สุดในโครงสร้างการค้นหาแบบไบนารี
• ขั้นตอนวิธีการแบ่งและพิชิตบางอย่างตามฟังก์ชันเชิงเส้น
• การคำนวณตัวเลข Fibonacci - วิธีที่ดีที่สุดหลักฐานพื้นฐานที่นี่ไม่ได้ใช้ข้อมูลที่สมบูรณ์และลดขนาดปัญหาด้วยการทำซ้ำทุกครั้ง

O(n log n) เวลา

ปัจจัยของ 'log n' ถูกนำมาใช้โดยการพิจารณา Divide and Conquer อัลกอริทึมเหล่านี้บางส่วนเป็นอัลกอริทึมที่เหมาะสมที่สุดและใช้บ่อย

• ผสานการเรียง
• กองเรียง
• จัดเรียงด่วน
• อัลกอริทึมการแบ่งและพิชิตบางอย่างตามการเพิ่มประสิทธิภาพอัลกอริทึม O (n ^ 2)

O(n^2) เวลา

สิ่งเหล่านี้ควรจะเป็นอัลกอริทึมที่มีประสิทธิภาพน้อยกว่าหากมีคู่ O (nlogn) อยู่ แอปพลิเคชันทั่วไปอาจเป็น Brute Force ที่นี่

• เรียงฟอง
• เรียงลำดับการแทรก
• เรียงลำดับการเลือก
• ข้ามอาร์เรย์ 2D ธรรมดา ๆ

ตัวอย่างง่ายๆของO(1)อาจเป็นreturn 23;- ไม่ว่าอินพุตใดก็ตามสิ่งนี้จะส่งกลับในเวลาที่แน่นอนและ จำกัด

ตัวอย่างทั่วไปของO(N log N)การจัดเรียงอาร์เรย์อินพุตด้วยอัลกอริทึมที่ดี (เช่นการผสาน)

ตัวอย่างทั่วไปหากO(log N)จะค้นหาค่าในอาร์เรย์อินพุตที่เรียงลำดับตามการแบ่งส่วน

O (1) - ขั้นตอนการปรุงอาหารส่วนใหญ่เป็น O (1) นั่นคือต้องใช้เวลาคงที่แม้ว่าจะมีคนทำอาหารมากขึ้นก็ตาม (ในระดับหนึ่งเนื่องจากคุณอาจใช้เนื้อที่ในหม้อ / กระทะหมด และต้องแยกปรุง)

O (เข้าสู่ระบบ) - ค้นหาบางสิ่งในสมุดโทรศัพท์ของคุณ คิดว่าการค้นหาแบบไบนารี

O (n) - อ่านหนังสือโดยที่ n คือจำนวนหน้า เป็นระยะเวลาขั้นต่ำที่ใช้ในการอ่านหนังสือ

O (nlogn) - คิดไม่ออกในทันทีว่ามีบางสิ่งที่อาจทำทุกวันนั่นคือ nlogn ... เว้นแต่คุณจะจัดเรียงการ์ดโดยทำการผสานหรือจัดเรียงอย่างรวดเร็ว!

ฉันสามารถเสนออัลกอริทึมทั่วไปให้คุณได้ ...

• O (1): การเข้าถึงองค์ประกอบในอาร์เรย์ (เช่น int i = a [9])
• O (n log n): ด่วนหรือผสาน (โดยเฉลี่ย)
• O (log n): การค้นหาแบบไบนารี

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

O (1): ค้นหาการเคลื่อนไหวต่อไปที่ดีที่สุดในหมากรุก (หรือไปเพื่อเรื่องนั้น) เนื่องจากจำนวนสถานะของเกมมี จำกัด จึงมีเพียง O (1) :-)

ไม่มีการวัดความซับซ้อนของแอปพลิเคชันซอฟต์แวร์และไม่ได้เขียนด้วยสัญกรณ์ big-O มีประโยชน์ในการวัดความซับซ้อนของอัลกอริทึมและเปรียบเทียบอัลกอริทึมในโดเมนเดียวกันเท่านั้น เป็นไปได้มากเมื่อเราพูดว่า O (n) เราหมายความว่ามันเป็น "O (n) การเปรียบเทียบ " หรือ "O (n) การคำนวณทางคณิตศาสตร์" นั่นหมายความว่าคุณไม่สามารถเปรียบเทียบอัลกอริทึมหรือแอปพลิเคชันคู่ใด ๆ

O (1) - การลบองค์ประกอบจากรายการที่เชื่อมโยงแบบทวีคูณ เช่น

typedef struct _node {
    struct _node *next;
    struct _node *prev;
    int data;
} node;


void delete(node **head, node *to_delete)
{
    .
    .
    .
}

คุณสามารถเพิ่มอัลกอริทึมต่อไปนี้ในรายการของคุณ:

O(1)- การพิจารณาว่าตัวเลขเป็นเลขคู่หรือคี่ การทำงานกับ HashMap

O(logN) - การคำนวณ x ^ N,

O(N Log N) - ระยะเวลาที่เพิ่มขึ้นยาวนานที่สุด

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

0 (logn) - การค้นหาแบบไบนารี, องค์ประกอบสูงสุดในอาร์เรย์ (สามารถมีได้มากกว่าหนึ่งจุดสูงสุด) 0 (1) - ในหลามคำนวณความยาวของรายการหรือสตริง ฟังก์ชัน len () ใช้เวลา 0 (1) ครั้ง การเข้าถึงองค์ประกอบในอาร์เรย์ใช้เวลา 0 (1) ครั้ง การกดในกองซ้อนใช้เวลา 0 (1) ครั้ง 0 (nlogn) - ผสานการจัดเรียง การเรียงลำดับใน python ใช้เวลา nlogn ดังนั้นเมื่อคุณใช้ listname.sort () ต้องใช้เวลา nlogn

การค้นหาหมายเหตุในตารางแฮชบางครั้งใช้เวลามากกว่าคงที่เนื่องจากการชนกัน

O (2 ^N )

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

int Fibonacci (int number)
{
if (number <= 1) return number;
return Fibonacci(number - 2) + Fibonacci(number - 1);
}