1
00:00:00,000 --> 00:00:12,350
>> [Παίζει μουσική]

2
00:00:12,350 --> 00:00:13,050
>> ROB BOWDEN: Hi.

3
00:00:13,050 --> 00:00:13,640
Είμαι Rob.

4
00:00:13,640 --> 00:00:16,210
Και ας αυτή τη λύση έξω.

5
00:00:16,210 --> 00:00:20,070
Έτσι, εδώ θα πάμε να εφαρμόσει
ένα γενικό πίνακα.

6
00:00:20,070 --> 00:00:24,090
Βλέπουμε ότι ο κόμβος του struct μας
πίνακας πρόκειται να μοιάζει με αυτό.

7
00:00:24,090 --> 00:00:28,710
Έτσι πρόκειται να έχουν μια λέξη char
πίνακας μεγέθους ΜΗΚΟΣ + 1.

8
00:00:28,710 --> 00:00:32,259
Μην ξεχνάτε το + 1, δεδομένου ότι η μέγιστη
λέξη στο λεξικό είναι 45

9
00:00:32,259 --> 00:00:33,130
χαρακτήρων.

10
00:00:33,130 --> 00:00:37,070
Και μετά θα πάμε να χρειαστεί ένα επιπλέον
χαρακτήρα για το μηδέν backslash.

11
00:00:37,070 --> 00:00:40,870
>> Και τότε hashtable μας σε κάθε
κάδος πρόκειται να αποθηκεύσετε ένα

12
00:00:40,870 --> 00:00:42,320
συνδεδεμένη λίστα των κόμβων.

13
00:00:42,320 --> 00:00:44,420
Εμείς δεν κάνουμε γραμμική σχολαστικά εδώ.

14
00:00:44,420 --> 00:00:48,430
Και έτσι, ώστε να συνδεθεί με την επόμενη
στοιχείο στον κάδο, χρειαζόμαστε μια

15
00:00:48,430 --> 00:00:50,390
struct node * επόμενο.

16
00:00:50,390 --> 00:00:51,110
OK.

17
00:00:51,110 --> 00:00:53,090
Έτσι, αυτό είναι ένας κόμβος μοιάζει.

18
00:00:53,090 --> 00:00:56,180
>> Τώρα εδώ είναι η δήλωση
της hashtable μας.

19
00:00:56,180 --> 00:00:59,640
Είναι πρόκειται να έχει 16.834 κάδους.

20
00:00:59,640 --> 00:01:01,910
Αλλά αυτός ο αριθμός δεν έχει τόση σημασία.

21
00:01:01,910 --> 00:01:05,450
Και τέλος, θα πάμε να έχουν το
καθολική μεταβλητή μέγεθος hashtable, η οποία

22
00:01:05,450 --> 00:01:07,000
πρόκειται να ξεκινήσει ως μηδέν.

23
00:01:07,000 --> 00:01:10,760
Και πρόκειται να παρακολουθείτε το πώς
τα πολλά λόγια είναι στο λεξικό μας.

24
00:01:10,760 --> 00:01:13,710
>> Έτσι, ας ρίξουμε μια ματιά στο φορτίο.

25
00:01:13,710 --> 00:01:16,390
Παρατηρήστε ότι το φορτίο, επιστρέφει μια bool.

26
00:01:16,390 --> 00:01:20,530
Θα επιστρέψει true αν ήταν επιτυχία
φορτώνονται και ψεύτικες διαφορετικά.

27
00:01:20,530 --> 00:01:23,990
Και παίρνει ένα const char * λεξικό,
το οποίο είναι το λεξικό

28
00:01:23,990 --> 00:01:25,280
ότι θέλουμε να ανοίξουμε.

29
00:01:25,280 --> 00:01:27,170
Έτσι, αυτό είναι το πρώτο πράγμα που
θα πάμε να κάνουμε.

30
00:01:27,170 --> 00:01:29,500
>> Εμείς πάμε για να το fopen
λεξικό για την ανάγνωση.

31
00:01:29,500 --> 00:01:31,680
Και θα πάμε να πρέπει να κάνει
βεβαιωθείτε ότι πέτυχε.

32
00:01:31,680 --> 00:01:35,920
Έτσι, αν επιστρέψει NULL, τότε δεν είχαμε
επιτυχία ανοίξτε το λεξικό.

33
00:01:35,920 --> 00:01:37,440
Και εμείς πρέπει να επιστρέψει false.

34
00:01:37,440 --> 00:01:41,580
Αλλά και αν υποτεθεί ότι το έκανε με επιτυχία
ανοιχτό, τότε θα θέλετε να διαβάσετε το

35
00:01:41,580 --> 00:01:42,400
λεξικό.

36
00:01:42,400 --> 00:01:46,450
Γι 'αυτό κράτα looping μέχρι να βρούμε κάποια
λόγος για να ξεφύγει από αυτόν τον βρόχο,

37
00:01:46,450 --> 00:01:47,570
οποίο και θα δούμε.

38
00:01:47,570 --> 00:01:48,920
Γι 'αυτό κράτα looping.

39
00:01:48,920 --> 00:01:51,780
>> Και τώρα θα πάμε να
malloc έναν μεμονωμένο κόμβο.

40
00:01:51,780 --> 00:01:54,020
Και φυσικά χρειαζόμαστε
στον αέρα ελέγξτε ξανά.

41
00:01:54,020 --> 00:01:58,680
Έτσι, αν mallocing δεν πετύχει, τότε
θέλουμε να ξεφορτώσουν κάθε κόμβο που

42
00:01:58,680 --> 00:02:02,590
συνέβη με malloc πριν, κλείστε το
λεξικό και επιστρέφει false.

43
00:02:02,590 --> 00:02:06,830
Αλλά αγνοώντας ότι, αν υποτεθεί ότι
καταφέρει, τότε θα θέλετε να χρησιμοποιήσετε fscanf

44
00:02:06,830 --> 00:02:12,400
να διαβάσει μια λέξη από μας
λεξικό στο κόμβο μας.

45
00:02:12,400 --> 00:02:17,940
Έτσι, να θυμάστε ότι η καταχώρηση> λέξη είναι ο char
ρυθμιστικό λέξη του μεγέθους Lenghth + 1

46
00:02:17,940 --> 00:02:20,300
ότι θα πάμε για να αποθηκεύσετε τη λέξη μέσα

47
00:02:20,300 --> 00:02:25,070
>> Έτσι fscanf πρόκειται να επιστρέψει 1, εφ '
καθώς ήταν σε θέση να με επιτυχία

48
00:02:25,070 --> 00:02:26,750
διαβάστε μια λέξη από το αρχείο.

