[เล่นดนตรี] 

ROB สลิง: สวัสดี ฉันร็อบ และให้การแก้ปัญหานี้ออก ดังนั้นที่นี่เรากำลังจะดำเนินการ ตารางทั่วไป เราจะเห็นว่าโครงสร้างของโหนดของเรา ตารางจะมีลักษณะเช่นนี้ ดังนั้นมันจะมีคำถ่าน อาร์เรย์ที่มีขนาดความยาว + 1 อย่าลืม + 1 เนื่องจากสูงสุด คำในพจนานุกรม 45 ตัวอักษร แล้วเราจะต้องอย่างใดอย่างหนึ่งเป็นพิเศษ ตัวอักษรสำหรับศูนย์เครื่องหมาย 

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

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

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

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

และตอนนี้เรากำลังจะ malloc โหนดเดียว และแน่นอนเราต้อง ในการตรวจสอบอากาศอีกครั้ง ดังนั้นหาก mallocing ไม่ประสบความสำเร็จแล้ว เราต้องการที่จะยกเลิกการโหลดโหนดที่เรา ๆ ที่เกิดขึ้นกับ malloc ก่อนที่จะปิด พจนานุกรมและกลับเท็จ แต่ไม่สนใจว่าเราสมมติว่า ประสบความสำเร็จแล้วเราต้องการที่จะใช้ fscanf การอ่านคำเดียวจากเรา พจนานุกรมเป็นโหนดของเรา ดังนั้นจำไว้ว่ารายการ> คำเป็นถ่าน บัฟเฟอร์คำขนาด lenghth + 1 ที่เรากำลังจะเก็บคำค่ะ 

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

ลองมาดูที่ ฟังก์ชันแฮช เพื่อให้คุณไม่ได้จริงๆต้อง ที่จะเข้าใจในเรื่องนี้ และที่จริงเราก็ดึงกัญชานี้ ฟังก์ชั่นจากอินเทอร์เน็ต สิ่งเดียวที่คุณจำเป็นต้องรู้คือ ที่นี้จะใช้เวลา char * คำ const ดังนั้นจึงสละสตริงเป็น input และ กลับ int ไม่ได้ลงนามเป็นผลผลิต เพื่อให้ทุกฟังก์ชันแฮชจะเป็นมัน จะใช้เวลาในการป้อนข้อมูลและช่วยให้คุณ ดัชนีลงใน hashtable 

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

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

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

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

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

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

ตอนนี้สำหรับวงที่เป็นไป ย้ำผ่านรายการที่เชื่อมโยง ที่อยู่ในดัชนีที่ ดังนั้นเราจะสังเกตเห็นการเริ่มต้นรายการ ให้ชี้ไปที่ดัชนี เรากำลังจะดำเนินการต่อไป ในขณะที่รายการ! = NULL และจำไว้ว่าการปรับปรุงตัวชี้ ในรายการรายการที่เชื่อมโยงเราเข้า => ต่อไป เพื่อให้มีจุดเริ่มต้นในปัจจุบันของเราที่จะ รายการถัดไปในรายการที่เชื่อมโยง 

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

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

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

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

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

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

ขอให้แก้ปัญหานี้ลอง ดังนั้นลองมาดูที่สิ่งที่เรา โหนด struct จะมีลักษณะเช่น ที่นี่เราเห็นเรากำลังจะมีบูล คำและโหนด struct * เด็ก ALPHABET วงเล็บ ดังนั้นสิ่งแรกที่คุณอาจจะ สงสัยว่าทำไม ALPHABET เอ็ดหมายถึง 27? ดีจำไว้ว่าเรากำลังจะต้อง จะได้รับการจัดการอัญประกาศเดี่ยว เพื่อที่จะเป็นบางส่วนของ กรณีพิเศษตลอดทั้งโปรแกรมนี้ 

ตอนนี้จำได้ว่า Trie ที่ ใช้งานได้จริง สมมติว่าเรากำลังทำดัชนีคำ "แมว." แล้วจากรากของ Trie ที่ เราจะมองไปที่เด็ก อาร์เรย์และเรากำลังจะไปดูที่ ดัชนีที่สอดคล้องกับตัวอักษร C. เพื่อที่ว่าจะได้รับการจัดทำดัชนีที่ 2 ได้รับเพื่อที่จะว่า ให้เราโหนดใหม่ แล้วเราจะทำงานจากโหนดที่ 

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

