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

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

ให้ A[1..p] และ B[1..q] เป็นอาร์เรย์สองชุดที่เรียงลำดับจากน้อยไปมาก นอกจากนี้ ให้ C[1..n] เป็นอาร์เรย์ผลลัพธ์ อัลกอริทึมการรวมแบบ 2 ทางมาตรฐาน^{[ 1 ]}จะเก็บดัชนี i, j และ k ไว้ใน A, B และ C ตามลำดับ ในตอนเริ่มต้น ดัชนีเหล่านี้จะอ้างอิงถึงองค์ประกอบแรก นั่นคือ 1 ถ้า A[i] < B[j] อัลกอริทึมจะคัดลอก A[i] ไปยัง C[k] และเพิ่มค่า i และ k มิฉะนั้น อัลกอริทึมจะคัดลอก B[j] ไปยัง C[k] และเพิ่มค่า j และ k กรณีพิเศษจะเกิดขึ้นหาก i หรือ j ไปถึงจุดสิ้นสุดของ A หรือ B ในกรณีนี้ อัลกอริทึมจะคัดลอกองค์ประกอบที่เหลือของ B หรือ A ไปยัง C และสิ้นสุดการทำงาน

ปัญหา การรวมแบบ kทาง คือการรวมอาร์เรย์ที่เรียงลำดับแล้ว k ชุด เพื่อสร้างอาร์เรย์ที่เรียงลำดับ แล้วเพียงชุดเดียว ที่มีองค์ประกอบเหมือนกัน ให้ n แทนจำนวนองค์ประกอบทั้งหมด โดย n เท่ากับขนาดของอาร์เรย์ผลลัพธ์และผลรวมของขนาดของอาร์เรย์อินพุตทั้ง k ชุด เพื่อความง่าย เราสมมติว่าไม่มีอาร์เรย์อินพุตใดว่างเปล่า ดังนั้นจึงทำให้เวลาในการประมวลผลที่รายงานง่ายขึ้น ปัญหานี้สามารถแก้ไขได้ในเวลาการทำงาน โดยใช้พื้นที่ มีอัลกอริทึมหลายตัวที่บรรลุเวลาการทำงานนี้ ${\displaystyle k\leq n}$${\displaystyle {\mathcal {O}}(n\cdot \log(k))}$${\displaystyle {\คณิตศาสตร์ {O}}(n)}$

ปัญหาดังกล่าวสามารถแก้ไขได้โดยการรวมอาร์เรย์ k สองชุดเข้าด้วยกันซ้ำๆ โดยใช้การรวมแบบ 2 ทาง จนกว่าจะเหลือเพียงอาร์เรย์เดียว หากรวมอาร์เรย์ในลำดับใดๆ เวลาในการทำงานที่ได้จะเป็นเพียง O(kn) ซึ่งถือว่าไม่เหมาะสมที่สุด

สามารถปรับปรุงเวลาการทำงานได้โดยการรวมอาร์เรย์แรกกับอาร์เรย์ที่สอง อาร์เรย์ที่สามกับอาร์เรย์ที่สี่ และต่อไปเรื่อยๆ เนื่องจากจำนวนอาร์เรย์ลดลงครึ่งหนึ่งในแต่ละรอบการทำงาน จึงมีเพียง Θ(log k) รอบการทำงานเท่านั้น ในแต่ละรอบการทำงาน ทุกองค์ประกอบจะถูกย้ายเพียงครั้งเดียว ดังนั้นเวลาการทำงานต่อรอบจึงอยู่ใน Θ(n) เนื่องจาก n คือจำนวนองค์ประกอบ ดังนั้นเวลาการทำงานทั้งหมดจึงอยู่ใน Θ(n log k)

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

ในกรณีนี้ เราจะรวม k-run เข้าด้วยกันพร้อมๆ กัน

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