49
00:02:26,750 --> 00:02:30,460
Αν συμβεί είτε ένα λάθος, ή εμείς
φτάσετε στο τέλος του αρχείου,

50
00:02:30,460 --> 00:02:31,950
δεν θα επιστρέψει 1.

51
00:02:31,950 --> 00:02:35,180
Σε αυτή την περίπτωση δεν επιστρέφει 1,
είμαστε επιτέλους να ξεφύγει από

52
00:02:35,180 --> 00:02:37,280
αυτό το βρόχο, ενώ.

53
00:02:37,280 --> 00:02:42,770
Έτσι, βλέπουμε ότι από τη στιγμή που έχουμε με επιτυχία
διαβάστε μια λέξη σε

54
00:02:42,770 --> 00:02:48,270
entry> λέξη, τότε θα πάμε σε αυτό
λέξη χρησιμοποιώντας τη λειτουργία hash μας.

55
00:02:48,270 --> 00:02:49,580
>> Ας ρίξουμε μια ματιά
η συνάρτηση κατακερματισμού.

56
00:02:49,580 --> 00:02:52,430

57
00:02:52,430 --> 00:02:55,610
Έτσι, δεν πρέπει πραγματικά
να το καταλάβουμε αυτό.

58
00:02:55,610 --> 00:02:59,460
Και στην πραγματικότητα απλά τράβηξε αυτό το κλειδί
λειτουργεί από το διαδίκτυο.

59
00:02:59,460 --> 00:03:04,010
Το μόνο πράγμα που πρέπει να αναγνωρίσουμε είναι
ότι αυτό παίρνει const char * λέξη.

60
00:03:04,010 --> 00:03:08,960
Γι 'αυτό παίρνει ένα string ως πρώτη ύλη, και
επιστρέφοντας ένα unsigned int ως έξοδο.

61
00:03:08,960 --> 00:03:12,360
Έτσι ώστε να είναι όλα μια συνάρτηση κατακερματισμού, είναι
παίρνει σε μια είσοδο και σας δίνει μια

62
00:03:12,360 --> 00:03:14,490
δείκτη στο hashtable.

63
00:03:14,490 --> 00:03:18,530
>> Παρατηρήστε ότι είμαστε moding από NUM_BUCKETS,
έτσι ώστε η τιμή επέστρεψε

64
00:03:18,530 --> 00:03:21,730
στην πραγματικότητα είναι ένας δείκτης στο hashtable
και δεν δείκτη πέρα ​​από το

65
00:03:21,730 --> 00:03:24,320
όρια της συστοιχίας.

66
00:03:24,320 --> 00:03:28,060
Έτσι, δεδομένου ότι η λειτουργία, θα πάμε
για τον κατακερματισμό της λέξης που διαβάζουμε το

67
00:03:28,060 --> 00:03:29,390
λεξικό.

68
00:03:29,390 --> 00:03:31,700
Και μετά θα πάμε να χρησιμοποιούν
ότι hash για να εισάγετε το

69
00:03:31,700 --> 00:03:33,750
είσοδο στο hashtable.

70
00:03:33,750 --> 00:03:38,520
>> Τώρα hashtable hash είναι η τρέχουσα
συνδεδεμένη λίστα στον πίνακα.

71
00:03:38,520 --> 00:03:41,410
Και είναι πολύ πιθανό
ότι είναι ακριβώς NULL.

72
00:03:41,410 --> 00:03:44,960
Θέλουμε να εισάγετε την είσοδό μας κατά τη
ξεκινώντας από αυτήν την συνδεδεμένη λίστα.

73
00:03:44,960 --> 00:03:48,600
Και έτσι θα πάμε να διαθέτουν ισχύουσα μας
σημείο εισόδου σε ό, τι το hashtable

74
00:03:48,600 --> 00:03:50,380
επισημαίνει σήμερα με.

75
00:03:50,380 --> 00:03:53,310
Και μετά θα πάμε για την αποθήκευση,
στο hashtable κατά τη

76
00:03:53,310 --> 00:03:55,350
hash, η τρέχουσα καταχώρηση.

77
00:03:55,350 --> 00:03:59,320
Έτσι, αυτές οι δύο γραμμές εισάγουν επιτυχώς
Η είσοδος κατά την έναρξη της

78
00:03:59,320 --> 00:04:02,260
συνδεδεμένη λίστα σε αυτό το ευρετήριο
στο hashtable.

79
00:04:02,260 --> 00:04:04,900
>> Μόλις τελειώσετε με αυτό, γνωρίζουμε
ότι βρήκαμε μια άλλη λέξη στο

80
00:04:04,900 --> 00:04:07,790
λεξικό, και θα αυξήσετε και πάλι.

81
00:04:07,790 --> 00:04:13,960
Έτσι κρατάμε το κάνουμε αυτό μέχρι fscanf
τελικά επέστρεψε κάτι μη-1 στους

82
00:04:13,960 --> 00:04:16,950
που το σημείο να θυμάστε ότι
θα πρέπει να ελευθερώσετε την είσοδο.

83
00:04:16,950 --> 00:04:19,459
Έτσι, εδώ έχουμε malloced μια καταχώρηση.

84
00:04:19,459 --> 00:04:21,329
Και προσπαθήσαμε να διαβάσω κάτι
από το λεξικό.

85
00:04:21,329 --> 00:04:23,910
Και εμείς δεν διαβάστηκε επιτυχώς
κάτι από το λεξικό, σε

86
00:04:23,910 --> 00:04:26,650
ποια περίπτωση θα πρέπει να ελευθερώσετε την είσοδο
ότι στην πραγματικότητα ποτέ δεν έχουν τεθεί σε η

87
00:04:26,650 --> 00:04:29,140
Hashtable, και τελικά να σπάσουν.

88
00:04:29,140 --> 00:04:32,750
>> Μόλις ξεσπάσει πρέπει να δούμε, επίσης,
δεν έχουμε σπάσει, επειδή εκεί έξω

89
00:04:32,750 --> 00:04:34,360
ήταν ένα σφάλμα κατά την ανάγνωση από το αρχείο;

90
00:04:34,360 --> 00:04:37,120
Ή μήπως έχουμε ξεφύγει από γιατί
φτάσει στο τέλος του αρχείου;

91
00:04:37,120 --> 00:04:39,480
Αν υπήρχε κάποιο σφάλμα, τότε
θέλουμε να επιστρέψει false.

92
00:04:39,480 --> 00:04:40,930
Επειδή το φορτίο δεν τα κατάφερε.

93
00:04:40,930 --> 00:04:43,890
Και στη διαδικασία θέλουμε να ξεφορτώσουν
όλες οι λέξεις που διαβάζονται, και

94
00:04:43,890 --> 00:04:45,670
κλείστε το αρχείο λεξικού.

