O (log n) หมายถึงอะไรอย่างแน่นอน

ฉันกำลังเรียนรู้เกี่ยวกับเวลาทำงานของ Big O Notation และเวลาที่ถูกตัดจำหน่าย ฉันเข้าใจความคิดของเวลาเชิงเส้นO (n)ซึ่งหมายความว่าขนาดของอินพุตมีผลต่อการเติบโตของอัลกอริทึมตามสัดส่วน ... และเช่นเดียวกันสำหรับตัวอย่างเช่นเวลากำลังสองO (n ² )ฯลฯ อัลกอริธึมที่สิบเอ็ด เช่นเครื่องปั่นไฟที่มีการเปลี่ยนแปลงด้วยเวลาO (n!)ที่เติบโตโดยแฟกทอเรียล

ตัวอย่างเช่นฟังก์ชันต่อไปนี้คือO (n)เนื่องจากอัลกอริทึมเติบโตตามสัดส่วนของอินพุตn :

f(int n) {
  int i;
  for (i = 0; i < n; ++i)
    printf("%d", i);
}

ในทำนองเดียวกันหากมีการวนซ้ำซ้อนกันเวลาจะเป็น O (n ² )

แต่O (log n)คืออะไรกันแน่? ยกตัวอย่างเช่นมันหมายความว่าอะไรที่จะบอกว่าความสูงของต้นไม้ไบนารีสมบูรณ์คือO (log n) ?

ฉันรู้ (อาจไม่ได้อยู่ในรายละเอียดที่ดี) สิ่งที่ลอการิทึมคือในแง่ที่ว่า: log ₁₀ 100 = 2 แต่ฉันไม่เข้าใจวิธีการระบุฟังก์ชันด้วยเวลาลอการิทึม

ฉันไม่เข้าใจวิธีการระบุฟังก์ชั่นด้วยเวลาบันทึก

คุณลักษณะที่พบบ่อยที่สุดของฟังก์ชั่นเวลาลอการิทึมคือ:

• ตัวเลือกขององค์ประกอบถัดไปที่จะทำการกระทำบางอย่างเป็นหนึ่งในความเป็นไปได้หลายอย่างและ
• จะต้องเลือกคนเดียวเท่านั้น

หรือ

• องค์ประกอบที่มีการดำเนินการคือตัวเลขของ n

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

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

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

นี่คือเวลาทำงานของการดำเนินการบางอย่างที่เราอาจดำเนินการกับสมุดโทรศัพท์ตั้งแต่เร็วที่สุดไปจนถึงช้าที่สุด:

• O (1) (ในกรณีที่เลวร้ายที่สุด):ในหน้าของชื่อธุรกิจที่เปิดอยู่และชื่อธุรกิจให้ค้นหาหมายเลขโทรศัพท์

• O (1) (ในกรณีโดยเฉลี่ย):ในหน้าที่ชื่อของบุคคลนั้นอยู่บนและชื่อของพวกเขาค้นหาหมายเลขโทรศัพท์

• O (บันทึก n):ระบุชื่อของบุคคลค้นหาหมายเลขโทรศัพท์โดยเลือกจุดสุ่มประมาณครึ่งทางของหนังสือที่คุณยังไม่ได้ค้นหาจากนั้นตรวจสอบเพื่อดูว่าชื่อของบุคคลนั้นอยู่ที่จุดนั้นหรือไม่ จากนั้นทำซ้ำกระบวนการประมาณครึ่งทางผ่านส่วนหนึ่งของหนังสือที่ชื่อของบุคคลนั้นอยู่ (นี่คือการค้นหาแบบไบนารีสำหรับชื่อของบุคคล)

• O (n):ค้นหาทุกคนที่มีหมายเลขโทรศัพท์มีตัวเลข "5"

• O (n):ระบุหมายเลขโทรศัพท์ค้นหาบุคคลหรือธุรกิจด้วยหมายเลขนั้น

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

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

• O (n log n):เราต้องการปรับแต่งสมุดโทรศัพท์ดังนั้นเราจะหาชื่อบุคคลหรือธุรกิจของแต่ละคนในสำเนาที่ได้รับมอบหมายจากนั้นวนชื่อของพวกเขาในหนังสือและเขียนบันทึกขอบคุณสั้น ๆ สำหรับอุปถัมภ์ .

• O (n ² ):มีข้อผิดพลาดเกิดขึ้นที่สำนักงานและทุกรายการในสมุดโทรศัพท์แต่ละเล่มจะมี "0" เพิ่มเติมในตอนท้ายของหมายเลขโทรศัพท์ ใช้สีขาวและลบแต่ละศูนย์

• O (n · n!):เราพร้อมที่จะโหลดสมุดโทรศัพท์ลงในแท่นจัดส่ง น่าเสียดายที่หุ่นยนต์ที่ควรจะโหลดหนังสือหายไปแล้ว: มันวางหนังสือลงบนรถบรรทุกตามลำดับแบบสุ่ม! ยิ่งไปกว่านั้นมันโหลดหนังสือทั้งหมดลงบนรถบรรทุกจากนั้นตรวจสอบเพื่อดูว่าพวกเขาอยู่ในลำดับที่ถูกต้องหรือไม่และถ้าไม่มันจะทำการโหลดหนังสือและเริ่มใหม่ (นี่คือการจัดเรียง bogo ที่หวั่นกลัว)

