1
00:00:00,000 --> 00:00:12,350
>> [MUSIC ప్లే]

2
00:00:12,350 --> 00:00:13,050
>> రాబ్ బౌడెన్: ఎక్కువ.

3
00:00:13,050 --> 00:00:13,640
నేను రాబ్ ఉన్నాను.

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
కనుక ఇది ఒక చార్ పదం కలిగి జరగబోతోంది
పరిమాణం పొడవు + 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
మరియు తర్వాత మేము ఒక అదనపు అవసరం చూడాలని
బాక్ స్లాష్ సున్నా పాత్ర.

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 నోడ్ * తదుపరి.

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
ఇది విజయవంతంగా ఉంటే మీరు నిజమైన తిరిగి
లోడ్, మరియు తప్పుడు లేకపోతే.

27
00:01:20,530 --> 00:01:23,990
మరియు అది, ఒక కాన్స్ట్ చార్ * నిఘంటువు పడుతుంది
నిఘంటువు ఇది

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
మరియు మేము తప్పుడు తిరిగి.

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
మేము కొన్ని కనుగొనేందుకు వరకు మళ్ళీ వెతికినా ఉంచడానికి
ఈ లూప్ నుండి బ్రేక్ కారణం,

37
00:01:46,450 --> 00:01:47,570
మేము చూస్తారు ఇది.

38
00:01:47,570 --> 00:01:48,920
కాబట్టి మళ్ళీ వెతికినా ఉంచడానికి.

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 జరిగింది, దగ్గరగా
నిఘంటువు మరియు తప్పుడు తిరిగి.

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
కాబట్టి ఆ ప్రవేశం> పదం గుర్తు చార్
+ 1 పరిమాణం LENGHTH మాట బఫర్

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
ఎంట్రీ> పదం, తర్వాత ఆ చూడాలని
మా హాష్ ఫంక్షన్ను ఉపయోగించి పదం.

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
మీరు గుర్తించడానికి అవసరం మాత్రమే విషయం
ఈ ఒక కాన్స్ట్ చార్ * పదం పడుతుంది.

60
00:03:04,010 --> 00:03:08,960
ఇది ఇన్పుట్ వంటి స్ట్రింగ్ తీసుకొని, మరియు
అవుట్పుట్ ఒక 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
>> మేము NUM_BUCKETS ద్వారా Moding గమనించవచ్చు,
కాబట్టి ఆ విలువ తిరిగి

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
మరియు తర్వాత మేము ఉపయోగించడానికి వెళుతున్న
ఇన్సర్ట్ హాష్

69
00:03:31,700 --> 00:03:33,750
hashtable ప్రవేశం.

70
00:03:33,750 --> 00:03:38,520
>> ఇప్పుడు hashtable హాష్ ప్రస్తుత ఉంది
పట్టికలో లింక్ జాబితా.

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
హాష్, ప్రస్తుత ఎంట్రీ.

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
లోపం తరువాత, ఉంది ఉంటే
మేము తప్పుడు తిరిగి అనుకుంటున్నారా.

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
చార్ * పదం లో, లేదో జారీ
స్ట్రింగ్ లో మా నిఘంటువులో లో ఉంది.

101
00:05:07,530 --> 00:05:09,890
, నిఘంటువులో ఇది చేస్తే
అది మా hashtable లో ఉంటే,

102
00:05:09,890 --> 00:05:11,170
మేము నిజమైన తిరిగి ఉంటుంది.

103
00:05:11,170 --> 00:05:13,380
ఇది కాదు ఉంటే, మేము తప్పుడు తిరిగి ఉంటుంది.

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
మేము మా హాష్ ఫంక్షన్ను పరిశీలించి ఉంటే,
నిజానికి మా హాష్ ఫంక్షన్ను

109
00:05:29,510 --> 00:05:32,700
తక్కువ పెట్ట ప్రతి పాత్ర
పదం యొక్క.