95
00:04:45,670 --> 00:04:48,740
>> Υποθέτοντας ότι τα κατάφερε, τότε απλά
πρέπει ακόμα να κλείσει το λεξικό

96
00:04:48,740 --> 00:04:53,040
αρχείο, και τελικά επιστρέφει αληθές, δεδομένου ότι
φορτώθηκε με επιτυχία το λεξικό.

97
00:04:53,040 --> 00:04:54,420
Και αυτό είναι για το φορτίο.

98
00:04:54,420 --> 00:04:59,020
Έτσι ελέγχουν τώρα, δίνεται ένα φορτωμένο hashtable,
πρόκειται να μοιάζει με αυτό.

99
00:04:59,020 --> 00:05:03,140
Έτσι ελέγχετε, επιστρέφει μια bool, η οποία είναι
πρόκειται να αναφέρουν αν το περάσει

100
00:05:03,140 --> 00:05:07,530
σε char * λέξη, αν η περάσει
το string είναι στο λεξικό μας.

101
00:05:07,530 --> 00:05:09,890
Έτσι, αν υπάρχει στο λεξικό,
εάν είναι σε hashtable μας,

102
00:05:09,890 --> 00:05:11,170
θα επιστρέψει true.

103
00:05:11,170 --> 00:05:13,380
Και αν δεν είναι, θα επιστρέψει false.

104
00:05:13,380 --> 00:05:17,740
>> Λαμβάνοντας υπόψη αυτό πέρασε στη λέξη, είμαστε
πρόκειται για τον κατακερματισμό της λέξης.

105
00:05:17,740 --> 00:05:22,110
Τώρα, ένα σημαντικό πράγμα που πρέπει να αναγνωρίσουμε είναι
ότι σε φορτίο ξέραμε ότι όλα τα

106
00:05:22,110 --> 00:05:23,820
λέξεις θα πάμε να είναι πεζά.

107
00:05:23,820 --> 00:05:25,820
Αλλά εδώ δεν είμαστε τόσο σίγουροι.

108
00:05:25,820 --> 00:05:29,510
Αν ρίξουμε μια ματιά σε συνάρτηση κατακερματισμού μας,
μας λειτουργία hash πραγματικότητα

109
00:05:29,510 --> 00:05:32,700
είναι κάτω περίβλημα κάθε χαρακτήρα
της λέξης.

110
00:05:32,700 --> 00:05:37,940
Έτσι, ανεξάρτητα από την κεφαλαιοποίηση
λέξη, hash λειτουργία μας είναι η επιστροφή

111
00:05:37,940 --> 00:05:42,270
ο ίδιος δείκτης για ό, τι το
κεφαλαιοποίηση είναι, όπως θα έπρεπε

112
00:05:42,270 --> 00:05:45,280
Επέστρεψε για μια εντελώς πεζά
εκδοχή της λέξης.

113
00:05:45,280 --> 00:05:46,600
Εντάξει.

114
00:05:46,600 --> 00:05:49,790
Αυτός είναι ο δείκτης μας είναι μέσα η
Hashtable για αυτή τη λέξη.

115
00:05:49,790 --> 00:05:52,940
>> Τώρα αυτό για βρόχο πρόκειται να
επαναλήψεις πάνω από την συνδεδεμένη λίστα

116
00:05:52,940 --> 00:05:55,000
ότι ήταν λόγω δείκτη.

117
00:05:55,000 --> 00:05:59,610
Έτσι παρατηρούμε εμείς την προετοιμασία εισόδου
να οδηγούν σε αυτό το δείκτη.

118
00:05:59,610 --> 00:06:02,750
Εμείς πάμε για να συνεχίσει
ενώ η είσοδος! = NULL.

119
00:06:02,750 --> 00:06:07,770
Και να θυμάστε ότι η ενημέρωση του δείκτη
σε συνδεδεμένη μας καταχώριση στη λίστα εισόδου => επόμενο.

120
00:06:07,770 --> 00:06:14,400
Έτσι, έχουν τρέχον σημείο εισόδου μας στο
το επόμενο στοιχείο στη συνδεδεμένη λίστα.

121
00:06:14,400 --> 00:06:19,250
>> Έτσι, για κάθε καταχώρηση στη συνδεδεμένη λίστα,
θα πάμε να χρησιμοποιήσετε strcasecmp.

122
00:06:19,250 --> 00:06:20,330
Δεν είναι strcomp.

123
00:06:20,330 --> 00:06:23,780
Επειδή για άλλη μια φορά, θέλουμε να
κάνουμε τα πράγματα περίπτωση insensitively.

124
00:06:23,780 --> 00:06:27,870
Έτσι χρησιμοποιούμε strcasecmp να συγκρίνουμε τις
λέξη που διήλθε μέσω αυτού

125
00:06:27,870 --> 00:06:31,860
λειτουργία κατά το λόγο
ότι είναι σε αυτή την καταχώρηση.

126
00:06:31,860 --> 00:06:35,570
Αν επιστρέφει μηδέν, αυτό σημαίνει ότι υπήρχε
έναν αγώνα, οπότε θέλουμε να

127
00:06:35,570 --> 00:06:36,630
return true.

128
00:06:36,630 --> 00:06:39,590
Βρήκαμε επιτυχώς η
λέξη hashtable μας.

129
00:06:39,590 --> 00:06:43,040
>> Εάν δεν υπάρχει αντιστοιχία, τότε είμαστε
πρόκειται να βρόχο και πάλι και να δούμε το

130
00:06:43,040 --> 00:06:43,990
επόμενη καταχώρηση.

131
00:06:43,990 --> 00:06:47,640
Και θα συνεχίσουμε looping, ενώ υπάρχει
είναι καταχωρήσεις σε αυτήν την συνδεδεμένη λίστα.

132
00:06:47,640 --> 00:06:50,160
Τι θα συμβεί αν σπάσει
έξω από αυτό για βρόχο;

133
00:06:50,160 --> 00:06:55,110
Αυτό σημαίνει ότι δεν κατάφερε να βρει μια καταχώρηση που
συμφωνημένα αυτή τη λέξη, στην οποία περίπτωση

134
00:06:55,110 --> 00:07:00,220
θα επιστρέψει false για να δείξει ότι μας
hashtable δεν περιέχουν αυτή τη λέξη.

135
00:07:00,220 --> 00:07:02,540
Και αυτό είναι μια επιταγή.

136
00:07:02,540 --> 00:07:04,790
>> Έτσι, ας ρίξουμε μια ματιά στο μέγεθος.

137
00:07:04,790 --> 00:07:06,970
Τώρα το μέγεθος θα είναι αρκετά απλή.