• O (n ⁿ ):คุณซ่อมหุ่นยนต์เพื่อให้มันโหลดสิ่งต่าง ๆ ได้อย่างถูกต้อง ในวันถัดไปเพื่อนร่วมงานคนหนึ่งของคุณเล่นตลกกับคุณและวางสายหุ่นยนต์แท่นวางสินค้าเข้ากับระบบการพิมพ์อัตโนมัติ ทุกครั้งที่หุ่นยนต์ไปโหลดหนังสือต้นฉบับเครื่องพิมพ์จากโรงงานจะทำซ้ำสมุดโทรศัพท์ทั้งหมด! โชคดีที่ระบบตรวจจับข้อผิดพลาดของหุ่นยนต์มีความซับซ้อนพอที่หุ่นยนต์จะไม่ลองพิมพ์สำเนาเพิ่มเติมเมื่อพบหนังสือซ้ำสำหรับการโหลด แต่ยังต้องโหลดหนังสือต้นฉบับและสำเนาที่พิมพ์ซ้ำทุกเล่ม

O(log N)โดยทั่วไปหมายถึงเวลาเพิ่มขึ้นเป็นเส้นตรงในขณะที่เวลาnเพิ่มขึ้นชี้แจง ดังนั้นถ้าใช้เวลา1ในการคำนวณ10องค์ประกอบที่สองมันจะใช้เวลาไม่2กี่วินาทีในการคำนวณ100องค์ประกอบ, 3วินาทีในการคำนวณ1000องค์ประกอบและอื่น ๆ

มันเป็นO(log n)เมื่อเราทำแบ่งและพิชิตการค้นหาแบบไบนารีขั้นตอนวิธีการเช่น อีกตัวอย่างหนึ่งคือการจัดเรียงอย่างรวดเร็วโดยที่แต่ละครั้งที่เราแบ่งอาร์เรย์ออกเป็นสองส่วนและแต่ละครั้งที่ใช้O(N)เวลาในการค้นหาองค์ประกอบสาระสำคัญ ดังนั้นมัน N O(log N)

คำตอบที่ดีมากมายได้ถูกโพสต์ไปยังคำถามนี้แล้ว แต่ฉันเชื่อว่าเราขาดคำตอบที่สำคัญไปแล้วนั่นคือคำตอบที่แสดงไว้

มันหมายความว่าอย่างไรที่ความสูงของต้นไม้ไบนารีสมบูรณ์คือ O (log n)

รูปวาดต่อไปนี้แสดงให้เห็นถึงต้นไม้ไบนารี สังเกตว่าแต่ละระดับมีจำนวนของโหนดเป็นสองเท่าเมื่อเทียบกับระดับที่สูงกว่า (ดังนั้นไบนารี ):

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

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

การพล็อตlog(n)บนกระดาษธรรมดาจะส่งผลให้กราฟที่เส้นโค้งที่nเพิ่มขึ้นช้าลงเมื่อเพิ่มขึ้น:

คำอธิบายด้านล่างคือการใช้กรณีของต้นไม้ไบนารีที่สมดุลอย่างเต็มที่เพื่อช่วยให้คุณเข้าใจว่าเรามีความซับซ้อนของเวลาลอการิทึม

ต้นไม้ไบนารีเป็นกรณีที่ปัญหาของขนาด n ถูกแบ่งออกเป็นปัญหาย่อยของขนาด n / 2 จนกว่าเราจะถึงปัญหาของขนาด 1:

และนั่นคือวิธีที่คุณได้ O (log n) ซึ่งเป็นปริมาณงานที่ต้องทำบนต้นไม้ด้านบนเพื่อให้ได้ทางออก

อัลกอริทึมทั่วไปที่มีความซับซ้อนของเวลา O (log n) คือการค้นหาแบบไบนารีซึ่งมีความสัมพันธ์แบบเรียกซ้ำคือ T (n / 2) + O (1) คือในทุก ๆ ระดับของต้นไม้ที่คุณแบ่งปัญหาออกเป็นครึ่งและทำงานเพิ่มเติมจำนวนคงที่

ภาพรวม

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

ครั้งแรกที่คุณจะต้องมีความคิดทั่วไปของลอการิทึมซึ่งคุณสามารถได้รับจากhttps://en.wikipedia.org/wiki/Logarithm การใช้วิทยาศาสตร์ธรรมชาติeและบันทึกทางธรรมชาติ สาวกวิศวกรรมจะใช้ log_10 (ฐาน 10) และนักวิทยาศาสตร์คอมพิวเตอร์จะใช้ log_2 (ฐานฐาน 2) เป็นจำนวนมากเนื่องจากคอมพิวเตอร์เป็นฐานไบนารี บางครั้งคุณจะเห็นตัวย่อของบันทึกธรรมชาติเป็นln()วิศวกรปกติออกจาก _10 ออกและใช้เพียงlog()และ log_2 lg()ย่อเป็น log(n)ทุกประเภทลอการิทึมเติบโตในลักษณะคล้ายนั่นคือเหตุผลที่พวกเขาร่วมกันประเภทเดียวกันของ

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

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