ดังนั้นเราจึงไม่จำเป็นต้องมีเหตุผลว่ากรณีพิเศษหรือไม่ สิ่งที่ดีของคำว่า "ภัยพิบัติ" อยู่ในพจนานุกรมของเรา แต่ คำว่า "แมว" ไม่ได้คืออะไร มากและกำลังมองหาเพื่อดูว่าคำว่า "แมว" อยู่ในพจนานุกรมของเราเรา จะประสบความสำเร็จมองผ่าน ดัชนี C--T โหนดในภูมิภาค แต่นั่นเป็นเพียงเพราะภัยพิบัติ ที่เกิดขึ้นในการสร้างโหนดในทาง จาก C-A-T, ทุกวิธีการ ในตอนท้ายของคำว่า ดังนั้นคำว่าบูลถูกนำมาใช้เพื่อแสดงให้เห็นว่า ตำแหน่งนี้โดยเฉพาะอย่างยิ่ง จริงแสดงให้เห็นคำ 

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

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

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

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

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

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

ดังนั้นเช่นฉันกล่าวก่อนที่เราต้อง กรณีพิเศษเครื่องหมายวรรคตอน สังเกตเห็นเรากำลังใช้ประกอบ ผู้ประกอบการที่นี่ ดังนั้นเรากำลังจะอ่านนี้ถ้า ตัวละครที่เราอ่านเป็น เครื่องหมายวรรคตอนนั้นเรากำลังจะตั้ง ดัชนี = "ALPHABET" -1 ซึ่งจะ เป็นดัชนีที่ 26 

อื่นถ้ามันไม่ได้เป็นเครื่องหมายวรรคตอนมี เราจะกำหนดดัชนี เท่ากับค - ดังนั้นอย่าลืมกลับมาจากก่อนหน้านี้พีชุด ค - จะให้เรา ตำแหน่งเรียงตามตัวอักษร C. ดังนั้นหาก C เป็นตัวอักษรนี้จะ ให้เราเป็นศูนย์ดัชนี สำหรับตัวอักษร B จะให้ เราดัชนี 1 และอื่น ๆ 

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

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

ตอนนี้ถ้านี้ไม่ว่างที่จะเริ่มต้นด้วย แล้วเคอร์เซอร์ก็สามารถย้ำ ลงไปที่เด็กที่ไม่จริง มีอะไรที่จะจัดสรร นี้เป็นกรณีที่เกิดขึ้นครั้งแรกของเรา จัดสรรคำว่า "แมว." และ นั่นหมายความว่าเมื่อเราไปในการจัดสรร "ภัยพิบัติ" เราไม่จำเป็นต้องสร้าง โหนดสำหรับ C-A-T อีกครั้ง พวกเขามีอยู่แล้ว 

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

ขณะนี้การตั้งค่าที่เป็นจริง เราต้องการที่จะตั้งค่าเคอร์เซอร์ของเราไปยังจุด ที่จุดเริ่มต้นของ Trie อีกครั้ง และในที่สุดเพิ่มในพจนานุกรมของเรา ขนาดเนื่องจากเราพบว่าการทำงานอื่น ดังนั้นเรากำลังจะเก็บทำที่ การอ่านในตัวละครโดยตัวอักษร สร้างโหนดใหม่ใน Trie ที่เราและ สำหรับแต่ละคำในพจนานุกรมจน ในที่สุดเราก็มาถึง C! = EOF ซึ่งใน กรณีที่เราแยกออกจากแฟ้ม 

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

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

เรามาดูกันว่าที่นี่เช่นเดียวกับก่อนหน้านี้ ที่เรากำลังจะใช้เคอร์เซอร์เพื่อย้ำ ผ่าน Trie ที่ของเรา ตอนนี้ที่นี่เรากำลังจะย้ำ เหนือคำทั้งหมดของเรา ดังนั้น iterating กว่าคำที่เรามีอดีตที่ผ่านมา เราจะตรวจสอบ ดัชนีลงในอาร์เรย์ที่เด็ก สอดคล้องกับคำวงเล็บ I. ดังนั้นนี่ จะมีลักษณะเหมือนกับ ภาระที่ถ้าคำ [i] เป็นเครื่องหมายวรรคตอนแล้วเราต้องการ ที่จะใช้ดัชนี "ALPHABET" - 1 เพราะเราพิจารณาแล้วว่าที่ เป็นที่ที่เราจะเก็บ apostrophes 

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

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

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

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

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

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

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

[เล่นดนตรี]