1
00:00:00,000 --> 00:00:09,700

2
00:00:09,700 --> 00:00:12,140
>> ZAMYLA ચાન: માતાનો બનાવીએ
જોડણી પરીક્ષક.

3
00:00:12,140 --> 00:00:16,900
તમે speller.c ખોલો, તો પછી તમે જોશો
તે માટે વિધેય સૌથી

4
00:00:16,900 --> 00:00:20,810
એક સામે લખાણ ફાઈલ ચકાસણી
શબ્દકોશ પહેલેથી જ તમારા માટે બનાવવામાં આવે છે.

5
00:00:20,810 --> 00:00:26,330
એક શબ્દકોશ લખાણમાં પસાર. / સ્પેલર,
ફાઇલ અને પછી બીજા લખાણ ફાઈલ છે,

6
00:00:26,330 --> 00:00:28,960
કે લખાણ ફાઈલ તપાસ કરશે
શબ્દકોશમાં સામે.

7
00:00:28,960 --> 00:00:34,160
>> હવે, શબ્દકોશ લખાણ ફાઈલો સમાવશે
માન્ય શબ્દો, લાઇન દીઠ એક.

8
00:00:34,160 --> 00:00:37,910
પછી speller.c લોડ ફોન કરશે
શબ્દકોશમાં લખાણ ફાઈલ છે.

9
00:00:37,910 --> 00:00:43,650
તે કહેવાય કાર્ય પર તપાસો કહી શકશો
આ ઇનપુટ ટેક્સ્ટ ફાઇલ માં દરેક શબ્દ,

10
00:00:43,650 --> 00:00:46,460
બધા જોડણી ખોટી શબ્દો પ્રિન્ટ કરે છે.

11
00:00:46,460 --> 00:00:50,030
>> Speller.c પણ કદ ફોન કરશે
માં શબ્દોની સંખ્યા નક્કી

12
00:00:50,030 --> 00:00:53,500
શબ્દકોશ અને કોલ અનલોડ
મેમરી મુક્ત છે.

13
00:00:53,500 --> 00:00:57,600
speller.c પણ કેવી રીતે સાચવી રાખે કરશે
ખૂબ સમય આ કરવા માટે વપરાય છે

14
00:00:57,600 --> 00:01:00,560
પ્રક્રિયા, પરંતુ અમે પડશે
પાછળથી તે મળે છે.

15
00:01:00,560 --> 00:01:02,440
>> તેથી આપણે શું જરૂર છે?

16
00:01:02,440 --> 00:01:05,110
અમે dictionary.c ભરવા માટે જરૂર છે.

17
00:01:05,110 --> 00:01:09,940
Dictionary.c, અમે સહાય કરનાર છે
લોડ જે કાર્ય લોડ,

18
00:01:09,940 --> 00:01:10,855
આપનું સ્વાગત છે.

19
00:01:10,855 --> 00:01:15,490
જો ચકાસે છે કે જે કાર્ય ચેક,
આપેલ શબ્દ કોશ છે.

20
00:01:15,490 --> 00:01:19,150
કાર્ય માપ સંખ્યા આપે
શબ્દકોશમાંનાં શબ્દો.

21
00:01:19,150 --> 00:01:24,870
અને છેલ્લે, અમે, ઉતર્યો છે જે
મેમરી ના શબ્દકોશ મુક્ત કરે છે.

22
00:01:24,870 --> 00:01:27,070
>> તેથી પ્રથમ, લોડ સામનો કરીએ.

23
00:01:27,070 --> 00:01:32,110
શબ્દકોશમાં લખાણમાં દરેક શબ્દ માટે
ફાઇલને લોડ માં શબ્દો સ્ટોર કરશે

24
00:01:32,110 --> 00:01:34,860
શબ્દકોશમાં માહિતી બંધારણ
તમારી પસંદગીના, ક્યાં તો ના

25
00:01:34,860 --> 00:01:36,750
કોષ્ટક અથવા એક trie હેશ.

26
00:01:36,750 --> 00:01:39,440
હું બંને પર જઈશ
આ લઈ જવામાં.

27
00:01:39,440 --> 00:01:43,150
>> પ્રથમ માતાનો હેશ કોષ્ટકો વિશે વાત કરો.

28
00:01:43,150 --> 00:01:47,050
તમે 10 બિલિયર્ડ બોલમાં હતી અને કહે છે
તમે તેમનો સંગ્રહ કરવા માગે છે.

29
00:01:47,050 --> 00:01:50,420
તમે એક ડોલ તેમને બધા મૂકવા છે,
અને તમે ચોક્કસ જ્યારે જરૂર પડે ત્યારે

30
00:01:50,420 --> 00:01:54,010
બોલ નંબર, તમે એક લઇ છો
એક સમયે મરી બહાર

31
00:01:54,010 --> 00:01:55,880
કે બોલ શોધી.

32
00:01:55,880 --> 00:01:59,370
અને માત્ર 10 બોલમાં સાથે, તમે પ્રયત્ન કરીશું
વાજબી તમારા બોલ શોધવા માટે સક્ષમ

33
00:01:59,370 --> 00:02:01,160
તે સમયનો જથ્થો.

34
00:02:01,160 --> 00:02:03,180
>> પરંતુ જો તમે 20 બોલમાં હોય તો?

35
00:02:03,180 --> 00:02:05,480
તે હવે થોડો સમય સુધી લાગી શકે છે.

36
00:02:05,480 --> 00:02:06,180
શું 100 વિશે શું?

37
00:02:06,180 --> 00:02:07,880
1,000?

38
00:02:07,880 --> 00:02:11,590
હવે, તે ખૂબ સરળ છે જો
તમે ઘણા buckets હતી.

39
00:02:11,590 --> 00:02:15,890
કદાચ બોલ્સ એક ડોલ શૂન્ય નંબર
નવ સુધી બીજું ડોલ દ્વારા

40
00:02:15,890 --> 00:02:18,800
બોલમાં 10 દ્વારા નંબર
19, અને તેથી.