ตัวอย่างโค้ดแบบง่ายของหมวดหมู่ Big O ต่างๆ:

O (1) - ตัวอย่างเวลาคงที่:

• อัลกอริทึม 1:

ขั้นตอนวิธีการพิมพ์ 1 สวัสดีอีกครั้งและมันไม่ได้ขึ้นอยู่กับ n O(1)ดังนั้นจึงมักจะทำงานในเวลาที่คงที่ดังนั้นจึงเป็น

print "hello";

• อัลกอริทึม 2:

อัลกอริทึม 2 พิมพ์ hello 3 ครั้งอย่างไรก็ตามมันไม่ได้ขึ้นอยู่กับขนาดอินพุต แม้เมื่อเติบโตขึ้นอัลกอริทึมนี้จะพิมพ์ Hello 3 ครั้งเท่านั้น ที่ถูกกล่าวว่า 3 เป็นค่าคงที่ดังนั้นอัลกอริทึมนี้ก็เช่นO(1)กัน

print "hello";
print "hello";
print "hello";

O (บันทึก (n)) - ตัวอย่างลอการิทึม:

• อัลกอริทึม 3 - สิ่งนี้ทำหน้าที่เหมือน "log_2"

อัลกอริทึม 3 แสดงให้เห็นถึงอัลกอริทึมที่ทำงานใน log_2 (n) สังเกตการดำเนินการโพสต์ของ for for ทวีคูณทวีคูณมูลค่าปัจจุบันของ i ด้วย 2 ดังนั้นiไปจาก 1 ถึง 2 ถึง 4 ถึง 8 ถึง 16 ถึง 32 ถึง 32 ...

for(int i = 1; i <= n; i = i * 2)
  print "hello";

• อัลกอริทึม 4 - สิ่งนี้ทำหน้าที่เหมือน "log_3"

อัลกอริทึม 4 แสดงให้เห็นถึง log_3 การแจ้งเตือนiเริ่มจาก 1 ถึง 3 ถึง 9 ถึง 27 ...

for(int i = 1; i <= n; i = i * 3)
  print "hello";

• อัลกอริทึม 5 - สิ่งนี้ทำหน้าที่เหมือน "log_1.02"

อัลกอริทึม 5 มีความสำคัญเนื่องจากช่วยแสดงว่าตราบใดที่จำนวนมากกว่า 1 และผลลัพธ์นั้นคูณกับตัวเองซ้ำ ๆ คุณกำลังมองหาอัลกอริทึมลอการิทึม

for(double i = 1; i < n; i = i * 1.02)
  print "hello";

O (n) - ตัวอย่างเวลาเชิงเส้น:

• อัลกอริทึม 6

อัลกอริทึมนี้ง่ายซึ่งพิมพ์ hello n ครั้ง

for(int i = 0; i < n; i++)
  print "hello";

• อัลกอริทึม 7

อัลกอริทึมนี้แสดงรูปแบบที่จะพิมพ์ hello n / 2 ครั้ง n / 2 = 1/2 * n เราไม่สนใจค่าคงที่ 1/2 และดูว่าอัลกอริทึมนี้คือ O (n)

for(int i = 0; i < n; i = i + 2)
  print "hello";

O (n * log (n)) - nlog (n) ตัวอย่าง:

• อัลกอริทึม 8

คิดว่านี้เป็นส่วนผสมของและO(log(n)) O(n)การทำรังของลูปช่วยให้เราได้รับO(n*log(n))

for(int i = 0; i < n; i++)
  for(int j = 1; j < n; j = j * 2)
    print "hello";

• อัลกอริทึม 9

อัลกอริทึม 9 เหมือนกับอัลกอริทึม 8 แต่แต่ละลูปอนุญาตการเปลี่ยนแปลงได้ซึ่งยังคงเป็นผลลัพธ์สุดท้าย O(n*log(n))

for(int i = 0; i < n; i = i + 2)
  for(int j = 1; j < n; j = j * 3)
    print "hello";

O (n ^ 2) - n กำลังสองตัวอย่าง:

• อัลกอริทึม 10

O(n^2) สามารถทำได้ง่ายโดยการทำรังมาตรฐานสำหรับลูป

for(int i = 0; i < n; i++)
  for(int j = 0; j < n; j++)
    print "hello";

• อัลกอริทึม 11

เช่นเดียวกับอัลกอริทึม 10 แต่มีรูปแบบบางอย่าง

for(int i = 0; i < n; i++)
  for(int j = 0; j < n; j = j + 2)
    print "hello";

O (n ^ 3) - n cubed ตัวอย่าง:

• อัลกอริทึม 12

นี่เป็นเหมือนอัลกอริทึม 10 แต่มี 3 ลูปแทน 2

for(int i = 0; i < n; i++)
  for(int j = 0; j < n; j++)
    for(int k = 0; k < n; k++)
      print "hello";