138
00:07:06,970 --> 00:07:11,080
Από θυμάστε του φορτίου, για κάθε λέξη
βρήκαμε, είμαστε αυξάνεται σε παγκόσμιο επίπεδο

139
00:07:11,080 --> 00:07:12,880
μεταβλητό μέγεθος hashtable.

140
00:07:12,880 --> 00:07:16,480
Έτσι, η λειτουργία μέγεθος είναι ακριβώς πρόκειται
να επιστρέψει global μεταβλητή.

141
00:07:16,480 --> 00:07:18,150
Και αυτό είναι όλο.

142
00:07:18,150 --> 00:07:22,300
>> Τώρα επιτέλους, θα πρέπει να ξεφορτώσουν το
λεξικό φορά κάνει τα πάντα.

143
00:07:22,300 --> 00:07:25,340
Λοιπόν, πώς θα πάμε να το κάνουμε αυτό;

144
00:07:25,340 --> 00:07:30,440
Εδώ είμαστε looping πάνω
κουβάδες του πίνακα μας.

145
00:07:30,440 --> 00:07:33,240
Έτσι, υπάρχουν NUM_BUCKETS κουβάδες.

146
00:07:33,240 --> 00:07:37,410
Και για κάθε συνδεδεμένη λίστα σε μας
hashtable, θα πάμε να στρέφονται

147
00:07:37,410 --> 00:07:41,070
το σύνολο της συνδεδεμένης λίστας,
ελευθερώνοντας κάθε στοιχείο.

148
00:07:41,070 --> 00:07:42,900
>> Τώρα πρέπει να είμαστε προσεκτικοί.

149
00:07:42,900 --> 00:07:47,910
Έτσι, εδώ έχουμε μια προσωρινή μεταβλητή
ότι είναι αποθήκευση του δείκτη προς την επόμενη

150
00:07:47,910 --> 00:07:49,730
στοιχείο στην συνδεδεμένη λίστα.

151
00:07:49,730 --> 00:07:52,140
Και μετά θα πάμε στην ελεύθερη
το τρέχον στοιχείο.

152
00:07:52,140 --> 00:07:55,990
Πρέπει να είμαστε σίγουροι ότι κάνουμε αυτό από τότε που
Δεν μπορούμε απλά να απελευθερώσει το τρέχον στοιχείο

153
00:07:55,990 --> 00:07:59,180
και στη συνέχεια προσπαθήστε να μεταβείτε στον επόμενο δείκτη,
δεδομένου ότι μόλις το έχουμε απελευθερωθεί,

154
00:07:59,180 --> 00:08:00,870
η μνήμη καθίσταται άκυρη.

155
00:08:00,870 --> 00:08:04,990
>> Πρέπει, λοιπόν, να κρατήσει γύρω από ένα δείκτη για
το επόμενο στοιχείο, τότε μπορούμε να ελευθερώσουμε το

156
00:08:04,990 --> 00:08:08,360
τρέχον στοιχείο, και στη συνέχεια μπορούμε να ενημερώσετε
τρέχον στοιχείο μας να υποδεικνύουν

157
00:08:08,360 --> 00:08:09,550
Το επόμενο στοιχείο.

158
00:08:09,550 --> 00:08:12,800
Θα βρόχο ενώ υπάρχουν στοιχεία
σε αυτή την συνδεδεμένη λίστα.

159
00:08:12,800 --> 00:08:15,620
Θα το κάνουμε αυτό για όλα τα συνδεδεμένα
καταλόγους στο hashtable.

160
00:08:15,620 --> 00:08:19,460
Και όταν θα τελειώσετε με αυτό, έχουμε
εντελώς ξεφόρτωσε το hashtable, και

161
00:08:19,460 --> 00:08:20,190
τελειώσαμε.

162
00:08:20,190 --> 00:08:23,200
Έτσι είναι αδύνατο για ξεφορτώσουν
ποτέ να επιστρέψει false.

163
00:08:23,200 --> 00:08:26,470
Και όταν τελειώσουμε, θα
μόλις επιστρέψει αλήθεια.

164
00:08:26,470 --> 00:08:29,000
>> Ας δώσει σε αυτό μια δοκιμή λύση.

165
00:08:29,000 --> 00:08:33,070
Έτσι, ας ρίξουμε μια ματιά στο τι μας
struct κόμβος θα μοιάσει.

166
00:08:33,070 --> 00:08:36,220
Εδώ βλέπουμε θα πάμε να έχουν μια bool
λέξη και ένας κόμβος struct * παιδιά

167
00:08:36,220 --> 00:08:37,470
βραχίονα ΑΛΦΑΒΗΤΟ.

168
00:08:37,470 --> 00:08:38,929

169
00:08:38,929 --> 00:08:42,020
Έτσι, το πρώτο πράγμα που θα μπορούσε να είναι
αναρωτιούνται, γιατί είναι ALPHABET

170
00:08:42,020 --> 00:08:44,660
ed ορίζεται ως 27;

171
00:08:44,660 --> 00:08:47,900
Λοιπόν, να θυμάστε ότι θα πάμε να χρειαστεί
να χειρίζεται την απόστροφο.

172
00:08:47,900 --> 00:08:51,910
Έτσι, αυτό πρόκειται να είναι κάπως από μια
ειδική περίπτωση σε ολόκληρο το πρόγραμμα.

173
00:08:51,910 --> 00:08:54,710
>> Τώρα θυμηθείτε πώς μια trie
λειτουργεί πραγματικά.

174
00:08:54,710 --> 00:08:59,380
Ας πούμε ότι είμαστε ευρετηρίαση τη λέξη
"Γάτες". Στη συνέχεια, από τη ρίζα του trie,

175
00:08:59,380 --> 00:09:02,610
θα πάμε να δούμε τα παιδιά
σειρά, και θα πάμε να δούμε το

176
00:09:02,610 --> 00:09:08,090
δείκτη που αντιστοιχεί στο γράμμα
C. Έτσι, η οποία θα πρέπει να αναπροσαρμόζονται 2.

177
00:09:08,090 --> 00:09:11,530
Έτσι, δεδομένου ότι, η βούληση
να μας δώσει ένα νέο κόμβο.

178
00:09:11,530 --> 00:09:13,820
Και τότε θα εργαστούν από αυτόν τον κόμβο.

179
00:09:13,820 --> 00:09:17,770
>> Έτσι, δεδομένου ότι κόμβο, είμαστε για άλλη μια φορά
πρόκειται να εξετάσουμε το φάσμα των παιδιών.

180
00:09:17,770 --> 00:09:22,110
Και θα πάμε να δούμε δείκτη μηδέν
να αντιστοιχεί στο Α γάτας.

