- ตัวอย่าง Give (นักเรียนกำหนดเวลาเรียน) -
วิธีการประมวลผลการคิดปกติและวิธีการประมวลผลการเพิ่มประสิทธิภาพ:
ตัวอย่างเช่นชั้นเรียนการจัดตารางเวลาสำหรับนักเรียน นักเรียนและหลักสูตรมีความสัมพันธ์หลายต่อหลายคน
ตามตรรกะปกติควรมีตารางการเชื่อมโยงเพื่อรักษาความสัมพันธ์ระหว่างทั้งสอง
ตอนนี้เพิ่มข้อ จำกัด สำหรับการตรวจสอบ ตัวอย่างเช่น: หลักสูตรจางซานเรียนรู้ภาคการศึกษาที่แล้วไม่ควรกำหนดหลักสูตรสำหรับหลักสูตรดังกล่าวเมื่อชั้นเรียนจัดตารางเวลา
ดังนั้นตารางข้อ จำกัด (เช่นตารางเกรดประวัติศาสตร์) จำเป็นต้องปรากฏขึ้น
นั่นคือ: ตารางการเลือกหลักสูตรของนักเรียนต้องการตารางเกรดของนักเรียนเป็นข้อ จำกัด
- Scheme 1: วิธีการประมวลผลปกติ -
เมื่อนักเรียนรับการเลือกหลักสูตรอีกครั้ง คุณต้องตรวจสอบตารางการเลือกหลักสูตรของนักเรียนเพื่อดูว่ามีอยู่แล้วหรือไม่
นั่นคือการตรวจสอบต่อไปนี้คือ:
// สอบถามว่าข้อมูลที่มีรหัสนักเรียนและรหัสหลักสูตร A และ B มีอยู่จริง // ชุดรายการเก็บข้อมูลทั้งหมดของบันทึกการเลือกหลักสูตรนักเรียนในรายการ <TudentRecordentity> ListSudentRecord = service.findall (); // สอบถามข้อมูลเพื่อดูว่า studentRecordentity มีอยู่แล้ว ensr = liststudentRecord.find (s => s.studentCode == a && s.code == b); if (ensr == null) {// นักเรียนไม่ได้เลือกหลักสูตรนี้ // .... } else {// นักเรียนได้เลือกหลักสูตรนี้ // .... }รหัสข้างต้นมีความรัดกุมมาก และเข้าใจง่ายมาก
ก่อนอื่นสมมติว่ามีนักเรียน 5,000 คนและ 100 หลักสูตร จากนั้นสำหรับชุดข้อมูลสำหรับนักเรียนที่จะเลือกหลักสูตรปริมาณข้อมูลจะอยู่ที่ 5,000*100 ปริมาณข้อมูลจะเป็นลำดับความสำคัญของระดับ 100,000
ในบรรดาข้อมูล 100,000 ข้อมูลการสืบค้นนักเรียน = A หลักสูตร = B. การดำเนินการจะไม่มีประสิทธิภาพ เนื่องจากแบบสอบถามของวิธีการค้นหานั้นเป็นที่ที่คิวรีนั่นคือการค้นหาโดยการสำรวจชุดข้อมูล
ดังนั้นใช้รหัสด้านบน เมื่อปริมาณข้อมูลเพิ่มขึ้นเรื่อย ๆ ประสิทธิภาพการดำเนินการของโปรแกรมจะลดลงอย่างมีนัยสำคัญ
PS: ปริมาณข้อมูลกำลังเพิ่มขึ้นซึ่งไม่เหมาะสมในตัวอย่างนี้ ตัวอย่างอาจไม่เหมาะสม อย่างไรก็ตามนั่นอาจเป็นความหมาย -
- Scheme 2: ใช้หน่วยความจำเพื่อประสิทธิภาพการเพิ่มประสิทธิภาพ -
การปฏิบัตินี้ต้องใช้การใช้หน่วยความจำ หรือทำการตรวจสอบไปข้างหน้า (การเริ่มต้นข้อมูลจะดำเนินการในระหว่างการปรับใช้ของระบบ) นั่นคือ: เมื่อมีการโหลดหน้าเว็บข้อมูลจะถูกเรียกไปยังวิธีการสาธารณะที่ให้ไว้สำหรับการตรวจสอบเท่านั้น
// รหัสนักเรียนไปยังอาร์เรย์ดัชนีพจนานุกรมส่วนตัว <สตริง, int> _dicstudentCodetoArrayIndex; // รหัสหลักสูตรไปยังดัชนีข้อมูลพจนานุกรมส่วนตัว <String, int> _dicCourSecodetoArrayIndex; // นักเรียนทุกคนทั้งหมด รายการบันทึกการเลือกหลักสูตรของนักเรียน <SotrentCourseEntity> liStSudEntRecord = service.finall (); int ส่วนตัว [,] _connstudentRecord = new int [liststudent.count.counts.count.count]; // สร้างอาร์เรย์ของนักเรียนและ courses _dicstudentCodetoArrayIndex.add (list.udent [i] .code, i)} สำหรับ (int i = 0; i <listcourse.count; i ++) {_ diccoursecodetoarrayindex.add 1 หมายความว่านักเรียนได้เลือกหลักสูตร Void Private Void GenerateArray () {foreach (studentRecordentity sre ใน liststudentRecord) {int x = _dicstudentCodetoArrayIndex [sre.studentCode]; int y = diccoursecodetoarrayindex [sre.coursecode]; connstudentRecord [x, y] = 1;}} // วิธีการเปิด: สอบถามว่าบันทึกการเลือกหลักสูตรมีอยู่บนรหัสนักเรียนและรหัสหลักสูตร /// return 0 หมายความว่ามันไม่มีอยู่ </returns> โมฆะสาธารณะ VerifyRecordByStudentCodeAndCourSecode (สตริง pstudentCode, สตริง pcoursecode) {int x = _dicstudentCodetoArrayIndex [pStudentCode]; connstudentRecord [x, y];}- การวิเคราะห์ประสิทธิภาพ -
วิเคราะห์การปรากฏตัวของโซลูชันที่สอง
1. มีหลายวิธี
2. มีตัวแปรมากมายที่ใช้
ก่อนอื่นฉันต้องพูดถึงเรื่องนี้ จุดประสงค์ของการเพิ่มประสิทธิภาพนี้คือการปรับปรุงปรากฏการณ์ความล่าช้า (ข้อมูลการตรวจสอบจำนวนมาก) ที่นักเรียนพบเมื่อเลือกหลักสูตร
สองแผนการด้านบนถูกวิเคราะห์แยกกัน:
สมมติว่านักเรียนเป็น N และหลักสูตรคือ M
ทางออกแรก:
ความซับซ้อนของเวลานั้นง่ายต่อการคำนวณวิธีแก้ปัญหาแรกอย่างน้อย O (nm)
ทางออกที่สอง:
1. มีรหัสมากมาย แต่ผู้ใช้มีวิธีการ VerifyRecordByStudentCodeAnDCourSecode เท่านั้น
2. มีตัวแปรมากมายเนื่องจากโซลูชันนี้คือการใช้หน่วยความจำเพื่อปรับปรุงประสิทธิภาพ
กระบวนการดำเนินการของวิธีนี้: 1. ใช้รหัสในพจนานุกรมเพื่อค้นหาดัชนี 2 และใช้ดัชนีเพื่อสอบถามอาร์เรย์
ในขั้นตอนแรกแบบสอบถามในพจนานุกรมใช้อัลกอริทึมการค้นหาแฮช ความซับซ้อนของเวลาคือ O (LGN) และเวลาค่อนข้างเร็ว ขั้นตอนที่สองคือความซับซ้อนของเวลาคือ O (1) เนื่องจากอาร์เรย์ต่อเนื่อง ดัชนีจะค้นหาที่อยู่ที่เกี่ยวข้องโดยตรง
ดังนั้นวิธีการแก้ปัญหาที่สองจึงใช้สำหรับการตรวจสอบและความซับซ้อนของเวลาของสารละลายที่สองคือ O (LGN+LGM)
-สรุป-
ผ่านการวิเคราะห์ข้างต้นจะเห็นได้ว่าความพยายามหน่วยความจำสามารถปรับปรุงประสิทธิภาพการดำเนินการของโปรแกรม ข้างต้นเป็นเพียงตัวอย่างและคุณภาพของการเพิ่มประสิทธิภาพขึ้นอยู่กับโครงสร้างข้อมูลที่ใช้
ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้เกี่ยวกับรหัสอินสแตนซ์โครงสร้างข้อมูลการเพิ่มประสิทธิภาพของ Java ฉันหวังว่ามันจะเป็นประโยชน์กับทุกคน เพื่อนที่สนใจสามารถอ้างถึงหัวข้ออื่น ๆ ที่เกี่ยวข้องในเว็บไซต์นี้ต่อไป หากมีข้อบกพร่องใด ๆ โปรดฝากข้อความไว้เพื่อชี้ให้เห็น ขอบคุณเพื่อนที่ให้การสนับสนุนเว็บไซต์นี้!