41
00:02:18,800 --> 00:02:22,330
>> હવે તમે ચોક્કસ જોવા માટે જ્યારે જરૂર પડે ત્યારે
બોલ, તમે આપોઆપ કરી શકે

42
00:02:22,330 --> 00:02:26,320
એક ચોક્કસ ડોલ પર જાઓ અને
કે ડોલ શોધ.

43
00:02:26,320 --> 00:02:29,840
અને દરેક ડોલ આશરે 10 હોય તો
બોલ, પછી તમે સરળતાથી શોધવા શકે

44
00:02:29,840 --> 00:02:31,790
તે મારફતે.

45
00:02:31,790 --> 00:02:34,960
>> હવે, અમે સાથે કામ કરીએ છીએ, કારણ કે
શબ્દકોશો, એક જ ડોલ

46
00:02:34,960 --> 00:02:41,970
શબ્દકોશમાંનાં તમામ શબ્દો કરશે
કદાચ અત્યાર સુધી ખૂબ થોડા ડોલથી છે.

47
00:02:41,970 --> 00:02:44,370
તેથી આપણે હેશ કોષ્ટકો પર એક નજર કરીએ.

48
00:02:44,370 --> 00:02:46,940
>> ડોલથી ઝાકઝમાળ તરીકે તે વિચારો.

49
00:02:46,940 --> 00:02:50,370
અને આ કિસ્સામાં, ડોલથી
અમારા સંલગ્ન યાદી છે.

50
00:02:50,370 --> 00:02:54,770
અને અમે અમારા તમામ શબ્દો વિતરણ પડશે
આ ઘણી સંલગ્ન યાદીઓ માં નો સમાવેશ થાય છે

51
00:02:54,770 --> 00:02:58,940
હેશ વિધેય મદદથી એક સંગઠિત રીતે,
અમને જણાવો કે જે જે

52
00:02:58,940 --> 00:03:03,720
આપેલ કી ડોલ, આપેલ
શબ્દ, માટે અનુસરે છે.

53
00:03:03,720 --> 00:03:05,960
>> માતાનો schematically આ પ્રતિનિધિત્વ કરીએ.

54
00:03:05,960 --> 00:03:11,320
અહીં વાદળી બોક્સ કિંમતો સમાવે છે અને
લાલ બોક્સ બીજા કિંમત માટે નિર્દેશ

55
00:03:11,320 --> 00:03:12,280
નિર્દેશક જોડી.

56
00:03:12,280 --> 00:03:14,800
અમે આ જોડીઓ ગાંઠો કહી શકશો.

57
00:03:14,800 --> 00:03:18,260
હવે, દરેક ડોલ, હું જણાવ્યું હતું કે,
અગાઉ, એક કડી થયેલ યાદી છે.

58
00:03:18,260 --> 00:03:21,820
સંલગ્ન યાદીઓ, દરેક નોડ એક મૂલ્ય છે,
આ માટે તેમજ નિર્દેશક

59
00:03:21,820 --> 00:03:23,170
આગામી કિંમત.

60
00:03:23,170 --> 00:03:26,150
>> હવે, કડી થયેલ યાદી સાથે વ્યવહાર,
તે ખૂબ જ મહત્વપૂર્ણ છે કે જે તમને

61
00:03:26,150 --> 00:03:28,120
કોઇ કડીઓ ગુમાવી નથી.

62
00:03:28,120 --> 00:03:32,250
અને યાદ રાખો અન્ય હકીકત એ છે કે
છેલ્લા નોડ, તે નિર્દેશ ન થાય તો

63
00:03:32,250 --> 00:03:35,120
અન્ય નોડ, નલ નિર્દેશ કરે છે.

64
00:03:35,120 --> 00:03:37,970
>> તેથી અમે કેવી રીતે સી માં આ રજૂ કરે છે?

65
00:03:37,970 --> 00:03:40,540
અમે અહીં અમારા સ્ટ્રક્ટ વ્યાખ્યાયિત કરે છે.

66
00:03:40,540 --> 00:03:44,850
અને આ કિસ્સામાં કિંમત છે
લંબાઈ એક કોલસો બનાવો એરે.

67
00:03:44,850 --> 00:03:48,880
લંબાઈ છે જ્યાં લંબાઈ વત્તા 1,
વધુમાં વધુ કોઈપણ શબ્દ લંબાઈ, વત્તા 1 માટે

68
00:03:48,880 --> 00:03:50,380
નલ ટર્મીનેટર.

69
00:03:50,380 --> 00:03:54,210
અને પછી અમે એક નિર્દેશક હોય છે
આગામી કહેવાય અન્ય નોડ.

70
00:03:54,210 --> 00:03:56,730
>> તેથી આપણે નાના સંલગ્ન યાદી બનાવીએ.

71
00:03:56,730 --> 00:04:00,390
પ્રથમ, તમે તમારા નોડ malloc કરવા માંગો છો પડશે,
મેમરીમાં જગ્યા બનાવવા જે

72
00:04:00,390 --> 00:04:04,010
તમારા નોડ પ્રકાર માપ.

73
00:04:04,010 --> 00:04:06,100
અને અન્ય નોડ બનાવવા માટે,
ફરીથી mallocing.

74
00:04:06,100 --> 00:04:09,370

75
00:04:09,370 --> 00:04:14,340
>> હવે તમે એક કિંમત સોંપી કરવા માંગો છો
શબ્દ, તો પછી અમે node1 તીર કહી શકે

76
00:04:14,340 --> 00:04:18,820
શબ્દ "હેલો." જેટલી જ થાય છે આ તીર ઓપરેટર
નિર્દેશક અને dereferences

77
00:04:18,820 --> 00:04:20,620
સ્ટ્રક્ટ માતાનો ચલો ઍક્સેસ.

78
00:04:20,620 --> 00:04:24,330
આ રીતે, અમે બંને ઉપયોગ કરવાની જરૂર નથી
ડોટ અને તારો ઓપરેટર.