181
00:09:22,110 --> 00:09:27,170
Έτσι, τότε θα πάμε για να πάει σε αυτόν τον κόμβο,
και δεδομένου ότι ο κόμβος θα πάμε

182
00:09:27,170 --> 00:09:31,090
για να δούμε στο τέλος είναι ένα αντιστοιχεί
στο T. Και, προχωρώντας σε αυτόν τον κόμβο,

183
00:09:31,090 --> 00:09:35,530
Τέλος, έχουμε εντελώς κοίταξε
μέσω του λόγου μας "γάτα". Και τώρα bool

184
00:09:35,530 --> 00:09:40,960
λέξη έπρεπε να αναφέρει κατά πόσον
Αυτό συγκεκριμένη λέξη είναι στην πραγματικότητα μια λέξη.

185
00:09:40,960 --> 00:09:43,470
>> Έτσι, γιατί χρειαζόμαστε ότι η ειδική περίπτωση;

186
00:09:43,470 --> 00:09:47,700
Λοιπόν, τι τη λέξη "καταστροφή"
είναι στο λεξικό μας, αλλά η

187
00:09:47,700 --> 00:09:50,150
λέξη "γάτα" δεν είναι;

188
00:09:50,150 --> 00:09:54,580
Έτσι και ψάχνει να δει αν η λέξη "γάτα"
είναι στο λεξικό μας, είμαστε

189
00:09:54,580 --> 00:09:59,970
πρόκειται να δούμε με επιτυχία μέσα από
οι δείκτες C-Α-Τ στην περιοχή του κόμβου.

190
00:09:59,970 --> 00:10:04,290
Αλλά αυτό είναι μόνο επειδή καταστροφή
έτυχε να δημιουργήσουν κόμβους στο δρόμο

191
00:10:04,290 --> 00:10:07,190
από το C-Α-Τ, σε όλη τη διαδρομή προς
το τέλος της λέξης.

192
00:10:07,190 --> 00:10:12,020
Έτσι, bool λέξη χρησιμοποιείται για να δηλώσει αν
η συγκεκριμένη θέση

193
00:10:12,020 --> 00:10:14,310
πραγματικότητα δείχνει μια λέξη.

194
00:10:14,310 --> 00:10:15,140
>> Εντάξει.

195
00:10:15,140 --> 00:10:19,310
Έτσι, τώρα που ξέρουμε τι είναι trie
πρόκειται να μοιάσει με, ας δούμε το

196
00:10:19,310 --> 00:10:20,730
load για τη συνάρτηση.

197
00:10:20,730 --> 00:10:24,610
Έτσι, το φορτίο πρόκειται να επιστρέψει μια bool
για το αν επιτυχώς ή

198
00:10:24,610 --> 00:10:26,720
ανεπιτυχώς φορτωθεί το λεξικό.

199
00:10:26,720 --> 00:10:30,460
Και αυτό πρόκειται να είναι το λεξικό
ότι θέλουμε να φορτώσει.

200
00:10:30,460 --> 00:10:33,930
>> Έτσι, το πρώτο πράγμα είμαστε να κάνετε είναι να ανοίξετε
μέχρι το συγκεκριμένο λεξικό για την ανάγνωση.

201
00:10:33,930 --> 00:10:36,160
Και θα πρέπει να βεβαιωθείτε
δεν είχαμε αποτύχει.

202
00:10:36,160 --> 00:10:39,580
Έτσι, αν το λεξικό δεν ήταν
άνοιξε με επιτυχία, θα επιστρέψει

203
00:10:39,580 --> 00:10:42,400
null, στην οποία περίπτωση είμαστε
πρόκειται να επιστρέψει false.

204
00:10:42,400 --> 00:10:47,230
Αλλά και αν υποτεθεί ότι με επιτυχία
ανοιχτεί, τότε μπορούμε πραγματικά να διαβάσετε

205
00:10:47,230 --> 00:10:48,220
μέσω του λεξικού.

206
00:10:48,220 --> 00:10:50,880
>> Έτσι το πρώτο πράγμα που θα πάμε να
θέλετε να κάνετε είναι να έχουμε αυτό το

207
00:10:50,880 --> 00:10:52,500
καθολική μεταβλητή root.

208
00:10:52,500 --> 00:10:56,190
Τώρα ρίζα πρόκειται να είναι ένας κόμβος *.

209
00:10:56,190 --> 00:10:59,760
Είναι η κορυφή του trie μας που είμαστε
πρόκειται να την επανάληψη μέσα.

210
00:10:59,760 --> 00:11:02,660
Έτσι, το πρώτο πράγμα που θα πάμε
να θέλουμε να κάνουμε είναι να διαθέσει

211
00:11:02,660 --> 00:11:04,140
μνήμη για την ρίζα μας.

212
00:11:04,140 --> 00:11:07,980
Παρατηρήστε ότι είμαστε με τη calloc
λειτουργία, η οποία είναι βασικά η ίδια

213
00:11:07,980 --> 00:11:11,500
ως συνάρτηση malloc, εκτός του ότι είναι
εγγυημένη για να επιστρέψει κάτι που είναι

214
00:11:11,500 --> 00:11:13,180
εντελώς μηδενίζεται έξω.

215
00:11:13,180 --> 00:11:17,290
Έτσι, αν χρησιμοποιούσαμε malloc, θα πρέπει να
περάσουν από όλα από τους δείκτες σε μας

216
00:11:17,290 --> 00:11:20,160
κόμβο, και βεβαιωθείτε ότι
γιατί όλα αυτά είναι null.

217
00:11:20,160 --> 00:11:22,710
Έτσι calloc θα το κάνει αυτό για εμάς.

218
00:11:22,710 --> 00:11:26,330
>> Τώρα, όπως ακριβώς malloc, πρέπει να κάνουμε
βέβαιος ότι η κατανομή ήταν πραγματικά

219
00:11:26,330 --> 00:11:27,520
επιτυχής.

220
00:11:27,520 --> 00:11:29,990
Αν αυτό δεν επέστρεψε null, τότε
πρέπει να κλείσει ή να λεξικό

221
00:11:29,990 --> 00:11:32,100
αρχείο και να επιστρέψει false.

222
00:11:32,100 --> 00:11:36,835
Έτσι, υποθέτοντας ότι η κατανομή αυτή
επιτυχής, θα πάμε να χρησιμοποιήσετε ένα κόμβο *

223
00:11:36,835 --> 00:11:40,270
δρομέα για να μετακινηθείτε μέσα από trie μας.

224
00:11:40,270 --> 00:11:43,890
Έτσι, οι ρίζες μας, ποτέ δεν πρόκειται να αλλάξει,
αλλά θα πάμε να χρησιμοποιήσετε το δρομέα στην