• อัลกอริทึม 13

เช่นเดียวกับอัลกอริทึมที่ 12 O(n^3)แต่มีการเปลี่ยนแปลงบางอย่างที่ยังคงให้ผลผลิต

for(int i = 0; i < n; i++)
  for(int j = 0; j < n + 5; j = j + 2)
    for(int k = 0; k < n; k = k + 3)
      print "hello";

สรุป

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

หากคุณมีฟังก์ชั่นที่ใช้:

1 millisecond to complete if you have 2 elements.
2 milliseconds to complete if you have 4 elements.
3 milliseconds to complete if you have 8 elements.
4 milliseconds to complete if you have 16 elements.
...
n milliseconds to complete if you have 2^n elements.

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

เวลาทำงานลอการิทึม ( O(log n)) เป็นหลักหมายถึงว่าเวลาทำงานเพิ่มขึ้นตามสัดส่วนลอการิทึมของขนาดอินพุต - เป็นตัวอย่างถ้า 10 รายการใช้เวลามากที่สุดxและ 100 รายการใช้เวลามากที่สุดพูด2xและ 10,000 รายการ ใช้เวลาอย่างมาก4xจากนั้นก็ดูเหมือนO(log n)ความซับซ้อนของเวลา

ลอการิทึม

ตกลงลองและเข้าใจอย่างเต็มที่ว่าลอการิทึมจริงคืออะไร

ลองนึกภาพเรามีเชือกและผูกมันไว้กับม้า หากเชือกผูกติดกับม้าโดยตรงแรงของม้าจะต้องดึงออกไป (พูดจากชาย) คือ 1 โดยตรง

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

ทีนี้ถ้าเชือกวนหนึ่งครั้งม้าจะต้องดึงให้หนักขึ้น 10 เท่า หากมนุษย์ตัดสินใจที่จะทำให้มันยากจริงๆสำหรับม้าเขาอาจผูกเชือกรอบเสาอีกครั้งเพื่อเพิ่มความแข็งแรงโดยเพิ่มอีก 10 เท่า การวนซ้ำครั้งที่สามจะเพิ่มความแข็งแกร่งอีกครั้งอีก 10 ครั้ง

เราจะเห็นได้ว่าสำหรับแต่ละลูปค่าเพิ่มขึ้น 10 จำนวนเทิร์นที่ต้องใช้ในการรับจำนวนใด ๆ เรียกว่าลอการิทึมของตัวเลขนั่นคือเราต้องการโพสต์ 3 ครั้งเพื่อเพิ่มความแข็งแรงของคุณ 1000 ครั้ง 6 โพสต์ 1,000,000

3 คือลอการิทึม 1,000 และ 6 คือลอการิทึม 1,000,000 (ฐาน 10)

ดังนั้น O (log n) หมายถึงอะไรจริง?

ในตัวอย่างข้างต้นของเรา 'อัตราการเจริญเติบโตของเราคือO (log n) สำหรับทุกวงเพิ่มเติมแรงเชือกของเราสามารถจัดการได้มากกว่า 10 เท่า:

Turns | Max Force
  0   |   1
  1   |   10
  2   |   100
  3   |   1000
  4   |   10000
  n   |   10^n

ตอนนี้ตัวอย่างข้างต้นใช้ฐาน 10 แต่โชคดีที่ฐานของบันทึกไม่มีนัยสำคัญเมื่อเราพูดถึงสัญลักษณ์ขนาดใหญ่

ทีนี้ลองจินตนาการว่าคุณกำลังพยายามเดาตัวเลขระหว่าง 1-100

Your Friend: Guess my number between 1-100! 
Your Guess: 50
Your Friend: Lower!
Your Guess: 25
Your Friend: Lower!
Your Guess: 13
Your Friend: Higher!
Your Guess: 19
Your Friend: Higher!
Your Friend: 22
Your Guess: Lower!
Your Guess: 20
Your Friend: Higher!
Your Guess: 21
Your Friend: YOU GOT IT!  

ตอนนี้คุณต้องเดาให้ถูก 7 ข้อ แต่ความสัมพันธ์ที่นี่คืออะไร? ไอเท็มจำนวนมากที่สุดที่คุณสามารถเดาได้จากการเดาเพิ่มเติมแต่ละครั้งคืออะไร?

Guesses | Items
  1     |   2
  2     |   4
  3     |   8
  4     |   16
  5     |   32
  6     |   64
  7     |   128
  10    |   1024

เมื่อใช้กราฟเราจะเห็นว่าถ้าเราใช้การค้นหาแบบไบนารี่เพื่อคาดเดาตัวเลขระหว่าง 1-100 จะทำให้เราลองได้ไม่เกิน 7 ครั้ง ถ้าเรามีตัวเลข 128 ตัวเราก็สามารถเดาได้ว่าตัวเลขใน 7 attemps แต่ 129 ตัวเลขนั้นจะพาเราไปมากที่สุด 8 ครั้ง (ในความสัมพันธ์กับลอการิทึมที่นี่เราจะต้อง 7 เดาสำหรับช่วงค่า 128, 10 เดาสำหรับช่วงค่า 1024 . 7 คือลอการิทึมของ 128, 10 คือลอการิทึมของ 1024 (ฐาน 2))