79
00:04:24,330 --> 00:04:30,100
>> તેથી પછી હું node2 તીર શબ્દ સમકક્ષ હોય છે
"વિશ્વ." અને ત્યાં, આ કિંમતો છે

80
00:04:30,100 --> 00:04:33,110
મારા ગાંઠો રચાયેલ.

81
00:04:33,110 --> 00:04:38,780
કડીઓ બનાવવા માટે, હું node1 પાસ પડશે
આગામી તીર, કે નોડ સ્ટાર ઍક્સેસ,

82
00:04:38,780 --> 00:04:44,160
કે નોડ નિર્દેશક, node2 જેટલી જ થાય છે,
બે node2 માટે node1 પોઇન્ટ.

83
00:04:44,160 --> 00:04:46,360
અને ત્યાં અમે એક કડી થયેલ યાદી હોય છે.

84
00:04:46,360 --> 00:04:51,480
>> તેથી કે જે હમણાં જ એક કડી થયેલ યાદી છે, પરંતુ
હેશ કોષ્ટક એક સમગ્ર જૂથ છે

85
00:04:51,480 --> 00:04:52,520
સંલગ્ન યાદીઓ.

86
00:04:52,520 --> 00:04:55,920
ઠીક છે, અમે એ જ નોડ પડશે
પહેલાની જેમ માળખું.

87
00:04:55,920 --> 00:05:00,140
પરંતુ અમે એક વાસ્તવિક હેશ ટેબલ માગતા હતા,
પછી અમે માત્ર એક નોડ નિર્દેશક કરી શકો છો

88
00:05:00,140 --> 00:05:01,330
અહીં દર્શાવે છે.

89
00:05:01,330 --> 00:05:04,940
ઉદાહરણ તરીકે, કદ 500.

90
00:05:04,940 --> 00:05:08,910
>> હવે નોટિસ, વેપાર હોય તેમ બનશે
માપ વચ્ચે બોલ તમારા

91
00:05:08,910 --> 00:05:11,280
હેશ કોષ્ટક અને કદ
તમારી સાથે લિંક યાદીઓ.

92
00:05:11,280 --> 00:05:15,640
તમે એક ખરેખર મોટો આંકડો છે
ડોલથી પાછા રન કર્યા કલ્પના

93
00:05:15,640 --> 00:05:18,230
અને આગળ માટે એક લીટી માં
તમારા ડોલ શોધો.

94
00:05:18,230 --> 00:05:21,530
પરંતુ તમે પણ નાની સંખ્યામાં નહિં માંગો
ડોલથી છે, તો પછી અમે પાછા છો કારણ કે

95
00:05:21,530 --> 00:05:26,850
કર્યા કેવી રીતે મૂળ સમસ્યા
અમારા ડોલમાં ઘણા બોલમાં.

96
00:05:26,850 --> 00:05:30,480
>> ઠીક છે, પરંતુ જ્યાં અમારી બોલ લે છે?

97
00:05:30,480 --> 00:05:33,150
વેલ, અમે પ્રથમ જરૂર
હક, એક બોલ છે?

98
00:05:33,150 --> 00:05:39,130
તેથી આપણે દરેક માટે નોડ malloc દો
અમે કે જે નવો શબ્દ.

99
00:05:39,130 --> 00:05:42,900
નોડ * new_node સમકક્ષ
malloc (sizeof (નોડ)).

100
00:05:42,900 --> 00:05:46,760
>> અમે આ માળખું છે હવે, અમે
કાર્ય ઉપયોગ કરીને માં સ્કેન કરી શકે છે

101
00:05:46,760 --> 00:05:51,850
fscanf અમારા ફાઇલમાંથી શબ્દમાળા, જો
કે માં, શબ્દકોશ ફાઈલ છે

102
00:05:51,850 --> 00:05:55,780
new_node તીર શબ્દ, જ્યાં new_node
તીર શબ્દ અમારા છે

103
00:05:55,780 --> 00:05:58,110
કે શબ્દ સ્થળ.

104
00:05:58,110 --> 00:06:01,900
>> પછી, આપણે કે હેશ માંગો છો પડશે
હેશ વિધેય મદદથી શબ્દ.

105
00:06:01,900 --> 00:06:05,860
એક હેશ વિધેય શબ્દમાળા લે
અને ઇન્ડેક્સ આપે છે.

106
00:06:05,860 --> 00:06:09,760
આ કિસ્સામાં, ઇન્ડેક્સ છે
સંખ્યા કરતાં ઓછી હોય

107
00:06:09,760 --> 00:06:11,440
કે તમારી પાસે ડોલથી.

108
00:06:11,440 --> 00:06:14,600
>> હવે, જટિલ કાર્ય, તમે પ્રયાસ કરી રહ્યા છો ત્યારે
એક શોધવા અને એક બનાવવા માટે

109
00:06:14,600 --> 00:06:17,890
તમારી પોતાની, યાદ છે કે તેઓ
નિર્ધારિત હોય છે.

110
00:06:17,890 --> 00:06:22,420
તે જ કિંમત માટે જરૂર અર્થ એ થાય કે
એ જ ડોલ માટે દર વખતે નકશો

111
00:06:22,420 --> 00:06:23,800
તમે તેને હેશ છે.

112
00:06:23,800 --> 00:06:25,300
>> તે પ્રકારની એક લાઈબ્રેરી જેવું છે.

113
00:06:25,300 --> 00:06:28,560
તમે પર આધારિત એક પુસ્તક, લો, યારે
લેખક, તમે જાણો છો કે જે શેલ્ફ તે જોઈએ

114
00:06:28,560 --> 00:06:31,890
તે છાજલી નંબર શું, પર જાઓ
એક, બે, કે ત્રણ.

115
00:06:31,890 --> 00:06:36,280
અને તે પુસ્તક હંમેશા પર સંબંધ હશે
શેલ્ફ એક, બે, કે ત્રણ ક્યાં.

116
00:06:36,280 --> 00:06:39,460

117
00:06:39,460 --> 00:06:43,810
>> તેથી, જો new_node તીર શબ્દ છે
તમારી શબ્દકોશ થી શબ્દ, તો પછી