เราสามารถปรับปรุงวิธีการนี้ได้โดยการคำนวณหาองค์ประกอบที่เล็กที่สุดได้เร็วขึ้น โดยการใช้ ฮีป ( heaps ), ต้นไม้ทัวร์นาเมนต์ (tournament trees) หรือต้นไม้สไปลย์ (splay trees ) เราสามารถหาองค์ประกอบที่เล็กที่สุดได้ในเวลา O(log k) ดังนั้นเวลาในการทำงานโดยรวมจึงอยู่ในรูป O(n log k)

โดยทั่วไปแล้วจะใช้ฮีป (heap) มากกว่า แม้ว่าในทางปฏิบัติแล้วโครงสร้างต้นไม้แบบทัวร์นาเมนต์ (tournament tree) จะเร็วกว่าก็ตาม ฮีปใช้การเปรียบเทียบประมาณ 2*log(k) ครั้งในแต่ละขั้นตอน เนื่องจากมันจัดการต้นไม้จากรากไปจนถึงด้านล่างสุด และจำเป็นต้องเปรียบเทียบลูกทั้งสองของแต่ละโหนด ในขณะที่โครงสร้างต้นไม้แบบทัวร์นาเมนต์ต้องการการเปรียบเทียบเพียง log(k) ครั้งเท่านั้น เพราะมันเริ่มต้นจากด้านล่างสุดของต้นไม้และทำงานขึ้นไปจนถึงราก โดยทำการเปรียบเทียบเพียงครั้งเดียวในแต่ละชั้น ดังนั้นจึงควรเลือกใช้โครงสร้างต้นไม้แบบทัวร์นาเมนต์มากกว่า

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

โดยใช้ตัวชี้ อัลกอริทึมฮีปแบบ in-place ^{[ 2 ]} จะจัดสรร min-heap ของตัวชี้ลงในอาร์เรย์อินพุต ในขั้นต้น ตัวชี้เหล่านี้จะชี้ไปยังองค์ประกอบที่เล็กที่สุดของอาร์เรย์อินพุต ตัวชี้จะถูกเรียงลำดับตามค่าที่ชี้ไป ในขั้นตอนการประมวลผลล่วงหน้า O(k) ฮีปจะถูกสร้างขึ้นโดยใช้ขั้นตอน heapify มาตรฐาน หลังจากนั้น อัลกอริทึมจะถ่ายโอนองค์ประกอบที่ตัวชี้รากชี้ไป เพิ่มค่าตัวชี้ดังกล่าว และดำเนินการขั้นตอนการเพิ่มคีย์มาตรฐานกับองค์ประกอบราก เวลาในการทำงานของขั้นตอนการเพิ่มคีย์ถูกจำกัดด้วย O(log k) เนื่องจากมีองค์ประกอบ n ตัว เวลาในการทำงานทั้งหมดจึงเป็น O(n log k)

โปรดทราบว่าการดำเนินการแทนที่คีย์และการเพิ่มคีย์หรือลดคีย์แบบวนซ้ำนั้นไม่ได้รับการสนับสนุนโดย ไลบรารี คิวลำดับความสำคัญ หลายแห่ง เช่นC++ stl และ Java การใช้ฟังก์ชันแยกค่าต่ำสุดและแทรกค่าใหม่นั้นมีประสิทธิภาพน้อยกว่า

ต้นไม้ทัวร์นาเมนต์^{[ 3 ]}อิงตามทัวร์นาเมนต์แบบคัดออก เช่นเดียวกับการแข่งขันกีฬา ในแต่ละเกม องค์ประกอบอินพุตสองตัวจะแข่งขันกัน ผู้ชนะจะผ่านเข้ารอบต่อไป ดังนั้น เราจึงได้ต้นไม้ไบนารีของเกม รายการจะถูกจัดเรียงตามลำดับจากน้อยไปมาก ดังนั้นผู้ชนะของเกมคือองค์ประกอบที่มีค่าน้อยกว่าทั้งสอง

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

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