สังเกตว่าฉันมีตัวหนา 'มากที่สุด' สัญลักษณ์ Big-O มักอ้างถึงกรณีที่แย่กว่านั้น หากคุณโชคดีคุณสามารถเดาได้ในหนึ่งครั้งดังนั้นกรณีที่ดีที่สุดคือ O (1) แต่นั่นเป็นอีกเรื่องหนึ่ง

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

แล้ว O (n log n) ล่ะ?

ในที่สุดคุณจะเจออัลกอริธึมเชิงเส้นเวลาO (n log (n)) กฎของหัวแม่มือด้านบนนำไปใช้อีกครั้ง แต่คราวนี้ฟังก์ชั่นลอการิทึมต้องทำงาน n ครั้งเช่นการลดขนาดของรายการn ครั้งซึ่งเกิดขึ้นในอัลกอริทึมเช่นการรวมกัน

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

Disclaimer: ตัวอย่างเชือกลอการิทึมถูกคว้ายอดเยี่ยมจากหนังสือ Delight คณิตศาสตร์โดย W.Sawyer

คุณสามารถคิดถึง O (log N) โดยสังเขปโดยบอกว่าเวลาเป็นสัดส่วนกับจำนวนหลักใน N

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

หากการดำเนินการทำให้ชุดของเวลาคงที่ตัดสินใจแต่ละส่วนแบ่งครึ่ง (ลดลงด้วยปัจจัย 3, 4, 5 .. ) ขนาดของอินพุตที่จะพิจารณาทั้งหมดจะต้องใช้เวลาสัดส่วนกับฐาน 2 (ฐาน 3) , ฐาน 4, ฐาน 5 ... ) ของขนาด N ของอินพุตแทนที่จะเป็น O (N)

และอื่น ๆ

วิธีที่ดีที่สุดที่ฉันต้องนึกภาพอัลกอริทึมที่ทำงานใน O (log n) เป็นดังนี้:

หากคุณเพิ่มขนาดปัญหาด้วยจำนวนทวีคูณ (เช่นคูณขนาดด้วย 10) งานจะเพิ่มขึ้นตามจำนวนที่เพิ่มขึ้นเท่านั้น

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

ก่อนอื่นผมขอแนะนำให้คุณอ่านหนังสือต่อไปนี้

อัลกอริทึม (รุ่นที่ 4)

นี่คือฟังก์ชั่นบางอย่างและความซับซ้อนที่คาดหวัง ตัวเลขจะแสดงให้เห็นความถี่การดำเนินการคำสั่ง

การติดตามBig-O Complexity Chartยังนำมาจากbigocheatsheet

ในที่สุดการแสดงที่เรียบง่ายมากก็จะแสดงวิธีการคำนวณ

กายวิภาคของความถี่ในการประมวลผลคำสั่งของโปรแกรม

การวิเคราะห์เวลาทำงานของโปรแกรม (ตัวอย่าง)

บันทึก_b (n) คืออะไร

มันคือจำนวนครั้งที่คุณสามารถตัดบันทึกของความยาว n ซ้ำ ๆ กันเป็นส่วนเท่า ๆ กัน b ก่อนถึงส่วนที่มีขนาด 1

อัลกอริทึมหารและพิชิตมักจะมี lognองค์ประกอบในเวลาทำงาน สิ่งนี้มาจากการลดลงครึ่งหนึ่งของอินพุต

ในกรณีของการค้นหาแบบไบนารีการวนซ้ำทุกครั้งที่คุณทิ้งครึ่งหนึ่งของอินพุต ควรสังเกตว่าในสัญกรณ์ Big-O บันทึกเป็นฐาน 2

แก้ไข: ดังที่บันทึกไว้ฐานบันทึกไม่สำคัญ แต่เมื่อได้รับประสิทธิภาพการทำงานของ Big-O ของอัลกอริทึมปัจจัยบันทึกจะมาจากการลดลงครึ่งหนึ่งดังนั้นทำไมฉันจึงคิดว่ามันเป็นฐาน 2

แต่ O (log n) คืออะไรกันแน่? ตัวอย่างเช่นมันหมายความว่าอย่างไรที่บอกว่าความสูงของต้นไม้ไบนารีสมบูรณ์คือ O (log n)

ฉันจะใช้ถ้อยคำนี้ใหม่ในขณะที่ 'ความสูงของต้นไม้ไบนารีสมบูรณ์คือ log n' การหาความสูงของต้นไม้ไบนารีที่สมบูรณ์จะเป็น O (บันทึก n) หากคุณสำรวจไปทีละขั้นตอน

ฉันไม่สามารถเข้าใจวิธีระบุฟังก์ชันด้วยเวลาลอการิทึม

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

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

ทั้งสองกรณีนี้จะใช้เวลา O (บันทึก n)

case 1: f(int n) {
      int i;
      for (i = 1; i < n; i=i*2)
        printf("%d", i);
    }


 case 2  : f(int n) {
      int i;
      for (i = n; i>=1 ; i=i/2)
        printf("%d", i);
    }