118
00:06:43,810 --> 00:06:47,770
હેશીંગ new_node તીર શબ્દ કરશે
ચાલો ઇન્ડેક્સ આપી

119
00:06:47,770 --> 00:06:49,370
હેશ ટેબલ ડોલ.

120
00:06:49,370 --> 00:06:54,040
અને પછી અમે તે માં કે સામેલ કરીશું
આ દ્વારા સૂચવાયેલ ચોક્કસ કડી થયેલ યાદી

121
00:06:54,040 --> 00:06:56,060
અમારા હેશ વિધેય ની કિંમત આવો.

122
00:06:56,060 --> 00:06:59,070
>> માતાનો એક ઉદાહરણ જુઓ
આ એક નોડ દાખલ

123
00:06:59,070 --> 00:07:01,750
એક કડી થયેલ યાદી કરે છે.

124
00:07:01,750 --> 00:07:06,930
વડા સૂચવે છે કે નોડ નિર્દેશક છે
એક કડી થયેલ શરૂઆત

125
00:07:06,930 --> 00:07:12,420
યાદી અને new_node નવા સૂચવે
તમે માત્ર માં દાખલ કરવા માંગો છો તે નોડ

126
00:07:12,420 --> 00:07:17,340
new_node માટે વડા સોંપણી ગુમાવશે
યાદી બાકીના લિંક.

127
00:07:17,340 --> 00:07:19,330
તેથી અમે આ કરવા નથી માંગતા.

128
00:07:19,330 --> 00:07:22,160
>> એના બદલે, આપણે ખાતરી કરવા માંગો છો
અમે દરેક ને પકડી કે

129
00:07:22,160 --> 00:07:23,550
અમારા કાર્યક્રમ એક નોડ.

130
00:07:23,550 --> 00:07:29,560
તેથી ચાલી new_node તીર આગામી સમકક્ષ
માથા અને પછી માથા new_node સમકક્ષ હોય છે

131
00:07:29,560 --> 00:07:34,470
આ તમામ સાચવશે
કડીઓ અને કોઈપણ ગુમાવી નથી.

132
00:07:34,470 --> 00:07:39,330
>> પરંતુ તમે તમારા યાદી હોય શું માંગો છો
એક અલગ પાડવામાં કડી થયેલ કર્યા છે, કારણ કે છટણી

133
00:07:39,330 --> 00:07:42,910
યાદી માટે સરળ હોઈ શકે છે
પાછળથી તે શોધી રહ્યા છો?

134
00:07:42,910 --> 00:07:46,020
વેલ, આ માટે, તમે જાણવા જરૂર પડશે
કેવી રીતે કડી થયેલ યાદી પસાર.

135
00:07:46,020 --> 00:07:51,210
>> એક કડી થયેલ યાદી પસાર કરવા માટે, ચાલો હોય
તરીકે કાર્ય કરવા માટે નોડ નિર્દેશક, નોડ *,

136
00:07:51,210 --> 00:07:54,120
સૂચવે તમારા કર્સર, જે
તમે શરૂ કરીને, પર છો નોડ

137
00:07:54,120 --> 00:07:55,460
પ્રથમ તત્વ છે.

138
00:07:55,460 --> 00:08:01,070
કર્સર સુધી રહ્યાં અમે કરી શકો છો, નલ છે
પછી ચોક્કસ પ્રક્રિયાઓ અને લેવા

139
00:08:01,070 --> 00:08:04,330
અમે જરૂર જ્યારે કર્સર આગળ
કર્સર તીર કિંમત મદદથી.

140
00:08:04,330 --> 00:08:08,820
>> યાદ રાખો, આ બરાબર જ છે
સંદર્ભ કર્યા વગર, સ્ટાર કર્સર કહેતા

141
00:08:08,820 --> 00:08:13,480
પછી ઉપયોગ કરીને કર્સર એ
કોઈ ઓપરેટર મૂલ્ય.

142
00:08:13,480 --> 00:08:19,000
તેથી આઈડી કર્સર છે અપડેટ
આગામી કર્સર તીર પર કર્સર.

143
00:08:19,000 --> 00:08:24,960
>> તમે ડી માં બની જાય છે તે નક્કી કહો
સી અને ઇ નોડ દાખલ કરવા વચ્ચે,

144
00:08:24,960 --> 00:08:30,030
આ માટે new_node ડી બિંદુ છે
આગામી કર્સર કે જે નોડ ઇ,.

145
00:08:30,030 --> 00:08:36,409
અને પછી સી માં, કર્સર, તો પછી નિર્દેશ કરી શકો છો
ડી આ રીતે કરવા માટે, તમારે યાદી જાળવી રાખે છે.

146
00:08:36,409 --> 00:08:41,080
દ્વારા તમારા કડીઓ ગુમાવી ખૂબ કાળજી રાખો
આગામી ડી કરવા માટે, કર્સરને તીર ખસેડવા

147
00:08:41,080 --> 00:08:43,929
સીધા.

148
00:08:43,929 --> 00:08:44,620
>> અધિકાર છે.

149
00:08:44,620 --> 00:08:48,920
જેથી, તમે ગાંઠો દાખલ કરી શકે છે
તે માં, લોડ શબ્દો તેમને લોડ

150
00:08:48,920 --> 00:08:51,600
ગાંઠો છે, અને તેમને સામેલ
તમારા હેશ કોષ્ટક માં.

151
00:08:51,600 --> 00:08:53,580
તેથી હવે આપણે પ્રયાસ કરે છે જુઓ.

152
00:08:53,580 --> 00:08:58,540
>> એક trie, દરેક નોડ એક સમાવશે
નોડ પોઇન્ટર, દરેક માટે એક એરે

153
00:08:58,540 --> 00:09:02,260
મૂળાક્ષરમાં અક્ષર
વત્તા એપોસ્ટ્રોફી.

154
00:09:02,260 --> 00:09:06,150
અને એરે દરેક તત્વ
અન્ય નોડ માટે નિર્દેશ કરશે.