110
00:05:32,700 --> 00:05:37,940
కాబట్టి సంబంధం లేకుండా మూలధనీకరణ
పదం, మా హాష్ ఫంక్షన్ను తిరిగి ఉంది

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
>> ఇప్పుడు లూప్ ఈ అన్నారు
లింక్ జాబితా పై iterate

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
నిజమైన తిరిగి.

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
మరియు మేము అయితే మళ్ళీ వెతికినా చేస్తాము
ఈ లింక్ జాబితాలో ప్రవేశాలు.

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
మేము సూచించడానికి తప్పుడు తిరిగి మా
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
కాబట్టి పరిమాణం ఫంక్షన్ కేవలం అన్నారు
ప్రపంచ వేరియబుల్ తిరిగి.

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
ఇక్కడే మేము పైగా మళ్ళీ వెతికినా
మా పట్టిక అన్ని బకెట్లు.

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
కనుక ఇది దించుతున్న కోసం అసాధ్యం
ఎప్పుడూ తప్పుడు తిరిగి.

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
బ్రాకెట్ ALPHABET.

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

169
00:08:38,929 --> 00:08:42,020
మీరు కావచ్చు మొదటి విషయం
wondering, ఎందుకు ALPHABET ఉంది

170
00:08:42,020 --> 00:08:44,660
ed 27 నిర్వచించారు?

171
00:08:44,660 --> 00:08:47,900
Well, మేము అవసరం చూడాలని గుర్తుంచుకోవాలి
అపాస్టిఫియర్ నిర్వహించడానికి చేయడానికి.

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
అక్షరం అనుగుణంగా ఆ సూచిక
2 సూచించాలని చేస్తాము C. కాబట్టి.

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
ముగింపు చూడండి ఇది ఒక సమంగా ఉంది
టి మరియు ఆ నోడ్ వెళ్ళేముందు, కు

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
Well ఏమి పదం యొక్క "విపత్తు"
మా నిఘంటువులో లో ఉంది, కానీ

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-A-T.

190
00:09:59,970 --> 00:10:04,290
కానీ ఏకైక ఎందుకంటే విపత్తు
మార్గంలో నోడ్స్ సృష్టించడానికి జరిగిన

191
00:10:04,290 --> 00:10:07,190
సి-A-T నుండి, అన్ని మార్గం
పదం యొక్క చివరి.

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
ఫంక్షన్ లోడ్.

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
శూన్య కేసులో మేము
తప్పుడు తిరిగి వెళుతున్న.

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
ప్రపంచ వేరియబుల్ రూట్.

208
00:10:52,500 --> 00:10:56,190
ఇప్పుడు రూట్ * ఒక నోడ్ అవతరిస్తుంది.

209
00:10:56,190 --> 00:10:59,760
ఇది మేము మా trie పైన ఉంది
ద్వారా iterating కావడం.

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
నోడ్, మరియు నిర్ధారించుకోండి
వారు అన్ని శూన్య ఉన్నారు.

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
ఈ శూన్య తిరిగి, అప్పుడు మేము
దగ్గరగా లేదా నిఘంటువు అవసరం

221
00:11:29,990 --> 00:11:32,100
ఫైల్ మరియు తప్పుడు తిరిగి.

222
00:11:32,100 --> 00:11:36,835
కాబట్టి ఆ జి ఊహిస్తూ
విజయవంతమైన, మేము ఒక నోడ్ * ఉపయోగించడానికి వెళుతున్న

223
00:11:36,835 --> 00:11:40,270
మా trie ద్వారా iterate కర్సర్.

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
>> కాబట్టి ఈ లో లూప్ మేము చదువుతున్నారని
నిఘంటువు ఫైలు ద్వారా.

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
అపాస్టిఫియర్, అప్పుడు మేము సెట్ చూడాలని
ఇండెక్స్ = "ALPHABET" -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
సి సమానంగా - ఒక.

244
00:12:43,760 --> 00:12:49,030
కాబట్టి తిరిగి గతంలో p-సెట్స్ నుండి గుర్తు,
సి - ఒక మాకు ఇవ్వాలని అన్నారు

245
00:12:49,030 --> 00:12:53,410
C. యొక్క అక్షర స్థానం అయితే
సి ఈ రెడీ లేఖ, ఉంది

246
00:12:53,410 --> 00:12:54,700
మాకు ఇండెక్స్ సున్నా ఇస్తాయి.

247
00:12:54,700 --> 00:12:58,120
లేఖ B, అది ఇస్తుంది
కాబట్టి మాకు ఇండెక్స్ 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
నిఘంటువు, మరియు తప్పుడు తిరిగి.

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
మా కర్సర్ iterate ఉంటుంది
బిడ్డకు డౌన్.