O (บันทึก n) เป็นการเข้าใจผิดเล็กน้อยและแม่นยำยิ่งขึ้นว่า O (บันทึก₂₎ n) คือ (ลอการิทึมพร้อมฐาน 2)

ความสูงของต้นไม้ไบนารีสมดุลเป็น O (log ₂ n) เนื่องจากทุกโหนดมีสอง (โน้ต "สอง" ในบันทึก₂ n) โหนดลูก ดังนั้นต้นไม้ที่มีโหนด n มีความสูงของบันทึก₂ n

อีกตัวอย่างหนึ่งคือการค้นหาแบบไบนารีซึ่งมีเวลาทำงานของ O (บันทึก₂ n) เพราะในทุกขั้นตอนคุณแบ่งการค้นหาด้วย 2

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

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

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

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

ความซับซ้อนเวลาทำงานของ merge sort O(n log n)เป็นตัวอย่างของ นี่เป็นเพราะคุณกำลังแบ่งอาร์เรย์ออกเป็นสองส่วนด้วยกันในแต่ละขั้นตอนทำให้มีผลรวมขั้นตอนการบันทึก (n) / บันทึก (2) โดยประมาณ อย่างไรก็ตามในแต่ละขั้นตอนคุณจะต้องดำเนินการผสานกับองค์ประกอบทั้งหมด (ไม่ว่าจะเป็นการดำเนินการผสานหนึ่งในสองรายการย่อยขององค์ประกอบ n / 2 หรือสองผสานการดำเนินงานในสี่รายการย่อยขององค์ประกอบ n / 4 ไม่เกี่ยวข้องเพราะมันจะต้อง ทำสิ่งนี้สำหรับองค์ประกอบ n ในแต่ละขั้นตอน) O(n log n)ดังนั้นความซับซ้อนรวม

* โปรดจำไว้ว่าสัญกรณ์ใหญ่ -O ตามคำนิยามค่าคงที่ไม่สำคัญ นอกจากนี้การเปลี่ยนแปลงกฎพื้นฐานสำหรับลอการิทึมความแตกต่างเพียงอย่างเดียวระหว่างลอการิทึมของฐานต่าง ๆ เป็นปัจจัยคงที่

มันหมายความว่าเวลาที่จำเป็นสำหรับงานนี้เพิ่มขึ้นด้วย log (n) (ตัวอย่าง: 2s สำหรับ n = 10, 4s สำหรับ n = 100, ... ) อ่านบทความวิกิพีเดียค้นหาแบบไบนารีขั้นตอนวิธีการและBig O โน้ตสำหรับแม่นยำมากขึ้น

ใส่เพียง: ในแต่ละขั้นตอนของอัลกอริทึมของคุณคุณสามารถตัดงานครึ่ง (เท่ากับ Asymptotically เทียบเท่ากับสาม, สี่, ... )

หากคุณพล็อตฟังก์ชั่นลอการิทึมบนเครื่องคิดเลขกราฟิกหรือสิ่งที่คล้ายกันคุณจะเห็นว่ามันเพิ่มขึ้นช้ามาก - ช้ากว่าฟังก์ชั่นเชิงเส้น

นี่คือเหตุผลว่าทำไมอัลกอริธึมที่มีความซับซ้อนของเวลาลอการิทึมจึงเป็นที่ต้องการอย่างสูง: แม้แต่ในกรณีที่มีขนาดใหญ่มาก (ตัวอย่างเช่น n = 10 ^ 8 เป็นต้น) พวกมันทำงานได้ดีกว่าที่ยอมรับได้

แต่สิ่งที่แน่นอนคือ O (log n)

มันหมายถึงอะไรอย่างแม่นยำคือ "เป็นnมีแนวโน้มไปทางinfinityที่timeมีแนวโน้มไปทางa*log(n)ที่aเป็นปัจจัยคงปรับ"

หรือที่จริงแล้วมันไม่ได้หมายความอย่างนั้น มีโอกาสมากขึ้นที่มันหมายถึงบางสิ่งเช่น " timeหารด้วยa*log(n)แนวโน้ม1"

"มีแนวโน้มต่อ" มีความหมายทางคณิตศาสตร์ตามปกติจาก 'การวิเคราะห์': ตัวอย่างเช่นว่า "ถ้าคุณเลือกค่าคงที่ที่ไม่เป็นศูนย์ขนาดเล็กโดยพลการใด ๆkฉันสามารถหาค่าที่สอดคล้องกันได้Xซึ่ง((time/(a*log(n))) - 1)น้อยกว่าkค่าทั้งหมดที่nมากกว่าX"

ในแง่การวางก็หมายความว่าสมการเวลาอาจมีองค์ประกอบอื่น ๆ : เช่นมันอาจมีเวลาเริ่มต้นคงที่บางอย่าง; แต่ส่วนประกอบอื่น ๆ เหล่านี้ซีดไปทางความไม่สำคัญสำหรับค่าขนาดใหญ่ของ n และ a * log (n) เป็นคำที่มีอำนาจเหนือสำหรับ n ขนาดใหญ่