225
00:11:43,890 --> 00:11:47,875
πραγματικά να πάει από κόμβο σε κόμβο.

226
00:11:47,875 --> 00:11:50,940
>> Έτσι, σε αυτό το βρόχο for διαβάζουμε
μέσα από το αρχείο λεξικού.

227
00:11:50,940 --> 00:11:53,670
Και είμαστε χρησιμοποιώντας fgetc.

228
00:11:53,670 --> 00:11:56,290
Fgetc πρόκειται να αρπάξει ένα ενιαίο
χαρακτήρα από το αρχείο.

229
00:11:56,290 --> 00:11:59,370
Εμείς πάμε για να συνεχίσει την αρπαγή
χαρακτήρες ενώ δεν φθάνουν το

230
00:11:59,370 --> 00:12:01,570
τέλος του αρχείου.

231
00:12:01,570 --> 00:12:03,480
>> Υπάρχουν δύο περιπτώσεις που πρέπει να χειριστεί.

232
00:12:03,480 --> 00:12:06,610
Το πρώτο, αν ο χαρακτήρας
δεν ήταν μια νέα γραμμή.

233
00:12:06,610 --> 00:12:10,450
Έτσι ξέρουμε αν ήταν μια νέα γραμμή, στη συνέχεια,
είμαστε έτοιμοι να προχωρήσουμε σε μια νέα λέξη.

234
00:12:10,450 --> 00:12:15,240
Αλλά αν υποτεθεί ότι δεν ήταν μια νέα γραμμή, στη συνέχεια,
εδώ θέλουμε να καταλάβουμε το

235
00:12:15,240 --> 00:12:18,380
δείκτη θα πάμε στο δείκτη σε
στο παιδικό πίνακα που

236
00:12:18,380 --> 00:12:19,810
κοιτάξαμε πριν.

237
00:12:19,810 --> 00:12:23,880
>> Έτσι, όπως είπα και πριν, θα πρέπει να
ειδική περίπτωση απόστροφο.

238
00:12:23,880 --> 00:12:26,220
Ανακοίνωση είμαστε με την τριμερή
χειριστή εδώ.

239
00:12:26,220 --> 00:12:29,580
Έτσι θα πάμε για να διαβάσετε αυτό που, αν
ο χαρακτήρας που διαβάζονται ήταν

240
00:12:29,580 --> 00:12:35,330
απόστροφο, τότε θα πάμε να θέσει
index = "ΑΛΦΑΒΗΤΟ" -1, η οποία θα

241
00:12:35,330 --> 00:12:37,680
είναι ο δείκτης 26.

242
00:12:37,680 --> 00:12:41,130
>> Αλλιώς, αν δεν ήταν μια απόστροφο, εκεί
θα πάμε για να ρυθμίσετε το δείκτη

243
00:12:41,130 --> 00:12:43,760
ίση με c - a.

244
00:12:43,760 --> 00:12:49,030
Έτσι θυμηθείτε πίσω από τα προηγουμένως p-ομάδες,
c - a πρόκειται να μας το δώσει

245
00:12:49,030 --> 00:12:53,410
αλφαβητική θέση του C. Έτσι, αν
C είναι το γράμμα Α, αυτό θα

246
00:12:53,410 --> 00:12:54,700
να μας δώσει δείκτη μηδέν.

247
00:12:54,700 --> 00:12:58,120
Για το γράμμα Β, θα δώσει
μας ο δείκτης 1, και ούτω καθεξής.

248
00:12:58,120 --> 00:13:03,010
>> Έτσι, αυτό μας δίνει ο δείκτης στον
παιδιά πίνακα που θέλουμε.

249
00:13:03,010 --> 00:13:08,890
Τώρα, αν ο δείκτης είναι σήμερα ανενεργές
τα παιδιά, αυτό σημαίνει ότι ένας κόμβος

250
00:13:08,890 --> 00:13:11,830
δεν υπάρχει προς το παρόν
από αυτό το μονοπάτι.

251
00:13:11,830 --> 00:13:15,160
Γι 'αυτό και πρέπει να διαθέσουν
ένας κόμβος για αυτή τη διαδρομή.

252
00:13:15,160 --> 00:13:16,550
Αυτό είναι τι θα κάνουμε εδώ.

253
00:13:16,550 --> 00:13:20,690
>> Έτσι θα πάμε να χρησιμοποιήσετε ξανά το calloc
λειτουργία, έτσι ώστε να μην χρειάζεται να

254
00:13:20,690 --> 00:13:22,880
μηδέν όλες τις κατευθύνσεις.

255
00:13:22,880 --> 00:13:27,240
Και εμείς πάλι πρέπει να ελέγξετε
calloc ότι δεν απέτυχε.

256
00:13:27,240 --> 00:13:30,700
Αν calloc είχε αποτύχει, τότε θα πρέπει
να ξεφορτώσουν τα πάντα, κλείστε μας

257
00:13:30,700 --> 00:13:32,820
λεξικό, και να επιστρέψει false.

258
00:13:32,820 --> 00:13:40,050
Έτσι, υποθέτοντας ότι δεν αποτύχει, τότε
Αυτό θα δημιουργήσει ένα νέο παιδί για μας.

259
00:13:40,050 --> 00:13:41,930
Και μετά θα πάμε σε αυτό το παιδί.

260
00:13:41,930 --> 00:13:44,960
Δρομέας μας θα επαναλάβει
προβλέπονται γι 'αυτό το παιδί.

261
00:13:44,960 --> 00:13:49,330
>> Τώρα, αν αυτό δεν ήταν null για να αρχίσει με,
Στη συνέχεια ο δρομέας μπορεί να επαναλάβει μόνο

262
00:13:49,330 --> 00:13:52,590
προβλέπονται γι 'αυτό το παιδί, χωρίς στην πραγματικότητα
χρειάζεται να διαθέσει τίποτα.

263
00:13:52,590 --> 00:13:56,730
Αυτή είναι η περίπτωση όπου αρχικά έγινε
κατανέμει τη λέξη "γάτα". Και

264
00:13:56,730 --> 00:14:00,330
αυτό σημαίνει ότι όταν πάμε να διαθέσει
"Καταστροφή", δεν χρειάζεται να δημιουργήσετε

265
00:14:00,330 --> 00:14:01,680
κόμβων για το C-Α-Τ και πάλι.

266
00:14:01,680 --> 00:14:04,830
Έχουν ήδη υπάρχουν.

267
00:14:04,830 --> 00:14:06,080
>> Τι είναι αυτό το άλλο;

268
00:14:06,080 --> 00:14:10,480
Αυτή είναι η κατάσταση όπου το c ήταν
backslash n, όπου c ήταν μια νέα γραμμή.