155
00:09:06,150 --> 00:09:10,130
કે નોડ નલ, પછી તે અક્ષર છે
આગામી પત્ર નથી ચાલી રહ્યું છે

156
00:09:10,130 --> 00:09:15,690
ક્રમ કોઈપણ શબ્દ, કારણ કે દરેક
શબ્દ તે છેલ્લા છે સૂચવે છે કે શું

157
00:09:15,690 --> 00:09:18,160
એક શબ્દ નથી અથવા ના પાત્ર.

158
00:09:18,160 --> 00:09:19,750
>> ચાલો એક રેખાકૃતિ જુઓ.

159
00:09:19,750 --> 00:09:22,260
આસ્થાપૂર્વક વસ્તુઓ કરશે
થોડી સ્પષ્ટ છે.

160
00:09:22,260 --> 00:09:27,210
આ આકૃતિ માં, અમે જુઓ કે માત્ર
અમુક અક્ષરો અને ચોક્કસ substrings

161
00:09:27,210 --> 00:09:28,190
બહાર યાદી થયેલ કરવામાં આવી રહી છે.

162
00:09:28,190 --> 00:09:32,500
તેથી જો તમે ચોક્કસ પાથ અનુસરી શકે છે, અને
તે પાથ તમામ પર લઈ જવામાં આવશે

163
00:09:32,500 --> 00:09:34,020
વિવિધ શબ્દો.

164
00:09:34,020 --> 00:09:37,630
>> તેથી અમે કેવી રીતે સી માં આ રજૂ કરે છે?

165
00:09:37,630 --> 00:09:41,910
વેલ, દરેક નોડ હવે હોય રહ્યું છે
સૂચવે છે કે શું બુલિયન કિંમત

166
00:09:41,910 --> 00:09:46,580
કે નોડ અંત છે
આપેલ શબ્દ અથવા નથી.

167
00:09:46,580 --> 00:09:50,690
અને પછી તે પણ દર્શાવે છે પડશે
નોડ બાળકો કહેવાય પોઇન્ટર, અને

168
00:09:50,690 --> 00:09:53,440
તેમને 27 હોઈ જતા હોય છે.

169
00:09:53,440 --> 00:09:56,510
અને તમે પણ કરવા માંગો છો પડશે, યાદ
તમારા પ્રથમ નોડ સાચવી રાખે.

170
00:09:56,510 --> 00:09:59,830
અમે તે રુટ કહી રહ્યા છીએ.

171
00:09:59,830 --> 00:10:01,690
>> જેથી એક trie બંધારણ છે.

172
00:10:01,690 --> 00:10:05,630
આપણે કઈ રીતે આ રજૂ કરે છે
એક શબ્દકોશ?

173
00:10:05,630 --> 00:10:09,890
વેલ, દરેક માટે, શબ્દો લાવવા માટે
શબ્દકોશ શબ્દ, તમે કરવા માંગો છો રહ્યા છીએ

174
00:10:09,890 --> 00:10:11,960
આ trie દ્વારા ભારપૂર્વક કહેવું છે.

175
00:10:11,960 --> 00:10:16,170
અને બાળકો દરેક તત્વ
અલગ અક્ષર અનુલક્ષે છે.

176
00:10:16,170 --> 00:10:21,660
>> તેથી બાળકોને કિંમત ચકાસણી
હું રજૂ જ્યાં ઇન્ડેક્સ હું

177
00:10:21,660 --> 00:10:24,840
પત્ર ચોક્કસ ઇન્ડેક્સ કે
તમે દાખલ કરવા માટે પ્રયાસ કરી રહ્યા છો.

178
00:10:24,840 --> 00:10:28,980
વેલ, જો તે નલ, પછી તમે કરવા માંગો છો પડશે
નવી નોડ malloc અને બાળકો હોય

179
00:10:28,980 --> 00:10:31,110
હું કે જે નોડ માટે નિર્દેશ કરે છે.

180
00:10:31,110 --> 00:10:35,630
>> તે નલ નથી, તો પછી તે અર્થ એ થાય કે
આપેલ છે કે શાખા છે, કે જે આપેલ

181
00:10:35,630 --> 00:10:37,350
રહેલ વાક્ય, પહેલેથી જ અસ્તિત્વમાં છે.

182
00:10:37,350 --> 00:10:40,160
તેથી પછી તમે તે જ ખસેડવા પડશે
નવા નોડ અને ચાલુ રાખો.

183
00:10:40,160 --> 00:10:43,220
તમે આ શબ્દ ઓવરને અંતે છો કે
તમે માં લાવવા માટે પ્રયાસ કરી રહ્યા છો

184
00:10:43,220 --> 00:10:48,120
શબ્દકોશ, તો પછી તમે તે સેટ કરી શકો છો
તમે ખરા છો કે વર્તમાન નોડ.

185
00:10:48,120 --> 00:10:51,550
>> તેથી આપણે દાખલ એક ઉદાહરણ જુઓ
માં શબ્દ "ફોક્સ" અમારી

186
00:10:51,550 --> 00:10:53,070
આપનું સ્વાગત છે.

187
00:10:53,070 --> 00:10:56,110
અમે સાથે શરૂ ડોળ કરવો
ખાલી શબ્દકોશ.

188
00:10:56,110 --> 00:11:01,610
પ્રથમ પત્ર, એફ, સ્થિત થયેલ આવશે
બાળકો ઈન્ડેક્સમાં મૂળ પાંચ

189
00:11:01,610 --> 00:11:03,700
બાળકો પણ દર્શાવે છે.

190
00:11:03,700 --> 00:11:05,430
તેથી અમે સાઇન કે દાખલ

191
00:11:05,430 --> 00:11:14,610
>> આ પત્ર ઓ પછી બાળકો હશે
પછી તે એફ પછી ઇન્ડેક્સ 15, અને એક્સ

192
00:11:14,610 --> 00:11:20,180
શાખા, પણ છે કે જે કરતાં ઓછો છે
પાંચ કંઈપણ બાળકો નહીં.