โปรดทราบว่าหากสมการนั้นเป็นเช่น ...

เวลา (n) = a + b บันทึก (n) + c n + d n n

... จากนั้นจะเป็น O (n กำลังสอง) เพราะไม่ว่าคุณค่าของค่าคงที่ a, b, c, และไม่ใช่ศูนย์ d d*n*nคำนั้นจะมีอิทธิพลเหนือผู้อื่นเสมอสำหรับค่าขนาดใหญ่ที่เพียงพอของ n

นั่นคือความหมายของสัญกรณ์ O: มันหมายถึง "อะไรคือคำสั่งของศัพท์ที่เด่นสำหรับ n ที่มีขนาดใหญ่พอสมควร"

ฉันสามารถเพิ่มสิ่งที่น่าสนใจที่ฉันอ่านในหนังสือโดย Kormen และอื่น ๆ เมื่อนานมาแล้ว ทีนี้ลองจินตนาการถึงปัญหาที่เราต้องหาทางแก้ปัญหาในพื้นที่ที่มีปัญหา พื้นที่ปัญหานี้ควรมีขอบเขต จำกัด

ทีนี้ถ้าคุณสามารถพิสูจน์ได้ว่าในทุกๆการวนซ้ำของอัลกอริทึมของคุณคุณตัดส่วนของพื้นที่นี้นั่นไม่น้อยกว่าขีด จำกัด นั่นหมายความว่าอัลกอริทึมของคุณทำงานในเวลา O (logN)

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

ฉันสามารถยกตัวอย่างสำหรับ a for loop และบางทีเมื่อเข้าใจแนวคิดแล้วอาจจะง่ายกว่าที่จะเข้าใจในบริบทที่แตกต่างกัน

นั่นหมายความว่าในลูปขั้นตอนจะเพิ่มขึ้นแบบทวีคูณ เช่น

for (i=1; i<=n; i=i*2) {;}

ความซับซ้อนของ O-notation ของโปรแกรมนี้คือ O (log (n)) ลองวนซ้ำด้วยมือ (n อยู่ระหว่าง 512 ถึง 1,023 (ยกเว้น 1024):

step: 1   2   3   4   5    6    7    8     9     10
   i: 1   2   4   8   16   32   64   128   256   512

แม้ว่า n จะอยู่ระหว่าง 512 ถึง 1,023 แต่จะมีการทำซ้ำ 10 ครั้งเท่านั้น นี่เป็นเพราะขั้นตอนในการวนซ้ำเพิ่มขึ้นแบบทวีคูณและใช้เวลาเพียง 10 รอบในการยกเลิก

ลอการิทึมของ x (ไปยังฐานของ a) คือฟังก์ชันย้อนกลับของ a ^ x

มันก็เหมือนกับการพูดว่าลอการิทึมเป็นสิ่งที่ตรงกันข้ามของการชี้แจง

ทีนี้ลองดูวิธีนั้นถ้าเลขชี้กำลังเติบโตเร็วมากจากนั้นลอการิทึมจะเพิ่มขึ้น (ผกผัน) ช้ามาก

ความแตกต่างระหว่าง O (n) และ O (log (n)) มีขนาดใหญ่คล้ายกับความแตกต่างระหว่าง O (n) และ O (a ^ n) (เป็นค่าคงที่)

ที่จริงถ้าคุณมีรายการขององค์ประกอบ n และสร้างต้นไม้ไบนารีจากรายการนั้น (เช่นในอัลกอริทึมหารและพิชิต) คุณจะยังคงหารด้วย 2 จนกว่าจะถึงรายการขนาด 1 (ใบ)

ในขั้นตอนแรกคุณหารด้วย 2 จากนั้นคุณมี 2 รายการ (2 ^ 1) คุณหารด้วย 2 ดังนั้นคุณมี 4 รายการ (2 ^ 2) คุณหารอีกครั้งคุณมี 8 รายการ (2 ^ 3) ) และอื่น ๆ จนกว่าขนาดรายการของคุณคือ 1

นั่นให้สมการกับคุณ:

n/(2^steps)=1 <=> n=2^steps <=> lg(n)=steps

(คุณใช้ lg ของแต่ละด้าน lg เป็นฐานบันทึก 2)

ทุกครั้งที่เราเขียนอัลกอริธึมหรือรหัสเราพยายามวิเคราะห์ความซับซ้อนเชิงซีมโทติค มันจะแตกต่างจากของมันซับซ้อนเวลา

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

เพราะความซับซ้อนของเวลาขึ้นอยู่กับพารามิเตอร์ต่างๆ ได้แก่
1. ระบบทางกายภาพ
2. ภาษาโปรแกรม
3. สไตล์การเข้ารหัส
4. และอื่น ๆ อีกมากมาย ......

เวลาดำเนินการจริงไม่ใช่มาตรการที่ดีสำหรับการวิเคราะห์

แต่เราใช้ขนาดอินพุตเป็นพารามิเตอร์เพราะสิ่งที่เป็นรหัสอินพุตเหมือนกัน ดังนั้นเวลาดำเนินการจึงเป็นฟังก์ชันของขนาดอินพุต