269
00:14:10,480 --> 00:14:13,710
Αυτό σημαίνει ότι έχουμε επιτυχία
ολοκλήρωσε μια λέξη.

270
00:14:13,710 --> 00:14:16,860
Τώρα τι θέλουμε να κάνουμε όταν
ολοκλήρωσε με επιτυχία μια λέξη;

271
00:14:16,860 --> 00:14:21,100
Εμείς πάμε για να χρησιμοποιήσετε αυτό το πεδίο λέξη
εσωτερικό του struct node μας.

272
00:14:21,100 --> 00:14:23,390
Θέλουμε να ορίσετε ότι για να είναι αληθινό.

273
00:14:23,390 --> 00:14:27,150
Έτσι ώστε να δείχνει ότι αυτός ο κόμβος
υποδηλώνει μια επιτυχή

274
00:14:27,150 --> 00:14:29,250
λέξη, μια πραγματική λέξη.

275
00:14:29,250 --> 00:14:30,940
>> Τώρα που ότι για να είναι αληθινό.

276
00:14:30,940 --> 00:14:35,150
Θέλουμε να επαναφέρετε τον κέρσορα μας στο σημείο
στην αρχή του trie πάλι.

277
00:14:35,150 --> 00:14:40,160
Και τέλος, αυξήσετε λεξικό μας
μέγεθος, δεδομένου ότι βρήκε άλλη δουλειά.

278
00:14:40,160 --> 00:14:43,230
Έτσι θα πάμε για να συνεχίσουμε να το κάνουμε αυτό,
ανάγνωση στο χαρακτήρα προς χαρακτήρα,

279
00:14:43,230 --> 00:14:49,150
κατασκευή νέων κόμβων στην trie μας και
για κάθε λέξη στο λεξικό, μέχρις ότου

280
00:14:49,150 --> 00:14:54,020
φτάνουμε C! = ΕΟΦ, στον οποίο
περίπτωση που ξεφύγει από το αρχείο.

281
00:14:54,020 --> 00:14:57,050
>> Τώρα υπάρχουν δύο περιπτώσεις σύμφωνα με
που θα μπορούσε να έχει χτυπήσει ΕΟΦ.

282
00:14:57,050 --> 00:15:00,980
Το πρώτο είναι αν υπήρξε ένα λάθος
ανάγνωση από το αρχείο.

283
00:15:00,980 --> 00:15:03,470
Έτσι, αν υπήρχε ένα λάθος,
Πρέπει να κάνουμε το τυπικό.

284
00:15:03,470 --> 00:15:06,460
Ξεφορτώνουν τα πάντα, κοντά
το αρχείο, επιστρέφει false.

285
00:15:06,460 --> 00:15:09,810
Υποθέτοντας ότι δεν υπήρχε κάποιο σφάλμα, ότι
απλά σημαίνει ότι χτύπησε πραγματικά το τέλος του

286
00:15:09,810 --> 00:15:13,750
το αρχείο, στην οποία περίπτωση, κλείνουμε την
αρχείο και να επιστρέψει αληθές, δεδομένου ότι

287
00:15:13,750 --> 00:15:17,330
φορτωθεί με επιτυχία λεξικό
σε trie μας.

288
00:15:17,330 --> 00:15:20,170
>> Έτσι τώρα ας ελέγξει έξω έλεγχο.

289
00:15:20,170 --> 00:15:25,156
Κοιτάζοντας τη λειτουργία ελέγχου, βλέπουμε
ο έλεγχος πρόκειται να επιστρέψει μια bool.

290
00:15:25,156 --> 00:15:29,680
Επιστρέφει true αν αυτή η λέξη ότι είναι
που διαβιβάζονται είναι σε trie μας.

291
00:15:29,680 --> 00:15:32,110
Επιστρέφει false διαφορετικά.

292
00:15:32,110 --> 00:15:36,050
Λοιπόν, πώς να προσδιορίσετε αν
αυτή η λέξη είναι trie μας;

293
00:15:36,050 --> 00:15:40,190
>> Βλέπουμε εδώ ότι, όπως και πριν,
θα πάμε να χρησιμοποιήσετε το δρομέα για να μετακινηθείτε

294
00:15:40,190 --> 00:15:41,970
μέσω trie μας.

295
00:15:41,970 --> 00:15:46,600
Τώρα εδώ θα πάμε για να μετακινηθείτε
σε ολόκληρη τη λέξη μας.

296
00:15:46,600 --> 00:15:50,620
Έτσι επανάληψη πάνω από τη λέξη είμαστε το παρελθόν,
θα πάμε για τον προσδιορισμό της

297
00:15:50,620 --> 00:15:56,400
δείκτη στην συστοιχία των παιδιών που
αντιστοιχεί στη λέξη βραχίονα Ι. Έτσι, αυτό

298
00:15:56,400 --> 00:15:59,670
πρόκειται να δούμε ακριβώς όπως
φορτίο, όπου αν λέξη [i]

299
00:15:59,670 --> 00:16:03,310
είναι μια απόστροφο, τότε θέλουμε
να χρησιμοποιήσει δείκτη «αλφάβητο» - 1.

300
00:16:03,310 --> 00:16:05,350
Επειδή διαπιστώσαμε ότι
είναι όπου θα πάμε για να αποθηκεύσετε

301
00:16:05,350 --> 00:16:07,100
αποστρόφους.

302
00:16:07,100 --> 00:16:11,780
>> Αλλιώς θα πάμε να χρησιμοποιούν δύο κάτω λέξη
βραχίονα Ι. Έτσι, να θυμάστε ότι η λέξη μπορεί

303
00:16:11,780 --> 00:16:13,920
έχουν αυθαίρετα κεφαλαιοποίηση.

304
00:16:13,920 --> 00:16:17,540
Και έτσι θέλουμε να βεβαιωθείτε ότι είμαστε
χρησιμοποιώντας έναν πεζό έκδοση των πραγμάτων.

305
00:16:17,540 --> 00:16:21,920
Και στη συνέχεια, αφαιρέστε από το ότι «ένα» για μια φορά
και πάλι να μας δώσει την αλφαβητική

306
00:16:21,920 --> 00:16:23,880
θέση αυτού του χαρακτήρα.

307
00:16:23,880 --> 00:16:27,680
Έτσι, αυτό πρόκειται να είναι ευρετήριό μας
στον πίνακα των παιδιών.

308
00:16:27,680 --> 00:16:32,420
>> Και τώρα, αν ο δείκτης στα παιδιά
πίνακας είναι μηδενική, αυτό σημαίνει ότι

309
00:16:32,420 --> 00:16:34,990
δεν μπορεί πλέον να συνεχίσει την επανάληψη
κάτω trie μας.