193
00:11:20,180 --> 00:11:24,120
અને પછી એક્સ છેલ્લા અક્ષર છે, કારણ કે
જો શબ્દના આ "ફોક્સ" પછી હું જાઉં છું

194
00:11:24,120 --> 00:11:27,210
સૂચવે છે કે રંગ લીલો કે
તે શબ્દ ઓવરને છે.

195
00:11:27,210 --> 00:11:32,880
સી, કે છે સુયોજિત કરવામાં આવશે
શબ્દ સાચી કિંમત બુલિયન.

196
00:11:32,880 --> 00:11:36,780
>> હવે જો તમે કે આગામી શબ્દ
માં લોડ શબ્દ "foo 'શું છે?

197
00:11:36,780 --> 00:11:41,490
વેલ, તમે વધુ malloc જરૂર નથી
એફ માટે અથવા કંઈપણ માટે જગ્યા છે, કારણ કે

198
00:11:41,490 --> 00:11:42,990
તે પહેલેથી જ અસ્તિત્વ ધરાવે છે.

199
00:11:42,990 --> 00:11:45,910
પરંતુ foo છેલ્લા કંઈપણ?

200
00:11:45,910 --> 00:11:47,320
કે એક, તમે malloc પડશે.

201
00:11:47,320 --> 00:11:52,390
સુયોજિત છે, તે માટે એક નવી નોડ કરો
સાચું ના છે શબ્દ બુલિયન.

202
00:11:52,390 --> 00:11:57,340
>> તેથી હવે આપણે દાખલ કરો "ડોગ." ડોગ કરશે
મૂળ ની અનુક્રમણિકા ત્રણ સાથે શરૂ

203
00:11:57,340 --> 00:12:00,520
બાળકો, ડી નથી કારણ કે
હજુ સુધી બનાવવામાં આવ્યું.

204
00:12:00,520 --> 00:12:04,990
અને અમે એ જ પ્રક્રિયા તરીકે અનુસરો પડશે
પહેલાં, રહેલ વાક્ય કૂતરો બનાવવા માટે,

205
00:12:04,990 --> 00:12:10,400
જ્યાં જી લીલા કારણ કે રંગીન છે
કે શબ્દ ઓવરને છે.

206
00:12:10,400 --> 00:12:13,160
>> હવે, આપણે "કરી" દાખલ કરવા શું માંગો છો?

207
00:12:13,160 --> 00:12:17,150
વેલ, આ કૂતરો એક રહેલ વાક્ય છે, તેથી
અમે હવે malloc કરવાની જરૂર નથી.

208
00:12:17,150 --> 00:12:20,800
પરંતુ અમે અમે કર્યું છે તે દર્શાવવા માટે જરૂરી છે
કે શબ્દ ઓવરને પહોંચી ગયા છે.

209
00:12:20,800 --> 00:12:24,020
તેથી કંઈપણ લીલા રંગના કરવામાં આવશે.

210
00:12:24,020 --> 00:12:27,810
દરેક એક માટે તે પ્રક્રિયા ચાલુ રાખી રહ્યા છે
તમારા શબ્દકોશમાં શબ્દ, તમે કરેલા

211
00:12:27,810 --> 00:12:32,120
ક્યાં તો તમારી માં તેમને લોડ
કોષ્ટક અથવા તમારા trie હેશ.

212
00:12:32,120 --> 00:12:37,530
>> speller.c માટે શબ્દમાળાઓ માં પસાર કરશે
તેમને ચેક કરો dictionary.c.

213
00:12:37,530 --> 00:12:41,140
હવે, ચેક વિધેયને યોગ્ય રીતે કામ કરવા માટે છે
કેસ સંવેદનશૂન્યતાની હેઠળ.

214
00:12:41,140 --> 00:12:45,980
તે અર્થ એ થાય કે મોટા અક્ષરોમાં અને
નાના અક્ષરો અને બંને મિશ્રણ

215
00:12:45,980 --> 00:12:50,670
બધા ખરા તરીકે સમાન છે જોઈએ જો કોઈ હોય તો
કે મિશ્રણ છે

216
00:12:50,670 --> 00:12:51,880
આપનું સ્વાગત છે.

217
00:12:51,880 --> 00:12:55,580
તમે પણ શબ્દમાળાઓ છે કે ધારણ કરી શકે છે
માત્ર અંગ્રેજી સમાવી રહ્યું

218
00:12:55,580 --> 00:12:58,200
અક્ષરો અથવા apostrophes.

219
00:12:58,200 --> 00:13:02,490
>> તેથી આપણે તમે ચકાસી શકે છે કેવી રીતે જુઓ
હેશ કોષ્ટક બંધારણ સાથે.

220
00:13:02,490 --> 00:13:07,330
વેલ, શબ્દ જ હોય, તો તે
હેશ ટેબલ માં શોધી શકાય છે.

221
00:13:07,330 --> 00:13:12,240
તેથી પછી તમે તે શોધવા માટે પ્રયાસ કરી શકો છો
સંબંધિત ડોલમાં શબ્દ.

222
00:13:12,240 --> 00:13:14,480
>> તેથી જે ડોલ કે બોલવામાં હશે?

223
00:13:14,480 --> 00:13:20,060
સારું, તમે આ નંબર છે, કે ઇન્ડેક્સ મેળવવા માગો છો
બાલદી, કે શબ્દ હેશીંગ દ્વારા

224
00:13:20,060 --> 00:13:23,690
અને પછી તે યાદીની લિંક શોધ,
સમગ્ર મારફતે સરકાઉ

225
00:13:23,690 --> 00:13:28,060
આ શબ્દમાળા મદદથી સંલગ્ન યાદી,
કાર્ય કરો.

226
00:13:28,060 --> 00:13:31,940
>> યાદીની લિંક ઓવરને છે
જેનો અર્થ થાય છે, પહોંચી કે તમારા કર્સરને

227
00:13:31,940 --> 00:13:36,030
નલ પહોંચે, પછી શબ્દ નથી
શબ્દકોશમાંનાં જોવા મળે છે.