ต่อไปนี้เป็นตัวอย่างของ Linear Time Algorithm

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

และไม่เพียง แต่ค้นหาสิ่งที่อาจจะเป็นงาน (เพิ่มขึ้นเปรียบเทียบหรือการดำเนินการใด ๆ ) มันเป็นฟังก์ชั่นของขนาดอินพุต

ดังนั้นเมื่อคุณพูดว่าอัลกอริธึมใด ๆ คือ O (log n) หมายถึงเวลาดำเนินการคือ log คูณขนาดอินพุต n

เมื่อขนาดอินพุตเพิ่มขึ้นงานที่ทำ (นี่คือเวลาดำเนินการ) เพิ่มขึ้น (ดังนั้นสัดส่วน)

      n      Work
      2     1 units of work
      4     2 units of work
      8     3 units of work

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

log x to base b = y เป็นสิ่งที่ตรงกันข้าม b^y = x

หากคุณมีต้นไม้ M-ary ของความลึก d และขนาด n ดังนั้น:

• ภายในต้นไม้ทั้งหมด ~ O (M ^ d) = O (n)

• เดินเส้นทางเดียวในต้นไม้ ~ O (d) = O (log n ไปยังฐาน M)

ในเทคโนโลยีสารสนเทศหมายถึง:

  f(n)=O(g(n)) If there is suitable constant C and N0 independent on N, 
  such that
  for all N>N0  "C*g(n) > f(n) > 0" is true.

Ant ดูเหมือนว่าสัญลักษณ์นี้ส่วนใหญ่นำมาจากคณิตศาสตร์

ในบทความนี้มีข้อความอ้างอิง: DE Knuth, "BIG OMICRON และ BIG OMEGA และ BIG THETA", 1976 :

บนพื้นฐานของปัญหาที่กล่าวถึงที่นี่ผมเสนอว่าสมาชิกของ SIGACT และบรรณาธิการของวิทยาศาสตร์คอมพิวเตอร์และวารสารคณิตศาสตร์นำมาใช้สัญลักษณ์ตามที่กำหนดไว้ข้างต้นเว้นแต่ทางเลือกที่ดีที่สามารถพบได้ในเร็ว ๆ นี้พอสมควร

วันนี้เป็นปี 2016 แต่เรายังใช้อยู่ในปัจจุบัน

ในการวิเคราะห์ทางคณิตศาสตร์หมายความว่า:

  lim (f(n)/g(n))=Constant; where n goes to +infinity

แต่ในการวิเคราะห์ทางคณิตศาสตร์บางครั้งสัญลักษณ์นี้ใช้ในความหมาย "C * g (n)> f (n)> 0"

อย่างที่ฉันรู้จากมหาวิทยาลัยสัญลักษณ์ถูกใช้โดยนักคณิตศาสตร์ชาวเยอรมัน Landau (1877-1938)

ตัวอย่างไบนารีที่สมบูรณ์คือ O (ln n) เนื่องจากการค้นหามีลักษณะดังนี้:

1 2 3 4 5 6 7 8 9 10 11 12

ค้นหา 4 อัตราผลตอบแทน 3 ครั้ง: 6, 3 แล้ว 4 และ log2 12 = 3 ซึ่งเป็นลักษณะที่ดีต่อจำนวนครั้งที่ต้องการ

หากคุณกำลังมองหาคำตอบจากสัญชาตญาณฉันอยากจะตีความสองอย่างสำหรับคุณ

1. ลองนึกภาพเขาที่สูงมากที่มีฐานกว้างมากเช่นกัน ในการขึ้นไปถึงยอดเขามีสองวิธี: หนึ่งคือเส้นทางที่มุ่งไปรอบ ๆ เนินเขาไปถึงยอดเขาอีกด้านหนึ่ง: ระเบียงเล็ก ๆ เหมือนภาพแกะสลักที่ตัดออกมาเพื่อให้เป็นบันได ทีนี้ถ้าวิธีแรกคือการเข้าถึงในเวลาเชิงเส้น O (n), วิธีที่สองคือ O (log n)

2. ลองนึกภาพอัลกอริทึมซึ่งรับจำนวนเต็มnเป็นอินพุทและทำให้เสร็จในเวลาตามสัดส่วนซึ่งnก็คือ O (n) หรือ theta (n) แต่ถ้ามันวิ่งตามสัดส่วนเวลากับnumber of digits or the number of bits in the binary representation on numberอัลกอริทึมนั้นจะทำงานใน O (log n) หรือ theta (บันทึก n) เวลา

อัลกอริทึมในกระบวนทัศน์การแบ่งและการพิชิตนั้นมีความซับซ้อน O (logn) ตัวอย่างหนึ่งที่นี่คำนวณฟังก์ชันกำลังของคุณ

int power(int x, unsigned int y)
{
    int temp;
    if( y == 0)
        return 1;
    temp = power(x, y/2);
    if (y%2 == 0)
        return temp*temp;
    else
        return x*temp*temp;
}

จากhttp://www.geeksforgeeks.org/write-ac-program-to-calculate-powxn/