310
00:16:34,990 --> 00:16:38,870
Αν αυτή είναι η περίπτωση, αυτή η λέξη δεν μπορεί να
ενδεχομένως να είναι σε trie μας.

311
00:16:38,870 --> 00:16:42,340
Δεδομένου ότι αν ήταν, ότι θα
σημαίνει ότι θα υπάρξει ένα μονοπάτι

312
00:16:42,340 --> 00:16:43,510
μέχρι αυτή τη λέξη.

313
00:16:43,510 --> 00:16:45,290
Και ποτέ δεν θα αντιμετωπίσετε null.

314
00:16:45,290 --> 00:16:47,850
Έτσι αντιμετωπίζουν μηδενική, επιστρέφει false.

315
00:16:47,850 --> 00:16:49,840
Η λέξη δεν υπάρχει στο λεξικό.

316
00:16:49,840 --> 00:16:53,660
Αν δεν ήταν μηδενική, τότε είμαστε
πρόκειται να συνεχίσει την επανάληψη.

317
00:16:53,660 --> 00:16:57,220
>> Έτσι θα πάμε εκεί έξω δρομέα
στο σημείο σε αυτό το συγκεκριμένο

318
00:16:57,220 --> 00:16:59,760
κόμβο στο εν λόγω δείκτη.

319
00:16:59,760 --> 00:17:03,150
Κρατάμε το κάνουμε αυτό σε όλη
ολόκληρη η λέξη, υποθέτοντας

320
00:17:03,150 --> 00:17:03,950
εμείς ποτέ δεν χτύπησε null.

321
00:17:03,950 --> 00:17:07,220
Αυτό σημαίνει ότι ήμασταν σε θέση να περάσει
ολόκληρη η λέξη και να βρει

322
00:17:07,220 --> 00:17:08,920
ένας κόμβος στην προσπάθειά μας.

323
00:17:08,920 --> 00:17:10,770
Αλλά δεν είμαστε αρκετά γίνονται ακόμα.

324
00:17:10,770 --> 00:17:12,290
>> Δεν θέλουμε απλά να επιστρέψουν αλήθεια.

325
00:17:12,290 --> 00:17:14,770
Θέλουμε να επιστρέψουμε κέρσορα> λέξη.

326
00:17:14,770 --> 00:17:18,980
Από το θυμηθείτε και πάλι, είναι "γάτα" δεν είναι
στο λεξικό μας, και "καταστροφή"

327
00:17:18,980 --> 00:17:22,935
είναι, τότε θα έχουμε επιτυχία
μέσα από τη λέξη «γάτα». Αλλά δρομέα

328
00:17:22,935 --> 00:17:25,760
λέξη θα είναι ψευδής και δεν είναι αλήθεια.

329
00:17:25,760 --> 00:17:30,930
Έτσι επιστρέφουμε λέξη δρομέα για να δείξει
αν ο κόμβος αυτός είναι στην πραγματικότητα μια λέξη.

330
00:17:30,930 --> 00:17:32,470
Και αυτό είναι για έλεγχο.

331
00:17:32,470 --> 00:17:34,250
>> Έτσι, ας ελέγξει έξω μέγεθος.

332
00:17:34,250 --> 00:17:37,350
Έτσι, το μέγεθος θα είναι αρκετά εύκολο
δεδομένου ότι, θυμηθείτε το φορτίο, είμαστε

333
00:17:37,350 --> 00:17:41,430
προσαύξηση του μεγέθους λεξικό για
κάθε λέξη που συναντάμε.

334
00:17:41,430 --> 00:17:45,350
Έτσι, το μέγεθος είναι ακριβώς πρόκειται να
επιστρέψει λεξικό μέγεθος.

335
00:17:45,350 --> 00:17:47,390
Και αυτό είναι όλο.

336
00:17:47,390 --> 00:17:50,590
>> Έτσι, τέλος, έχουμε ξεφορτώσουν.

337
00:17:50,590 --> 00:17:55,100
Έτσι ξεφορτώσουν, θα πάμε να χρησιμοποιήσετε ένα
αναδρομική συνάρτηση για να κάνει πραγματικότητα όλα

338
00:17:55,100 --> 00:17:56,530
των εργασιών μας.

339
00:17:56,530 --> 00:17:59,340
Έτσι, η λειτουργία μας πρόκειται να
να κληθούν εκφορτωτής.

340
00:17:59,340 --> 00:18:01,650
Τι αποφόρτισης πρόκειται να κάνει;

341
00:18:01,650 --> 00:18:06,580
Βλέπουμε εδώ ότι ο εκφορτωτής πρόκειται να
επαναλάβετε σε όλα τα παιδιά σε

342
00:18:06,580 --> 00:18:08,410
Αυτό το συγκεκριμένο κόμβο.

343
00:18:08,410 --> 00:18:11,750
Και αν ο κόμβος παιδί δεν είναι
null, τότε θα πάμε να

344
00:18:11,750 --> 00:18:13,730
ξεφορτώνουν τον κόμβο παιδί.

345
00:18:13,730 --> 00:18:18,010
>> Έτσι, αυτό είναι που αναδρομικά ξεφορτώσουν
όλα τα παιδιά μας.

346
00:18:18,010 --> 00:18:21,080
Μόλις είμαστε σίγουροι ότι όλα τα παιδιά μας
έχουν εκφορτωθεί, τότε

347
00:18:21,080 --> 00:18:25,210
μπορούμε να απελευθερωθούμε, έτσι
ξεφορτώνουν τους εαυτούς μας.

348
00:18:25,210 --> 00:18:29,460
Αυτό θα λειτουργήσει αναδρομικά
ξεφορτώσουν το σύνολο trie.

349
00:18:29,460 --> 00:18:32,850
Και στη συνέχεια, μόλις γίνει αυτό,
μπορούμε απλά να επιστρέψουμε αλήθεια.

350
00:18:32,850 --> 00:18:34,210
Ξεφορτώσουν δεν μπορεί να αποτύχει.

351
00:18:34,210 --> 00:18:35,710
Εμείς απλά απελευθερώνοντας τα πράγματα.

352
00:18:35,710 --> 00:18:38,870
Συνεπώς, μόλις τελειώσαμε την απελευθέρωση
τα πάντα, να επιστρέψει αλήθεια.

353
00:18:38,870 --> 00:18:40,320
Και αυτό είναι όλο.

354
00:18:40,320 --> 00:18:41,080
Το όνομά μου είναι Rob.

355
00:18:41,080 --> 00:18:42,426
Και αυτό ήταν ορθογράφος.

356
00:18:42,426 --> 00:18:47,830
>> [Παίζει μουσική]