>> [เล่นดนตรี]
>> 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 ทั้งหมด
และแล้วเมื่อที่ทำ เราก็สามารถกลับจริง
ขนไม่สามารถล้มเหลว
เราก็พ้นสิ่งที่
ดังนั้นเมื่อเราดำเนินการเสร็จแล้วพ้น ทุกอย่างกลับจริง
และที่มัน
ชื่อของฉันคือร็อบ
และนี่คือสะกด
>> [เล่นดนตรี]