228
00:13:36,030 --> 00:13:39,090
તે કોઇ પણ અન્ય ડોલમાં નહીં.

229
00:13:39,090 --> 00:13:43,020
અહીં, તમે ત્યાં કદાચ જુઓ કે કેવી રીતે કરી શકે છે
ક્યાં કર્યા વચ્ચે મડાગાંઠ કરી

230
00:13:43,020 --> 00:13:46,280
છટણી સંલગ્ન યાદીઓ અથવા ક્રમમાંગોઠવાયેલનથી મુદ્દાઓ પર પણ.

231
00:13:46,280 --> 00:13:51,180
ક્યાં દરમિયાન વધુ સમય લેશે
તપાસ દરમિયાન સમય લોડ અથવા વધુ.

232
00:13:51,180 --> 00:13:53,560
>> તમે કેવી રીતે તપાસ કરી શકે છે
એક trie માળખું?

233
00:13:53,560 --> 00:13:56,370
અમે નીચે મુસાફરી રહ્યા છીએ
આ trie માં.

234
00:13:56,370 --> 00:14:00,390
આ ઇનપુટ શબ્દ દરેક અક્ષર માટે
અમે ચકાસણી કરી રહ્યા છીએ કે, અમે તે જઈશ

235
00:14:00,390 --> 00:14:03,280
બાળકો માં તત્વ અનુલક્ષીને.

236
00:14:03,280 --> 00:14:07,770
>> તે તત્વ નલ છે, પછી તે અર્થ
કોઈ substrings છે કે

237
00:14:07,770 --> 00:14:11,110
અમારા ઇનપુટ શબ્દ સમાવે છે, જેથી
જો શબ્દની જોડણી ખોટી છે.

238
00:14:11,110 --> 00:14:15,140
તે નલ નથી, અમે પર જઈ શકે છે
અમે છો જો શબ્દના આ આગામી પત્ર

239
00:14:15,140 --> 00:14:18,850
આ પ્રક્રિયા ચકાસણી અને ચાલુ
અમે ઓવરને પહોંચે ત્યાં સુધી

240
00:14:18,850 --> 00:14:20,350
ઇનપુટ શબ્દના.

241
00:14:20,350 --> 00:14:23,330
અને પછી અમે તપાસ કરી શકે છે
છે શબ્દ સાચી હોય.

242
00:14:23,330 --> 00:14:24,610
તે પછી મહાન છે.

243
00:14:24,610 --> 00:14:25,590
આ શબ્દ સુધારવા છે.

244
00:14:25,590 --> 00:14:30,890
પરંતુ જો નહિં, છતાં પણ કે રહેલ વાક્ય
આ trie અસ્તિત્વ ધરાવે છે, શબ્દ છે

245
00:14:30,890 --> 00:14:32,250
જોડણી ખોટી.

246
00:14:32,250 --> 00:14:36,590
>> કાર્ય માપ તરીકે ઓળખાય છે, ત્યારે માપ
શબ્દોની સંખ્યા પરત કરીશું કે

247
00:14:36,590 --> 00:14:39,110
તમારા આપવામાં શબ્દકોશમાંનાં છે
માહિતી બંધારણ.

248
00:14:39,110 --> 00:14:42,780
તમે, તમે હેશ ટેબલ ઉપયોગ કરી રહ્યાં છો તેથી
દરેક એક મારફતે જાઓ શકે છે

249
00:14:42,780 --> 00:14:45,860
દરેક એક સાથે જોડાયેલા યાદી
ડોલ ગણતરી

250
00:14:45,860 --> 00:14:47,130
શબ્દો છે.

251
00:14:47,130 --> 00:14:49,940
તમે એક trie ઉપયોગ કરી રહ્યાં છો, તમે કરી શકો છો
દરેક બિન નલ મારફતે જાઓ

252
00:14:49,940 --> 00:14:52,030
તમારા trie માં પાથ.

253
00:14:52,030 --> 00:14:56,420
અથવા તમે શબ્દકોશમાં લોડ કરી રહ્યાં છે, જ્યારે
માં, કદાચ તમે કેવી રીતે રાખી શકાય

254
00:14:56,420 --> 00:14:58,760
તમે સાઇન લોડ કરી રહ્યા છીએ ઘણા શબ્દો

255
00:14:58,760 --> 00:15:03,180
>> Speller.c ચકાસણી સમાપ્ત એકવાર
શબ્દકોશમાં સામે લખાણ ફાઈલ છે, તો પછી

256
00:15:03,180 --> 00:15:08,010
તે થાય અને તેથી તે, અનલોડ કહે છે જ્યાં
તમારી નોકરી કંઈપણ મફત છે

257
00:15:08,010 --> 00:15:09,500
તમે malloced કરેલો.

258
00:15:09,500 --> 00:15:14,420
પછી તમે હેશ ટેબલ ઉપયોગ તેથી જો
ટાળવા માટે ખાસ કરીને કાળજી રાખો જરૂર છે

259
00:15:14,420 --> 00:15:18,830
કંઈપણ મુક્ત કરીને ન મેમરી લીક્સ
અકાળે અને દરેક પર હોલ્ડિંગ

260
00:15:18,830 --> 00:15:20,780
જો તમારી પાસે મુક્ત પહેલાં એક કડી.

261
00:15:20,780 --> 00:15:24,680

262
00:15:24,680 --> 00:15:30,100
>> તેથી હેશ કોષ્ટક દરેક તત્વ તરીકે
અને કડી થયેલ યાદીમાં દરેક નોડ માટે,

263
00:15:30,100 --> 00:15:32,370
તમે કે નોડ મુક્ત કરવા માંગો છો પડશે.

264
00:15:32,370 --> 00:15:34,970
તમે કેવી રીતે મુક્ત કરીને જઈ નથી
એક કડી થયેલ યાદી?

265
00:15:34,970 --> 00:15:38,570
તમારા નોડ નિર્દેશક કર્સર માટે સુયોજિત કરી રહ્યા છે
આ શરૂઆત કરવા માટે હેડ,