261
00:13:44,960 --> 00:13:49,330
>> ఇప్పుడు ఈ తో ప్రారంభించడానికి శూన్య కాకుంటే,
అప్పుడు కర్సర్ iterate చేయవచ్చు

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
మళ్ళీ సి-A-T కోసం నోడ్స్.

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
ఈ సి అక్కడ పరిస్థితి
సి కొత్త లైన్ అక్కడ బాక్ స్లాష్ n,.

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 నోడ్ లోపలి.

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
మేము చివరకు సి చేరుకోవడానికి! = EOF, దీనిలో
సందర్భంలో మేము ఫైలు బయటకు.

281
00:14:54,020 --> 00:14:57,050
>> ఇప్పుడు రెండు కేసులు కింద ఉన్నాయి
మేము EOF హిట్ ఉండవచ్చు ఇది.

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
దగ్గరగా, ప్రతిదీ దించుతున్న
ఫైలు, తప్పుడు తిరిగి.

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
ఈ పదం అని ఉంటే అది నిజమైన తిరిగి
తరాలకు మా trie ఉంది.

291
00:15:29,680 --> 00:15:32,110
లేకపోతే తప్పుడు తిరిగి.

292
00:15:32,110 --> 00:15:36,050
కాబట్టి మీరు నిర్ధారించడానికి ఉంటాయి
ఈ పదం మా trie ఉంది?

293
00:15:36,050 --> 00:15:40,190
>> మేము ఇక్కడ చూసే ముందు వలె,
మేము iterate కర్సర్ ఉపయోగించడానికి వెళుతున్న

294
00:15:40,190 --> 00:15:41,970
మా trie ద్వారా.

295
00:15:41,970 --> 00:15:46,600
ఇప్పుడు ఇక్కడ మేము iterate చూడాలని
మా మొత్తం పదంపైన.

296
00:15:46,600 --> 00:15:50,620
కాబట్టి, మేము గతంలో ఉన్నాయి పదం మీద iterating
మేము నిర్ణయించే చూడాలని

297
00:15:50,620 --> 00:15:56,400
ఇండెక్స్ పిల్లలు శ్రేణి ఆ
పదం బ్రాకెట్ I. అనుగుణంగా ఈ

298
00:15:56,400 --> 00:15:59,670
ఖచ్చితంగా ఇలా అన్నారు
లోడ్, పేరు పదం [i]

299
00:15:59,670 --> 00:16:03,310
అపాస్ట్రఫీని, అప్పుడు మేము కావలసిన ఉంది
ఇండెక్స్ "ALPHABET" ఉపయోగించడానికి - 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
>> మిగతా మేము దిగువ రెండు పదం ఉపయోగించడానికి వెళుతున్న
బ్రాకెట్ I. కాబట్టి ఆ పదం గుర్తుంచుకోగలరు

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
ఇకపై iterating కొనసాగించవచ్చు
మా 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
మరియు మీరు శూన్య ఎదుర్కునే ఎప్పటికీ.

314
00:16:45,290 --> 00:16:47,850
కాబట్టి శూన్య ఎదుర్కొనడానికి, మేము తప్పుడు తిరిగి.

315
00:16:47,850 --> 00:16:49,840
నిఘంటువులో పదం కాదు.

316
00:16:49,840 --> 00:16:53,660
అది శూన్య కాదు, అప్పుడు మేము
iterating కొనసాగుతుంది అన్నారు.

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
మేము శూన్య హిట్ ఎప్పుడూ.

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
మా ఫంక్షన్ అన్నారు
unloader అని అంటాము.

340
00:17:59,340 --> 00:18:01,650
ఏ unloader చేయబోవడం?

341
00:18:01,650 --> 00:18:06,580
మేము ఆ unloader అన్నారు ఇక్కడ చూడండి
పిల్లల అన్ని వద్ద మీద iterate

342
00:18:06,580 --> 00:18:08,410
ఈ ప్రత్యేక నోడ్.

343
00:18:08,410 --> 00:18:11,750
మరియు పిల్లల నోడ్ లేకపోతే
శూన్య, అప్పుడు మేము చూడాలని

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
నా పేరు రాబ్ ఉంది.

355
00:18:41,080 --> 00:18:42,426
మరియు ఈ స్పెల్లర్ ఉంది.

356
00:18:42,426 --> 00:18:47,830
>> [MUSIC ప్లే]