ภาพแผนผังลำดับการแข่งขันและแผนผังลำดับผู้แพ้ในส่วนนี้ใช้ข้อมูลเดียวกัน และสามารถนำมาเปรียบเทียบกันเพื่อทำความเข้าใจวิธีการทำงานของแผนผังลำดับผู้แพ้ได้

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

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

ฟังก์ชัน merge(L1, ..., Ln) buildTree(heads of L1, ..., Ln) ในขณะที่ต้นไม้มีองค์ประกอบต่างๆ ผู้ชนะ := ต้นไม้.ผู้ชนะ เอาต์พุตผู้ชนะ.ค่า ใหม่ := ผู้ชนะ.ดัชนีถัดไป replayGames(winner.parent, new) // การเลือกทดแทน 

ฟังก์ชัน replayGames(node, new) ผู้แพ้, ผู้ชนะ := playGame(node, new) ค่าของโหนด := ค่าของผู้แพ้ node.index := loser.index ถ้าโหนดไม่ใช่โหนดราก replayGames(node.parent, winner) 

ฟังก์ชัน buildTree(elements) nextLayer := อาร์เรย์ใหม่() ในขณะที่องค์ประกอบไม่ว่างเปล่า el1 := elements.take() el2 := elements.take() ผู้แพ้, ผู้ชนะ := playGame(el1, el2) parent := โหนดใหม่ (el1, el2, loser) nextLayer.add(parent) ถ้า nextLayer.size == 1 ให้คืนค่า nextLayer (เฉพาะเลเยอร์ราก) มิฉะนั้นให้คืนค่า buildTree(nextLayer) 

ในตอนเริ่มต้น ต้นไม้จะถูกสร้างขึ้นในเวลา Θ(k) ก่อน ในแต่ละขั้นตอนของการรวม จะต้องเล่นเกมบนเส้นทางจากองค์ประกอบใหม่ไปยังรากอีกครั้งเท่านั้น ในแต่ละเลเยอร์ จะต้องมีการเปรียบเทียบเพียงครั้งเดียวเท่านั้น เนื่องจากต้นไม้มีความสมดุล เส้นทางจากอาร์เรย์อินพุตหนึ่งไปยังรากจึงมีองค์ประกอบเพียง Θ(log k) เท่านั้น โดยรวมแล้วมีองค์ประกอบ n ตัวที่ต้องถ่ายโอน ดังนั้นเวลาการทำงานทั้งหมดจึงอยู่ใน Θ(n log k) ^{[ 3 ]}

ส่วนต่อไปนี้ประกอบด้วยตัวอย่างโดยละเอียดสำหรับขั้นตอนการเลือกตัวแทน และตัวอย่างหนึ่งสำหรับขั้นตอนการผสานรวมที่สมบูรณ์ซึ่งประกอบด้วยการเลือกตัวแทนหลายรายการ

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

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

ตัวอย่างนี้ใช้ข้อมูลป้อนเข้าเป็นอาร์เรย์ที่เรียงลำดับแล้วสี่ชุด

{2, 7, 16} {5, 10, 20} {3, 6, 21} {4, 8, 9} 

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

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

การรวม kทางถูกใช้ในขั้นตอนการเรียงลำดับภายนอก^{[ 4 ]}อัลกอริทึมการเรียงลำดับภายนอกเป็นกลุ่มของอัลกอริทึมการเรียงลำดับที่สามารถจัดการกับข้อมูลจำนวนมหาศาล การเรียงลำดับภายนอกมีความจำเป็นเมื่อข้อมูลที่กำลังเรียงลำดับไม่สามารถจัดเก็บในหน่วยความจำหลักของอุปกรณ์คอมพิวเตอร์ (โดยปกติคือ RAM) ได้ และต้องจัดเก็บในหน่วยความจำภายนอกที่ช้ากว่า (โดยปกติคือฮาร์ดไดรฟ์) อัลกอริทึมการรวม kทางมักจะเกิดขึ้นในขั้นตอนที่สองของอัลกอริทึมการเรียงลำดับภายนอก เช่นเดียวกับที่เกิดขึ้นในการเรียงลำดับแบบผสาน

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