266
00:15:38,570 --> 00:15:43,100
સંલગ્ન યાદી, તો પછી તમારા કર્સરને જ્યારે
નલ નથી, તો તમે કામચલાઉ સેટ કરી શકો છો

267
00:15:43,100 --> 00:15:45,610
તમારા કર્સર નોડ નિર્દેશક.

268
00:15:45,610 --> 00:15:48,370
પછી કર્સર આગળ.

269
00:15:48,370 --> 00:15:52,950
અને પછી તમે તે કામચલાઉ મુક્ત કરી શકો છો
કિંમત, જ્યારે હજુ પણ પર હોલ્ડિંગ

270
00:15:52,950 --> 00:15:55,650
પછીથી બધું.

271
00:15:55,650 --> 00:15:57,800
>> શું તમે એક trie ઉપયોગ કરી રહ્યાં છો?

272
00:15:57,800 --> 00:16:00,410
પછી આ કામ કરવા માટે શ્રેષ્ઠ માર્ગ
ખૂબ જ થી અનલોડ છે

273
00:16:00,410 --> 00:16:02,290
ટોચ પર નીચે.

274
00:16:02,290 --> 00:16:06,920
સૌથી નીચો શક્ય પ્રવાસ દ્વારા
નોડ, તમે તમામ પોઇન્ટર મુક્ત કરી શકો છો

275
00:16:06,920 --> 00:16:11,430
કે પછી બાળકો અને backtrack
ઉપર, એકંદરે તત્વો મુક્ત કરીને

276
00:16:11,430 --> 00:16:15,610
બાળકો એરે, ત્યાં સુધી
તમે તમારા ટોચ રુટ નોડ નહીં.

277
00:16:15,610 --> 00:16:18,920
અહીં જ્યાં રિકર્ઝન
હાથમાં આવશે.

278
00:16:18,920 --> 00:16:22,780
>> ખાતરી કરો કે તમે કદાચ મુક્ત કર્યા છે કે બનાવવા માટે
તમે malloced છે કે બધું,

279
00:16:22,780 --> 00:16:24,400
તમે Valgrind વાપરી શકો છો.

280
00:16:24,400 --> 00:16:28,640
Valgrind ચાલી રહેલ તમારા કાર્યક્રમ ચાલશે
મેમરી કેટલા બાઇટ્સ ગણતરી

281
00:16:28,640 --> 00:16:32,440
તમે ઉપયોગ કરી અને તમે કરેલા ખાતરી કરો કે કરી રહ્યા છીએ
તમને કઈ, તેમને બધા મુક્ત

282
00:16:32,440 --> 00:16:34,530
તમારી પાસે શકે છે
મફત માટે ભૂલી.

283
00:16:34,530 --> 00:16:38,390
Valgrind તમને કહે છે એક વાર જેથી ચલાવો અને
અને તમે પછી, આગળ વધો આપે

284
00:16:38,390 --> 00:16:41,160
તમે અનલોડ પૂર્ણ કરી.

285
00:16:41,160 --> 00:16:44,420
>> હવે, તમે ટિપ્સ એક દંપતી જાઓ તે પહેલા
બંધ અને અમલીકરણ શરૂ તમારા

286
00:16:44,420 --> 00:16:46,260
આપનું સ્વાગત છે.

287
00:16:46,260 --> 00:16:49,650
હું એક નાની પાસ ભલામણ છો
તમે ચકાસવા માટે પ્રયાસ કરી રહ્યા છો ત્યારે શબ્દકોશ

288
00:16:49,650 --> 00:16:52,620
જીડીપી સાથે વસ્તુઓ બહાર અને ડિબગીંગ.

289
00:16:52,620 --> 00:16:58,550
સ્પેલર ની વપરાશ છે. / સ્પેલર, એક
વૈકલ્પિક શબ્દકોશ અને પછી લખાણ.

290
00:16:58,550 --> 00:17:01,550
>> મૂળભૂત રીતે, તેને લોડ કરે છે
મોટા શબ્દકોશ.

291
00:17:01,550 --> 00:17:06,670
તેથી તમે નાના પાસ શકો છો
શબ્દકોશ, અથવા કદાચ પણ કરી તમારા

292
00:17:06,670 --> 00:17:11,819
પોતાના, કસ્ટમાઇઝ તમારી શબ્દકોશ
અને તમારા લખાણ ફાઈલ.

293
00:17:11,819 --> 00:17:15,950
>> અને પછી છેવટે હું પણ ભલામણ છો
એક પેન અને કાગળ લો અને ડ્રો

294
00:17:15,950 --> 00:17:20,490
વસ્તુઓ બહાર તે પહેલાં, દરમ્યાન અને પછી
તમે તમારો કોડ તમામ તેવા પરચૂરણ ખર્ચ કર્યો.

295
00:17:20,490 --> 00:17:24,170
ફક્ત તમે મળી છે કે નહીં તેની ખાતરી
તે પોઇન્ટર માત્ર અધિકાર.

296
00:17:24,170 --> 00:17:26,480
>> હું તમને નસીબ શ્રેષ્ઠ માંગો છો.

297
00:17:26,480 --> 00:17:29,690
અને તમે પૂર્ણ કરી જાય, જો તમે ઇચ્છો
મોટા બોર્ડ અને પડકાર

298
00:17:29,690 --> 00:17:34,390
તમારા કાર્યક્રમ સાથે સરખાવવામાં આવે છે કેવી રીતે ઝડપી જુઓ
તમારા સહપાઠીઓને ', પછી હું પ્રોત્સાહિત

299
00:17:34,390 --> 00:17:35,960
તમે તે તપાસો.

300
00:17:35,960 --> 00:17:39,220
>> સાથે, તમે પૂર્ણ કરી
પાંચ સ્પેલર PSet.

301
00:17:39,220 --> 00:17:41,800
મારું નામ Zamyla છે, અને આ CS50 છે.

302
00:17:41,800 --> 00:17:49,504