1
00:00:00,000 --> 00:00:02,520
[Powered by Google Translate] [6 અઠવાડિયું ચાલુ રાખ્યું,]

2
00:00:02,520 --> 00:00:04,160
[ડેવિડ જે Malan] [હાર્વર્ડ યુનિવર્સિટી]

3
00:00:04,160 --> 00:00:08,720
[આ CS50 છે.] [CS50.TV]

4
00:00:08,720 --> 00:00:12,970
આ CS50 છે અને આ 6 અઠવાડિયાના અંત છે.

5
00:00:12,970 --> 00:00:17,970
તેથી CS50x એક હાર્વર્ડ પ્રથમ edX પહેલ સામેલ અભ્યાસક્રમો

6
00:00:17,970 --> 00:00:20,590
ખરેખર આ ભૂતકાળમાં સોમવાર હતું.

7
00:00:20,590 --> 00:00:23,460
જો તમે ઇન્ટરનેટ પર શું અન્ય એક ઝલક મેળવવા ઈચ્છો છો

8
00:00:23,460 --> 00:00:27,180
હવે સાથે પગલે, તમે x.cs50.net માટે વડા કરી શકે છે.

9
00:00:27,180 --> 00:00:30,350
કે તમે edx.org પર યોગ્ય જગ્યાએ પુનઃદિશામાન થશે,

10
00:00:30,350 --> 00:00:34,160
જે જ્યાં આ અને એમઆઇટી અને ફ્રોમ બર્કલી અન્ય અભ્યાસક્રમો હવે રહે છે.

11
00:00:34,160 --> 00:00:38,140
તમે એક એકાઉન્ટ માટે સાઇન અપ પડશે; તમને કે માલ મોટાભાગે સમાન

12
00:00:38,140 --> 00:00:42,170
જેમ તમે આ સત્ર પડ્યું, થોડા વિલંબ અઠવાડિયા જોકે, આપણે બધું તૈયાર મળે છે.

13
00:00:42,170 --> 00:00:46,930
પરંતુ CS50x વિદ્યાર્થીઓ હવે જોવા મળશે શું આ એક જેવું એક ઈન્ટરફેસ છે.

14
00:00:46,930 --> 00:00:50,040
આ ઉદાહરણ તરીકે, સમસ્યા 0 સમૂહ માટે walkthrough અગ્રણી Zamyla છે.

15
00:00:50,040 --> 00:00:54,230
Edx.org માં પ્રવેશ કરવા પર, એક CS50x વિદ્યાર્થી વસ્તુઓના પ્રકારની જુએ છે

16
00:00:54,230 --> 00:00:57,170
તમે કોર્સમાં જુઓ અપેક્ષા કરશે: સોમવાર માટે વ્યાખ્યાન,

17
00:00:57,170 --> 00:01:01,650
બુધવાર, વિવિધ શોર્ટ્સ, સમસ્યા સમૂહો છે, વૉકથ્રૂઝ, પીડીએફ માટે વ્યાખ્યાન.

18
00:01:01,650 --> 00:01:04,459
વધુમાં, તમે અહીં જુઓ, મશીન અનુવાદ

19
00:01:04,459 --> 00:01:08,390
ચિની, જાપાની, સ્પેનિશ, ઇટાલિયન માં ઇંગલિશ લખાણ હોય,

20
00:01:08,390 --> 00:01:12,810
અને અન્ય ભાષાઓ સંપૂર્ણ સમૂહ છે કે જે ચોક્કસપણે અપૂર્ણ હશે

21
00:01:12,810 --> 00:01:15,840
અમે તેમને રોલ આઉટ પ્રોગ્રામ એક API કહેવાય કંઈક વાપરી રહ્યા હોય,

22
00:01:15,840 --> 00:01:18,360
Google માંથી અથવા એપ્લિકેશન પ્રોગ્રામિંગ ઇન્ટરફેસ,

23
00:01:18,360 --> 00:01:21,360
કે અમને આ અન્ય ભાષાઓ માટે ઇંગલિશ કન્વર્ટ કરવા માટે પરવાનગી આપે છે.

24
00:01:21,360 --> 00:01:24,100
પરંતુ કેટલાક સો વત્તા સ્વયંસેવકો ની અદભૂત ભાવના માટે આભાર,

25
00:01:24,100 --> 00:01:26,940
ઇન્ટરનેટ પર રેન્ડમ લોકો માયાળુ માટે સામેલ ઓફર કરી છે

26
00:01:26,940 --> 00:01:30,180
આ પ્રોજેક્ટ માં, અમે ક્રમશઃ તે અનુવાદો ની ગુણવત્તા સુધારવા આવશે

27
00:01:30,180 --> 00:01:35,790
કર્યા માનવ ભૂલો કે જે અમારા કમ્પ્યુટર્સ આવેલ છે સુધારવા દ્વારા.

28
00:01:35,790 --> 00:01:42,330
>> તેથી તે વળે બહાર અમે થોડા વધુ વિદ્યાર્થીઓ સોમવારે હતો બતાવવા કરતાં અમે શરૂઆતમાં તેવી શક્યતા હતી.

29
00:01:42,330 --> 00:01:48,980
હકીકતમાં, હવે CS50x 100,000 ઘરમાં સાથે નીચેના લોકો છે.

30
00:01:48,980 --> 00:01:54,430
જેથી ખ્યાલ તમે તમામ ભાગ કોમ્પ્યુટર વિજ્ઞાન આ કોર્સ બનાવવા આ ઉદ્ઘાટન વર્ગ છે

31
00:01:54,430 --> 00:01:57,370
વધુ સામાન્ય શિક્ષણ, વધુ વિસ્તૃત રીતે, સુલભ.

32
00:01:57,370 --> 00:02:00,130
અને વાસ્તવિકતા હવે આ વ્યાપક ઑનલાઇન અભ્યાસક્રમો કેટલાક છે,

33
00:02:00,130 --> 00:02:04,070
તેઓ આ તમામ ખૂબ જ ઊંચી સંખ્યાના સાથે શરૂ કરવા માટે, કારણ કે અમે અહીં થાય છે એવું લાગે છે.

34
00:02:04,070 --> 00:02:08,759
પરંતુ ધ્યેય છે, છેવટે, CS50x માટે ખરેખર શક્ય તરીકે સમાપ્તિ રેખા પૂર્ણ કરવા માટે ઘણા લોકો છે.

35
00:02:08,759 --> 00:02:12,000
ડિઝાઇન દ્વારા, CS50x આ ભૂતકાળમાં સોમવારથી ઓફર કરી રહ્યું છે

36
00:02:12,000 --> 00:02:17,430
એપ્રિલ 15, 2013 દ્વારા તમામ માર્ગ છે, કે જેથી લોકો છે જેઓ શાળા ખાતરીઓ અન્યત્ર હોય છે,

37
00:02:17,430 --> 00:02:20,990
કામ, કુટુંબ, અન્ય તકરાર અને જેમ, થોડી વધુ ફ્લેક્સિબિલિટી હોય છે

38
00:02:20,990 --> 00:02:23,640
જેની સાથે આ અભ્યાસક્રમ માં ડાઇવ છે, કે જે, તે કહેવા માટે પૂરતો,

39
00:02:23,640 --> 00:02:30,540
છે તદ્દન પોતાની મહત્વકાંક્ષી થાય તો જ માત્ર એક સામાન્ય સત્ર દરમિયાન ત્રણ મહિના દરમિયાન.

40
00:02:30,540 --> 00:02:34,190
પરંતુ આ વિદ્યાર્થીઓ તે જ સમસ્યા સેટ ઉકેલ લાવવામાં આવશે, સમાન સામગ્રી જોઈ,

41
00:02:34,190 --> 00:02:36,350
એ જ શોર્ટ્સ અને તેના જેવા વપરાશ હોય છે.

42
00:02:36,350 --> 00:02:38,990
જેથી ખ્યાલ છે કે અમે આ સાથે મળીને બધી ખરેખર છે.

43
00:02:38,990 --> 00:02:42,360
અને એક CS50x ઓવરને ગોલ જેમ ઘણા લોકો વિચાર નથી

44
00:02:42,360 --> 00:02:45,720
સમાપ્તિ રેખા પૂર્ણ કરવા માટે અને તેમને કોમ્પ્યુટર વિજ્ઞાન આ મળેલી નવી સમજ આપી

45
00:02:45,720 --> 00:02:49,000
અને પણ પ્રોગ્રામિંગ માટે તેમને આ શેર અનુભવ ધરાવે છે.

46
00:02:49,000 --> 00:02:52,010
એક કેમ્પસ પર વ્યાખ્યાયિત 50 ના લક્ષણો, અમે આશા રાખીએ,

47
00:02:52,010 --> 00:02:56,260
છે કોમી અનુભવ આ પ્રકારની છે, અને વધુ સારા માટે અથવા ખરાબ માટે ક્યારેક,

48
00:02:56,260 --> 00:02:59,480
પરંતુ આ લોકો માટે ડાબી અને જમણી ચાલુ કરવા માટે હોય,

49
00:02:59,480 --> 00:03:01,830
અને ઓફિસ કલાકો અને hackathon અને વાજબી.

50
00:03:01,830 --> 00:03:04,560
તે થોડો કઠિન છે ઓનલાઈન લોકો સાથે વ્યક્તિ કે કરવા માટે,

51
00:03:04,560 --> 00:03:10,580
પરંતુ CS50x એપ્રિલ સૌપ્રથમ CS50 એક્સ્પો સાથે તારણ થશે,

52
00:03:10,580 --> 00:03:13,630
જે વાજબી અમારી વિચાર એક ઑનલાઇન અનુકૂલન હશે

53
00:03:13,630 --> 00:03:18,250
વિદ્યાર્થીઓ આ હજારો બધા જ્યાં માટે 1 એક સબમિટ કરવા આમંત્રિત કર્યા આવશે - 2-મિનિટની વિડિઓ માટે,

54
00:03:18,250 --> 00:03:22,480
અથવા તેમના અંતિમ અથવા તેમને પ્રોજેક્ટ વિડિઓ સ્ક્રીનકાસ્ટ હેલ્લો waving

55
00:03:22,480 --> 00:03:24,490
અને તેમના પ્રોજેક્ટ અંગે વાત છે અને તેને demoing,

56
00:03:24,490 --> 00:03:27,610
તમારા પૂરોગામી જેમ જ અહીં કેમ્પસ પર વાજબી થાય છે,

57
00:03:27,610 --> 00:03:31,400
જેથી સત્ર અંત સુધીમાં, આશા માટે એક વૈશ્વિક પ્રદર્શન હોય છે

58
00:03:31,400 --> 00:03:37,080
આ CS50x 'વિદ્યાર્થીઓ અંતિમ પ્રોજેક્ટ, કે જેવી જ છે જે તમે કેમ્પસ પર અહીં આ ડિસેમ્બર રાહ.

59
00:03:37,080 --> 00:03:39,680
તેથી આવવા મહિનામાં પર વધુ.

60
00:03:39,680 --> 00:03:43,640
>> 1,00,000 વિદ્યાર્થીઓ, જોકે, થોડા વધુ સીએએસ માટે જરૂરિયાત છે.

61
00:03:43,640 --> 00:03:47,590
આપેલ છે કે તમે ગાય્ઝ ટ્રેઇલના ઝળહળતું છે અહીં અને CS50 લેતી

62
00:03:47,590 --> 00:03:51,630
કેટલાંક અઠવાડિયા આ સામગ્રી edX પર જાણતા રિલીઝ અગાઉથી,

63
00:03:51,630 --> 00:03:55,330
સમજો અમે આ પહેલ માં શક્ય તેટલી આપણા પોતાના વિદ્યાર્થીઓને અનેક સમાવેશ ખુશી થશે,

64
00:03:55,330 --> 00:03:58,720
બંને તેમજ આ શિયાળામાં સત્ર દરમિયાન અને આ આવતા વસંત.

65
00:03:58,720 --> 00:04:01,620
તેથી જો તમે CS50x માં સામેલ કરવા માંગો છો,

66
00:04:01,620 --> 00:04:07,450
ખાસ કરીને CS50x ચર્ચા CS50 ચર્ચા ના edX આવૃત્તિ પર જોડાયા,

67
00:04:07,450 --> 00:04:10,140
જે તમને ઘણા કેમ્પસ પર ઉપયોગ કરીને, ઓનલાઈન બુલેટિન બોર્ડ,

68
00:04:10,140 --> 00:04:13,040
URL ને વડા કરવા કૃપા કરીને, અમને ખબર તમે કોણ છો,

69
00:04:13,040 --> 00:04:16,450
કારણ કે અમે સુધી વિદ્યાર્થીઓ અને સ્ટાફ એક ટીમ અને ફેકલ્ટી જેવું બિલ્ડ છો

70
00:04:16,450 --> 00:04:19,630
કેમ્પસ પર જે ફક્ત સાથે રમી રહ્યા છે અને બહાર મદદ કરે છે.

71
00:04:19,630 --> 00:04:21,720
અને જ્યારે તેઓ એક પ્રશ્ન છે કે તેમને પરિચિત છે જુઓ,

72
00:04:21,720 --> 00:04:25,320
તમે અમુક ભૂલ ક્યાંક બહાર ત્યાં ઇન્ટરનેટ પર કેટલાક દેશમાં જાણ વિદ્યાર્થી સાંભળવા,

73
00:04:25,320 --> 00:04:27,450
અને એક ઘંટડી રિંગ્સ કારણ કે તમે પણ એ જ સમસ્યા હતી

74
00:04:27,450 --> 00:04:32,620
તમારા-d હોલમાં પહેલા થોડો સમય, આસ્થાપૂર્વક પછી તમે સાંભળો અને તમારા પોતાના અનુભવ શેર કરી શકો છો.

75
00:04:32,620 --> 00:04:37,300
તેથી કૃપા કરીને લઇ જો તમે ઈચ્છો છો નથી.

76
00:04:37,300 --> 00:04:39,360
>> કમ્પ્યુટર હાર્વર્ડ ખાતે વિજ્ઞાન અભ્યાસક્રમો એક પરંપરા એક બીટ છે,

77
00:04:39,360 --> 00:04:44,730
તેમની વચ્ચે કેટલાક એપરલ, કેટલાક કપડાં છે, કે જે તમે ગર્વથી વસ્ત્રો કરી શકો છો હોવાની CS50,

78
00:04:44,730 --> 00:04:49,090
માતાનો સત્ર ઓવરને અંતે, તદ્દન ગર્વથી કહે છે કે તમે CS50 સમાપ્ત

79
00:04:49,090 --> 00:04:51,830
અને CS50 અને તેના જેવા લીધો હતો, અને અમે હંમેશા વિદ્યાર્થીઓ સમાવેશ કરવાનો પ્રયાસ કરો

80
00:04:51,830 --> 00:04:54,540
આ એટલું શક્ય છે, જેમાં અમે આમંત્રણ પ્રક્રિયામાં,

81
00:04:54,540 --> 00:04:56,900
આ સત્ર આ સમય આસપાસ, વિદ્યાર્થીઓ ડિઝાઇન સબમિટ કરવા માટે

82
00:04:56,900 --> 00:04:59,330
ફોટોશોપ મદદથી, અથવા પસંદગીના સાધન ગમે તમે ઉપયોગ કરવા માગો છો

83
00:04:59,330 --> 00:05:02,330
જો તમે એક ડિઝાઇનર કરશો, માટે ટી શર્ટ અને sweatshirts માટે ડિઝાઇન submit

84
00:05:02,330 --> 00:05:06,100
અને કૂતરા માટે અને છત્રી થોડું bandanas અમે હવે અને ગમે છે.

85
00:05:06,100 --> 00:05:09,370
અને બધું પછી છે - દરેક વર્ષ વિજેતાઓ પછી પ્રદર્શિત થાય છે

86
00:05:09,370 --> 00:05:12,700
store.cs50.net ખાતે અભ્યાસક્રમ વેબસાઇટ પર.

87
00:05:12,700 --> 00:05:15,790
બધું ત્યાં ખર્ચે વેચવામાં આવે છે, પરંતુ વેબસાઇટ માત્ર પોતે ચલાવે છે

88
00:05:15,790 --> 00:05:18,330
અને લોકો રંગો અને ડિઝાઇન કે તેઓ ગમે પસંદ કરવા માટે પરવાનગી આપે છે.

89
00:05:18,330 --> 00:05:20,420
તેથી મને લાગ્યું કે અમે હમણાં જ ગયા વર્ષના ડિઝાઇન કેટલાક શેર છો

90
00:05:20,420 --> 00:05:25,130
કે આ અહીં એક ઉપરાંત વેબસાઇટ પર હતી, જે વાર્ષિક પરંપરા છે.

91
00:05:25,130 --> 00:05:29,410
એક સબમિશન્સ "એવરી ડે હું Faultn Seg છું" છેલ્લા વર્ષ હતું,

92
00:05:29,410 --> 00:05:32,290
જે હજુ પણ સ્નાતકો માટે ત્યાં ઉપલબ્ધ છે.

93
00:05:32,290 --> 00:05:35,820
, અમે આ એક હતી "CS50, 1989 સ્થાપના."

94
00:05:35,820 --> 00:05:39,010
અમારા Bowdens એક, રોબ, ખૂબ લોકપ્રિય છેલ્લા વર્ષ હતું.

95
00:05:39,010 --> 00:05:43,480
"ટીમ બોડેન" જન્મ થયો, આ ડિઝાઇન, ટોચની વેચાણકર્તાઓ વચ્ચે કરવામાં આવી હતી.

96
00:05:43,480 --> 00:05:49,040
જેમ આ અહીં એક હતી. ઘણા લોકો વેચાણ લોગ અનુસાર "બોડેન ફીવર" હતા.

97
00:05:49,040 --> 00:05:52,650
સમજો કે જે હવે તમારા ડિઝાઈન ત્યાં હોઈ શકે, ઇન્ટરનેટ પર.

98
00:05:52,650 --> 00:05:57,510
આગામી સમસ્યા વધુ આ પર વિગતો આવવા સુયોજિત કરે છે.

99
00:05:57,510 --> 00:06:00,330
>> વધુ એક સાધન: તમે કેટલાક સંપર્કમાં હતી અને હવે આસ્થાપૂર્વક

100
00:06:00,330 --> 00:06:02,350
GDB સાથે કેટલાક અનુભવ હાથ પર,

101
00:06:02,350 --> 00:06:04,570
જે કોર્સ છે, એક ડીબગર અને તમે ચાલાકી માટે પરવાનગી આપે છે

102
00:06:04,570 --> 00:06:09,500
એકદમ નીચા સ્તરે તમારા કાર્યક્રમ કરવું, પ્રકારના શું વસ્તુઓ?

103
00:06:09,500 --> 00:06:13,030
GDB શું તમને છે?

104
00:06:13,030 --> 00:06:15,030
યાહ? મને કંઈક આપો. [વિદ્યાર્થી જવાબ, દુર્બોધ]

105
00:06:15,030 --> 00:06:18,120
ગુડ. કાર્ય માં પગલું છે, જેથી તમે માત્ર સ્કોર લખો ન હોય

106
00:06:18,120 --> 00:06:22,310
અને તેની સમગ્રતામાં દ્વારા કાર્યક્રમ ફટકો છે, છાપવા પ્રમાણભૂત આઉટપુટ વસ્તુઓ.

107
00:06:22,310 --> 00:06:25,190
તેના બદલે, તો તમે તેને વાક્ય મારફતે વાક્ય દ્વારા પગલું, ક્યાં આગામી લખીને કરી શકો છો

108
00:06:25,190 --> 00:06:30,300
માટે લીટી અથવા કાર્ય માં ડાઇવ, ખાસ કરીને એક કે તમે લખ્યું પગલું દ્વારા વાક્ય દ્વારા વાક્ય જાઓ.

109
00:06:30,300 --> 00:06:35,240
બીજું શું GDB તમને છે? યાહ? [વિદ્યાર્થી જવાબ, દુર્બોધ]

110
00:06:35,240 --> 00:06:38,100
ચલો છાપો. તેથી જો તમે તમારી કાર્યક્રમ ની અંદર થોડો આત્મનિરીક્ષણ કરવા માંગો છો

111
00:06:38,100 --> 00:06:41,500
આ સ્થળ પર તમામ printf નિવેદનો લખવા માટે આશરો કર્યા વગર,

112
00:06:41,500 --> 00:06:44,600
તમે માત્ર એક ચલ છાપી શકો છો અથવા એક ચલ દર્શાવે છે.

113
00:06:44,600 --> 00:06:46,710
બીજું શું તમે GDB જેવી ડીબગર સાથે કરી શકો છો?

114
00:06:46,710 --> 00:06:49,170
[વિદ્યાર્થી જવાબ, દુર્બોધ]

115
00:06:49,170 --> 00:06:52,080
બરાબર. તમે બ્રેકપોઇન્ટ્સ સેટ કરી શકો છો; તમે વિરામ અમલ કહેવું કરી શકો છો

116
00:06:52,080 --> 00:06:54,020
મુખ્ય કાર્ય અથવા foo કાર્ય છે.

117
00:06:54,020 --> 00:06:56,800
તમે 123 વાક્ય પર બ્રેક અમલ કહેવું કરી શકો છો.

118
00:06:56,800 --> 00:06:58,950
અને બ્રેકપોઇન્ટ્સ ખરેખર એક શક્તિશાળી ટેકનિક છે

119
00:06:58,950 --> 00:07:01,110
કારણ કે જો તમે જ્યાં તમારી સમસ્યા એક સામાન્ય સૂઝ હોય છે

120
00:07:01,110 --> 00:07:05,360
કદાચ, તમે હોય છે માટે સમય બગાડો એ કાર્યક્રમ પૂર્ણ મારફતે વેગ.

121
00:07:05,360 --> 00:07:08,250
તમે અનિવાર્યપણે અધિકાર ત્યાં કૂદકો કરી શકો છો અને પછી ટાઇપિંગ શરૂ કરો -

122
00:07:08,250 --> 00:07:10,970
પગલું અથવા આગામી અથવા જેવા સાથે મારફતે વેગ.

123
00:07:10,970 --> 00:07:14,340
પરંતુ GDB કંઈક સાથે કેચ છે કે તે તમે મદદ કરે છે, માનવ,

124
00:07:14,340 --> 00:07:16,940
તમારી સમસ્યાઓ શોધવા અને તમારી ભૂલો શોધે છે.

125
00:07:16,940 --> 00:07:19,470
તે જરૂરી નથી કે તેઓને શોધી નથી તમારા માટે ખૂબ જ.

126
00:07:19,470 --> 00:07:23,070
>> તેથી અમે બીજી દિવસ style50 રજૂઆત કરી હતી, જે ટૂંકા આદેશ વાક્ય સાધન છે

127
00:07:23,070 --> 00:07:27,500
કે તમારો કોડ થોડો વધુ તમે કરતાં સ્વચ્છ stylize કરવાનો પ્રયત્ન કરે છે, માનવ હોય પૂર્ણ કરી શકે છે.

128
00:07:27,500 --> 00:07:29,530
પરંતુ તે પણ ખરેખર માત્ર એક કલાત્મક ચીજ છે.

129
00:07:29,530 --> 00:07:34,110
પરંતુ તે વળે બહાર ત્યાં આ અન્ય Valgrind કહેવાય સાધન છે કે જે થોડી વધુ ઉપયોગ કરવા માટે arcane છે છે.

130
00:07:34,110 --> 00:07:36,860
તેના ઉત્પાદન atrociously પ્રથમ નજરમાં છુપાયેલું છે.

131
00:07:36,860 --> 00:07:39,420
પરંતુ તે અદ્ભૂત ઉપયોગી છે, ખાસ કરીને હવે કે અમે આ શબ્દ ભાગ પર છો

132
00:07:39,420 --> 00:07:43,080
તમે malloc અને ગતિશીલ મેમરી ફાળવણી વાપરો કે જ્યાં શરૂ કરી રહ્યાં છો.

133
00:07:43,080 --> 00:07:45,420
વસ્તુઓ ખરેખર, ખરેખર ખોટું ઝડપથી જઈ શકે છે.

134
00:07:45,420 --> 00:07:49,320
કારણ કે જો તમે તમારી મેમરી મુક્ત ભૂલી ગયા હો, અથવા તમે અમુક NULL નિર્દેશક ખોટો સંદર્ભ,

135
00:07:49,320 --> 00:07:55,770
અથવા તમે અમુક કચરો નિર્દેશક ડિરેફરન્સ, શું ખાસ છે તે પરિણામોમાં લક્ષણ છે?

136
00:07:55,770 --> 00:07:59,470
દોષ Seg. અને તમે કિલોબાઈટોમાં અથવા મેગાબાઇટ્સ કેટલાક નંબર આ કોર ફાઈલ વિચાર

137
00:07:59,470 --> 00:08:02,990
જે તમારા કાર્યક્રમ મેમરી રાજ્ય રજૂ જ્યારે તે ક્રેશ થયું,

138
00:08:02,990 --> 00:08:05,730
પરંતુ તમારા કાર્યક્રમ આખરે ખામી seg, સેગ્મેન્ટેશન ક્ષતિમાં,

139
00:08:05,730 --> 00:08:08,450
જેનો અર્થ થાય છે કશુંક ખરાબ લગભગ સંબંધિત હંમેશા થયું

140
00:08:08,450 --> 00:08:11,750
એક ભૂલ મેમરી સંબંધિત છે કે તમે ક્યાંક હતી.

141
00:08:11,750 --> 00:08:14,100
તેથી Valgrind તમને આ જેવી વસ્તુઓ શોધો.

142
00:08:14,100 --> 00:08:17,720
તે એક સાધન છે જે તમને સ્કોર છે, GDB જેમ, પછી તમે તમારા કાર્યક્રમ એકત્ર કર્યા છે,

143
00:08:17,720 --> 00:08:20,330
પરંતુ બદલે તમારા કાર્યક્રમ સીધી ચલાવો, તો તમારે સ્કોર Valgrind

144
00:08:20,330 --> 00:08:23,960
અને તમે તેને તમારા કાર્યક્રમ પસાર, જેમ તમે GDB સાથે કામ કરે છે.

145
00:08:23,960 --> 00:08:26,220
હવે, વપરાશ, આઉટપુટ શ્રેષ્ઠ પ્રકારનો વિચાર,

146
00:08:26,220 --> 00:08:30,410
છે થોડું લાંબુ છે, તેથી અધિકાર ત્યાં સ્ક્રીનની ટોચે તમે Valgrind-v જોશો.

147
00:08:30,410 --> 00:08:35,350
"વી" લગભગ સાર્વત્રિક વર્બોઝ અર્થ થાય છે જ્યારે તમે Linux કમ્પ્યુટર પર કાર્યક્રમો ઉપયોગ કરી રહ્યાં છો.

148
00:08:35,350 --> 00:08:38,770
તેથી તેનો અર્થ બહાર તમે કદાચ મૂળભૂત દ્વારા કરતાં વધુ માહિતી SPIT.

149
00:08:38,770 --> 00:08:45,510
"- = સંપૂર્ણ લીક તપાસો." આ માત્ર તમામ શક્ય મેમરી લીક્સ માટે ચેક કહેતા હોય છે,

150
00:08:45,510 --> 00:08:49,430
ભૂલો કે હું બનાવી હોઈ શકે છે. આ પણ, લિનક્સ કાર્યક્રમો સાથે એક સામાન્ય ફેરફાર છે.

151
00:08:49,430 --> 00:08:52,710
સામાન્ય રીતે, જો તમે આદેશ વાક્ય દલીલ છે કે "સ્વીચ" છે,

152
00:08:52,710 --> 00:08:55,830
કે જે કાર્યક્રમ વર્તન બદલવા તેવું માનવામાં આવે છે, અને તે એક જ અક્ષર છે,

153
00:08:55,830 --> 00:09:00,310
તે-v, પરંતુ ફેરવાઈ છે જો, માત્ર પ્રોગ્રામર ડિઝાઇન દ્વારા,

154
00:09:00,310 --> 00:09:05,150
છે એક સંપૂર્ણ અથવા શબ્દોના શબ્દ શ્રેણી, આદેશ વાક્ય દલીલ સાથે શરૂ થાય છે -.

155
00:09:05,150 --> 00:09:08,190
આ ફક્ત માનવ સંમેલનો, પરંતુ તમે તેમને વધુને વધુ જોશો.

156
00:09:08,190 --> 00:09:12,410
અને પછી, છેવટે, આ ચોક્કસ ઉદાહરણ કાર્યક્રમ માટે મનસ્વી નામ "a.out" છે.

157
00:09:12,410 --> 00:09:14,640
અને અહીં કેટલાક પ્રતિનિધિ આઉટપુટ છે.

158
00:09:14,640 --> 00:09:22,890
>> પહેલાં અમે તે શું અર્થ શકે જોવા દો, મને અહીં વધારે કોડ એક સ્નીપેટ પર જાઓ.

159
00:09:22,890 --> 00:09:26,390
દો અને મને જે રીતે આ બહાર ખસેડવા માટે, ટૂંક સમયમાં આવી,

160
00:09:26,390 --> 00:09:32,120
દો અને memory.c, કે જે આ ટૂંકા અહીં ઉદાહરણ છે પર એક નજર.

161
00:09:32,120 --> 00:09:36,290
તેથી આ કાર્યક્રમ દો, મને કાર્યો અને પ્રશ્નો પર ઝૂમ.

162
00:09:36,290 --> 00:09:39,430
અમે એક મુખ્ય કાર્ય છે, કે જે કાર્ય કહે એફ હોય છે,

163
00:09:39,430 --> 00:09:45,590
અને પછી એફ શું સહેજ તકનીકી ઇંગલિશ માં કરવા માટે, આગળ વધવા માટે કરે છે?

164
00:09:45,590 --> 00:09:49,760
એફ શું આગળ વધવા નથી કરી શકું?

165
00:09:49,760 --> 00:09:53,680
વિશે કેવી રીતે હું 20 રેખા સાથે શરૂ થશે, અને પડશે તો તારો સ્થાન વાંધો નથી,

166
00:09:53,680 --> 00:09:56,720
પરંતુ હું ફક્ત સુસંગત છેલ્લા વ્યાખ્યાન અહીં હશો.

167
00:09:56,720 --> 00:09:59,910
20 વાક્ય શું આપણા માટે છે? ડાબી બાજુએ. અમે તેને તોડી નીચે વધુ પડશે.

168
00:09:59,910 --> 00:10:02,410
ઈન્ * એક્સ: કે શું થાય છે?

169
00:10:02,410 --> 00:10:04,940
ઠીક છે. તે એક નિર્દેશક જાહેર કરવામાં આવ્યું છે અને હવે આપણે વધુ તકનિકી છે.

170
00:10:04,940 --> 00:10:10,230
તે શું નથી, ખૂબ concretely અર્થ, એક નિર્દેશક જાહેર? બીજા કોઇએ?

171
00:10:10,230 --> 00:10:15,050
યાહ? [વિદ્યાર્થી જવાબ, દુર્બોધ] ખૂબ દૂર.

172
00:10:15,050 --> 00:10:17,060
જેથી તમે સમાન સાઇન બાજુ જમણી બાજુ વાંચન કરી રહ્યા છો.

173
00:10:17,060 --> 00:10:20,290
ડાબી બાજુ પર માત્ર ચાલો ધ્યાન કેન્દ્રિત પૂર્ણાંક * એક્સ પર જ.

174
00:10:20,290 --> 00:10:24,700
આ કરતું એક નિર્દેશક "જાહેર", પરંતુ હવે ચાલો કે વ્યાખ્યા માટે ઊંડા માં ડાઇવ.

175
00:10:24,700 --> 00:10:28,330
કે શું concretely ટેકનિકલી, એનો અર્થ એ નથી? યાહ?

176
00:10:28,330 --> 00:10:31,940
[વિદ્યાર્થી જવાબ, દુર્બોધ]

177
00:10:31,940 --> 00:10:35,090
ઠીક છે. તે મેમરીમાં એક સરનામું સેવ તૈયાર છે.

178
00:10:35,090 --> 00:10:40,680
ગુડ. દો અને આ એક પગલું આગળ લે છે, તે એક ચલ એક્સ, જે 32 બિટ્સ છે જાહેર છે.

179
00:10:40,680 --> 00:10:44,440
અને હું જાણું છું તે 32 કારણ કે બિટ્સ છે -?

180
00:10:44,440 --> 00:10:47,390
તે કારણ કે તે પૂર્ણાંક છે, કારણ કે તે આ કેસમાં નિર્દેશક છે નથી.

181
00:10:47,390 --> 00:10:49,650
સંયોગ કે તે એક અને પૂર્ણાંક સાથે જ છે,

182
00:10:49,650 --> 00:10:51,970
પરંતુ હકીકત એ છે કે ત્યાં તારો છે ત્યાં અર્થ થાય છે કે આ એક નિર્દેશક છે

183
00:10:51,970 --> 00:10:57,300
અને સાધન, ઘણી કમ્પ્યુટર્સ સાથે નથી, પરંતુ તમામ પોઇંટરો 32 બિટ્સ છે.

184
00:10:57,300 --> 00:11:01,850
વધુ તાજેતરની મેક્સ, તાજેતરના પીસી જેવા આધુનિક હાર્ડવેર પર, તમે 64-bit પોઇન્ટર હોય શકે છે,

185
00:11:01,850 --> 00:11:04,160
પરંતુ સાધન, આ વસ્તુઓ 32 બિટ્સ છે.

186
00:11:04,160 --> 00:11:08,380
તેથી અમે તે પર પ્રમાણિત પડશે. વધુ concretely, વાર્તા આ પ્રમાણે જાય છે:

187
00:11:08,380 --> 00:11:10,820
અમે એક નિર્દેશક "જાહેર"; કે શું અર્થ છે?

188
00:11:10,820 --> 00:11:12,810
અમે મેમરી સરનામા સંગ્રહિત તૈયાર.

189
00:11:12,810 --> 00:11:15,530
કે શું અર્થ છે?

190
00:11:15,530 --> 00:11:19,810
અમે એક ચલ કહેવાતા એક્સ કે 32 બિટ્સ લે બનાવો

191
00:11:19,810 --> 00:11:23,810
કે તરત પૂર્ણાંક ની સરનામા સ્ટોર કરશે.

192
00:11:23,810 --> 00:11:26,470
અને તે કદાચ વિશે તરીકે ચોક્કસ તરીકે અમે મેળવી શકો છો.

193
00:11:26,470 --> 00:11:31,810
તે દંડ છે આગળ વધવા માટે વિશ્વ સરળ અને માત્ર કહેવું એક એક્સ કહેવાય નિર્દેશક જાહેર.

194
00:11:31,810 --> 00:11:35,380
એક નિર્દેશક જાહેર, પરંતુ ખ્યાલ અને સમજવા પડે છે ખરેખર શું ચાલી રહ્યું છે

195
00:11:35,380 --> 00:11:38,490
પણ માત્ર તે થોડા અક્ષરો.

196
00:11:38,490 --> 00:11:42,040
>> હવે, આ એક લગભગ થોડું સરળ છે, તેમ છતાં તે લાંબા સમય સુધી અભિવ્યક્તિ છે.

197
00:11:42,040 --> 00:11:48,160
તેથી આ શું, કરી છે કે હવે પ્રકાશિત છે: "malloc (10 * (પૂર્ણાંક) sizeof);" યાહ?

198
00:11:48,160 --> 00:11:52,350
[વિદ્યાર્થી જવાબ, દુર્બોધ]

199
00:11:52,350 --> 00:11:58,250
ગુડ. અને હું તેને ત્યાં લઈ શકશો. તે દસ પૂર્ણાંકો માટે મેમરી એક ભાગ allocating છે.

200
00:11:58,250 --> 00:12:02,190
અને હવે ચાલો થોડું ઊંડા માં ડાઇવ; તે દસ પૂર્ણાંકો માટે મેમરી એક ભાગ allocating છે.

201
00:12:02,190 --> 00:12:05,390
Malloc શું પછી પરત આવે છે?

202
00:12:05,390 --> 00:12:10,390
કે ભાગ ઓફ સરનામા, અથવા, વધુ concretely છે, કે જે ભાગ પ્રથમ બાઇટ ની સરનામું.

203
00:12:10,390 --> 00:12:14,080
પછી હું કેવી રીતે છું, તો પ્રોગ્રામર ખબર છે, ક્યાં મેમરી અંત કે ભાગ?

204
00:12:14,080 --> 00:12:18,340
મને ખબર છે કે તે સંલગ્ન છે. Malloc, વ્યાખ્યા દ્વારા, તમે મેમરી એક સંલગ્ન ભાગ આપશે.

205
00:12:18,340 --> 00:12:21,240
તેને કોઈ ગાબડા. કે જે તમને ભાગ દરેક બાઈટ વપરાશ હોય છે,

206
00:12:21,240 --> 00:12:26,760
પાછળ પાછળ પાછળ, પરંતુ હું જ્યાં મેમરી આ ભાગ ઓવરને કેવી રીતે જાણી શકું?

207
00:12:26,760 --> 00:12:28,850
જ્યારે તમે malloc ઉપયોગ કરો છો? [વિદ્યાર્થી જવાબ, દુર્બોધ] ગુડ.

208
00:12:28,850 --> 00:12:30,670
શું તમે નથી. તમે યાદ હોય છે.

209
00:12:30,670 --> 00:12:35,960
હું યાદ રાખો કે હું 10 કિંમત ઉપયોગ હોય છે, અને હું પણ અહીં કર્યું છે તેમ લાગતું નથી.

210
00:12:35,960 --> 00:12:41,000
પરંતુ જવાબદારી મને પર રાખે છે. Strlen, જે અમે સહેજ પર નિર્ભર શબ્દમાળાઓ માટે બની કરી લીધી છે,

211
00:12:41,000 --> 00:12:45,860
0 \ કર્યા આ સંમેલન કારણે માત્ર કામ કરે છે

212
00:12:45,860 --> 00:12:48,840
અથવા આ ખાસ nul અક્ષર શબ્દમાળા ઓવરને અંતે NUL.

213
00:12:48,840 --> 00:12:51,740
કે મેમરી માત્ર મનસ્વી હિસ્સામાં માટે રાખી નથી.

214
00:12:51,740 --> 00:12:58,590
તે તમારા પર છે. 20 લીટી તેથી, તે પછી, મેમરી એક ભાગ ફાળવે છે

215
00:12:58,590 --> 00:13:02,590
કે દસ પૂર્ણાંકો સ્ટોર કરી શકો છો અને તે પ્રથમ બાઇટ ની સરનામા સંગ્રહ કરે છે

216
00:13:02,590 --> 00:13:05,610
આ ચલ કહેવાય એક્સ માં મેમરી કે ભાગ છે.

217
00:13:05,610 --> 00:13:11,140
તેને લીધે, કે જે નિર્દેશક છે. 21 લીટી તેથી કમનસીબે, એક ભૂલ આવી હતી.

218
00:13:11,140 --> 00:13:16,110
પરંતુ પ્રથમ, તે શું કરી રહ્યો છે? તે 10 સ્થાન, 0 અનુક્રમિત અંતે સ્ટોર કહેતા છે,

219
00:13:16,110 --> 00:13:19,480
મેમરીનો ભાગ એક્સ મૂલ્ય 0 કહેવાય છે.

220
00:13:19,480 --> 00:13:21,510
>> તેથી નોટિસ વસ્તુઓ એક દંપતી પર જઈને કરવામાં આવે છે.

221
00:13:21,510 --> 00:13:25,420
ભલે એક્સ એક નિર્દેશક છે, પહેલા બે અઠવાડિયા થી યાદ

222
00:13:25,420 --> 00:13:29,440
કે તમે હજુ પણ ચોરસ એરે-શૈલી કૌંસ નોટેશનમાં વાપરી શકો છો.

223
00:13:29,440 --> 00:13:36,180
કારણ કે વાસ્તવમાં વધુ ભેદી દેખાવ નિર્દેશક અંકગણિત માટે નોટેશનમાં ટૂંકા હાથ છે.

224
00:13:36,180 --> 00:13:40,320
જ્યાં અમે આ કંઈક કરવું જોઈએ: સરનામું એક્સ લો, પર 10 સ્થળો ખસેડવા માટે,

225
00:13:40,320 --> 00:13:44,550
પછી સરનામા ગમે તે સ્થાન પર સંગ્રહ થયેલ છે ત્યાં જાઓ.

226
00:13:44,550 --> 00:13:48,090
પરંતુ પ્રમાણિકપણે, માત્ર આ જ ભયાનક છે વાંચવા અને સાથે આરામદાયક છે.

227
00:13:48,090 --> 00:13:52,900
તેથી વિશ્વ ખાસ કરીને ચોરસ કૌંસ વાપરે માત્ર કારણ કે તે વધુ માનવ મૈત્રીપૂર્ણ વાંચવા છે.

228
00:13:52,900 --> 00:13:55,140
પરંતુ શું ખરેખર હૂડ નીચે રહ્યું છે તે;

229
00:13:55,140 --> 00:13:58,190
એક્સ એક સરનામું, સે દીઠ નથી ઝાકઝમાળ છે.

230
00:13:58,190 --> 00:14:02,410
તેથી આ એક્સ માં 10 સ્થાન પર 0 સ્ટોર કરે છે.

231
00:14:02,410 --> 00:14:06,120
આ શા માટે છે ખરાબ? યાહ?

232
00:14:06,120 --> 00:14:17,370
[વિદ્યાર્થી જવાબ, દુર્બોધ] ચોક્કસ.

233
00:14:17,370 --> 00:14:21,100
અમે ફક્ત દસ ints ફાળવવામાં, પરંતુ અમે 0 થી ગણતરી જ્યારે સી પ્રોગ્રામિંગ,

234
00:14:21,100 --> 00:14:25,690
જેથી તમે 0 1 2 3 4 5 6 7 8 9, પરંતુ 10 વપરાશ હોય છે.

235
00:14:25,690 --> 00:14:30,270
તેથી ક્યાં તો કાર્યક્રમ seg ખામી માટે જઈ રહ્યો છે અથવા તે છે નથી.

236
00:14:30,270 --> 00:14:32,900
પરંતુ અમે ખરેખર ખબર નથી કે, આ એક nondeterministic વર્તન જેવું છે.

237
00:14:32,900 --> 00:14:35,600
તે ખરેખર શું આપણે નસીબદાર વિચાર પર આધાર રાખે છે.

238
00:14:35,600 --> 00:14:40,650
જો તે તારણ આપે છે કે જે ઓપરેટિંગ સિસ્ટમ વાંધો નથી જો હું કે જે વધારાના બાઇટ વાપરવા માટે,

239
00:14:40,650 --> 00:14:43,360
ભલે તે મને તે આપી નથી, મારા કાર્યક્રમ ભાંગી શકે છે.

240
00:14:43,360 --> 00:14:46,780
તે કાચા છે, તે બગડેલ નથી, પણ છે કે જે તમને લક્ષણ જોઈ શકે છે,

241
00:14:46,780 --> 00:14:48,960
અથવા તમે તેને માત્ર એક વખતે એક વખત જોઈ શકો.

242
00:14:48,960 --> 00:14:51,230
પરંતુ વાસ્તવિકતા એ છે કે ભૂલ હકીકત છે, ત્યાં.

243
00:14:51,230 --> 00:14:54,320
અને તે ખરેખર સમસ્યારૂપ છે જો તમે એક કાર્યક્રમ છે કે જે તમે યોગ્ય થવું હોય તેવા પરચૂરણ ખર્ચ કર્યો છે,

244
00:14:54,320 --> 00:14:58,840
કે તમે કાર્યક્રમ વેચી કર્યું છે કે લોકો ઉપયોગ કરી રહ્યા છો કે જે દરેક એક વખતે એક વખત ક્રેશ

245
00:14:58,840 --> 00:15:02,450
કારણ કે, બેશક, આ સારૂં નથી. હકીકતમાં, જો તમારી પાસે Android ફોન અથવા આઇફોન છે

246
00:15:02,450 --> 00:15:05,550
અને તમે આ દિવસોમાં એપ્લિકેશન્સ ડાઉનલોડ કરો, જો તમે ક્યારેય પડ્યું એક એપ્લિકેશન માત્ર છોડી દીધું

247
00:15:05,550 --> 00:15:10,040
અચાનક તમામ તે અદૃશ્ય થઈ જાય છે, તે હંમેશા કેટલાક મુદ્દાને મેમરી સંબંધિત પરિણામ છે,

248
00:15:10,040 --> 00:15:12,830
જેમાં પ્રોગ્રામર ઘણું ખરાબ અને dereferenced એક નિર્દેશક

249
00:15:12,830 --> 00:15:18,670
કે તે અથવા તેણી ન હોવું જોઈએ, અને iOS અથવા Android ના પરિણામ માટે માત્ર કાર્યક્રમ સંપૂર્ણપણે મારી નાખી છે

250
00:15:18,670 --> 00:15:23,080
તેના બદલે જોખમ અવ્યાખ્યાયિત વર્તન અથવા સુરક્ષા કોઈક પ્રકારનું સમાધાન કરતાં.

251
00:15:23,080 --> 00:15:25,950
>> ત્યાં એક એક ઉપરાંત આ કાર્યક્રમ અન્ય ભૂલ છે.

252
00:15:25,950 --> 00:15:30,180
બીજું શું હું આ કાર્યક્રમ માં ઘણું ખરાબ?

253
00:15:30,180 --> 00:15:32,740
હું નથી પ્રેક્ટિસ કર્યા છે હું શું ઉપદેશ કર્યો છે. યાહ?

254
00:15:32,740 --> 00:15:34,760
[વિદ્યાર્થી જવાબ, દુર્બોધ] ગુડ.

255
00:15:34,760 --> 00:15:36,880
હું મેમરી નથી મુક્ત છે. તેથી અંગૂઠાની હવે નિયમ

256
00:15:36,880 --> 00:15:43,150
માટે હોવું ગમે ત્યારે તમે malloc કૉલ, તમે મફત કૉલ જ્યારે તમે પૂર્ણ થાય છે જે મેમરી નો ઉપયોગ કરીને આવશ્યક છે.

257
00:15:43,150 --> 00:15:45,610
હવે, જ્યારે હું આ મેમરી મુક્ત માગતા નથી?

258
00:15:45,610 --> 00:15:49,780
કદાચ, ધારી રહ્યા છીએ આ પ્રથમ વાક્ય સાચું હતું, હું તેને અહીં કરવા માંગો છો કરશે.

259
00:15:49,780 --> 00:15:55,710
કારણ કે હું, હમણાં પૂરતું નથી, તે કરી શકે છે અહીં નહીં. શા માટે?

260
00:15:55,710 --> 00:15:57,860
બસ અવકાશ છે. તેથી ભલે અમે પોઇંટરો વિશે વાત કરી રહ્યાં છો,

261
00:15:57,860 --> 00:16:04,830
આ 2 સપ્તાહ અથવા 3 મુદ્દો છે, જ્યાં X એ સર્પાકાર કૌંસ જ્યાં તે જાહેર કરવામાં આવી ની અંદર અવકાશ જ છે.

262
00:16:04,830 --> 00:16:11,000
જેથી તમે ચોક્કસપણે તે ત્યાં ન મુક્ત કરી શકો છો. મારી જ તેને મુક્ત તક 21 લીટી પછી આશરે છે.

263
00:16:11,000 --> 00:16:15,170
આ એકદમ સરળ કાર્યક્રમ છે, તેને એકદમ સરળ હતું એકવાર તમે પ્રકારની તમારા મન આવરિત

264
00:16:15,170 --> 00:16:17,870
શું આસપાસ કાર્યક્રમ કરવું, છે જ્યાં ભૂલો હતી.

265
00:16:17,870 --> 00:16:20,500
અને જો તમે તેને પ્રથમ નથી દેખાતી, આસ્થાપૂર્વક તે થોડી સ્પષ્ટ હવે

266
00:16:20,500 --> 00:16:23,870
કે આ ભૂલો ખૂબ સરળતાથી અને હલ કરવામાં આવે છે સરળતાથી કરી હતી.

267
00:16:23,870 --> 00:16:28,720
પરંતુ જ્યારે એક કાર્યક્રમ 12 કરતાં વધુ રેખાઓ લાંબો છે, તે 50 રેખાઓ લાંબા, 100 લીટીઓ લાંબો છે,

268
00:16:28,720 --> 00:16:31,150
રેખા દ્વારા તમારો કોડ વાક્ય મારફતે વૉકિંગ, વિચારશીલ તે મારફતે તાર્કિક,

269
00:16:31,150 --> 00:16:35,110
શક્ય છે પરંતુ કરવા ખાસ નથી મજા છે, સતત ભૂલો માટે જોઈ રહ્યા છીએ,

270
00:16:35,110 --> 00:16:38,340
અને તે પણ મુશ્કેલ કરે છે, અને કે શા માટે Valgrind જેવા સાધન અસ્તિત્વમાં છે.

271
00:16:38,340 --> 00:16:40,900
મને આગળ વધો અને આ કરો: દો મને મારી ટર્મિનલ વિન્ડોમાં ખોલો,

272
00:16:40,900 --> 00:16:45,400
દો અને મને મેમરી માત્ર ચલાવવા માટે, કારણ કે મેમરી દંડ લાગે છે.

273
00:16:45,400 --> 00:16:49,180
હું નસીબદાર મેળવવામાં છું. એરે ઓવરને અંતે કે વધારાના બાઇટ જવું

274
00:16:49,180 --> 00:16:51,060
નથી લાગે છે નથી પણ સમસ્યારૂપ છે.

275
00:16:51,060 --> 00:16:56,370
પરંતુ મને દો, તેમ છતાં, એક સેનીટી ચેક, કે જે માત્ર તપાસ અર્થ એ થાય કરવું

276
00:16:56,370 --> 00:16:58,320
નથી કે આ ખરેખર સાચું છે.

277
00:16:58,320 --> 00:17:04,690
>> તેથી આપણે valgrind-v કરવું - = સંપૂર્ણ લીક તપાસો,

278
00:17:04,690 --> 00:17:07,520
અને પછી આ કિસ્સામાં કાર્યક્રમના નામ, a.out નથી મેમરી છે.

279
00:17:07,520 --> 00:17:10,760
તેથી દો મને આગળ વધો અને આ કરવા માટે. લિમિટેડ નહીં.

280
00:17:10,760 --> 00:17:14,109
ભગવાન પ્રિય. આ તેની ઉત્પાદન છે, અને આ છે જે હું અગાઉ ખોટો સંદર્ભ આપવામાં આવ્યો.

281
00:17:14,109 --> 00:17:17,550
પરંતુ, જો તમે નોનસેન્સ તમામ મારફતે અહીં વાંચી જાણવા માટે,

282
00:17:17,550 --> 00:17:20,760
આ સૌથી ન્યાયી તપાસ આઉટપુટ કે જે રસપ્રદ નથી છે.

283
00:17:20,760 --> 00:17:24,829
તમારી આંખ ખરેખર માટે શોધી શકાય છે શું ઇચ્છે છે ભૂલ અથવા અમાન્ય કોઇ ઉલ્લેખ છે.

284
00:17:24,829 --> 00:17:26,800
શબ્દો સમસ્યાઓ સૂચવે છે.

285
00:17:26,800 --> 00:17:29,340
અને ખરેખર, ચાલો શું ખોટું થઈ રહ્યું છે તે નીચે અહીં.

286
00:17:29,340 --> 00:17:35,230
હું અમુક પ્રકારની સાર છે, "ઉપયોગ બહાર નીકળો પર. 1 બ્લોકમાં 40 બાઇટ્સ"

287
00:17:35,230 --> 00:17:38,750
હું ખરેખર બ્લોક શું છે હજુ સુધી નથી, પરંતુ 40 બાઇટ્સ

288
00:17:38,750 --> 00:17:41,260
વાસ્તવમાં એવું લાગે છે કે હું બહાર આકૃતિ જ્યાં તે આવે શકે છે.

289
00:17:41,260 --> 00:17:45,030
40 બાઇટ્સ. બહાર નીકળો અંતે વપરાશમાં 40 બાઇટ્સ શા માટે છે?

290
00:17:45,030 --> 00:17:48,780
અને વધુ ચોક્કસ રીતે, જો આપણે નીચે સ્ક્રોલ અહીં,

291
00:17:48,780 --> 00:17:54,520
હું ચોક્કસપણે શા માટે છે 40 બાઇટ્સ ગુમાવી? યાહ?

292
00:17:54,520 --> 00:17:59,520
[વિદ્યાર્થી જવાબ, દુર્બોધ] પરફેક્ટ. અરે વાહ, બરાબર.

293
00:17:59,520 --> 00:18:03,540
ત્યાં દસ પૂર્ણાંકો હતા, અને તે દરેક 4, અથવા 32 બિટ્સની માપ છે,

294
00:18:03,540 --> 00:18:08,300
જેથી હું 40 ચોક્કસપણે બાઇટ્સ ગુમાવ્યું છે, કારણ કે, તમે જેમ પ્રસ્તાવ મૂક્યો, હું મુક્ત ન કહી છે.

295
00:18:08,300 --> 00:18:13,460
કે એક ભૂલ છે, અને હવે આપણે નીચે થોડી વધુ દેખાય અને આ આગામી જુઓ,

296
00:18:13,460 --> 00:18:16,900
"અમાન્ય 4 સાઈઝ લખી." હવે આ શું છે?

297
00:18:16,900 --> 00:18:21,150
આ સરનામું શું આધાર નોટેશનમાં વ્યક્ત છે દેખીતી રીતે?

298
00:18:21,150 --> 00:18:23,640
આ હેક્સાડેસિમલ છે, અને કોઇ પણ સમયે 0x સાથે શરૂ નંબર જુઓ,

299
00:18:23,640 --> 00:18:29,410
તે હેક્સાડેસિમલ અર્થ થાય છે, જે અમે મને લાગે છે કે, પ્રશ્નો pset હિસ્સો 0 વિભાગમાં પાછા માર્ગ હતી,

300
00:18:29,410 --> 00:18:34,090
જે warmup કસરત માત્ર કરવું હતું, બાઈનરી હેક્સ માટે રેખાંશ રૂપાંતરિત અને તેથી આગળ.

301
00:18:34,090 --> 00:18:39,220
હેક્સાડેસિમલ, માનવ સંમેલન દ્વારા જ સામાન્ય રીતે પોઇંટરો પ્રતિનિધિત્વ કરવા માટે વપરાય છે

302
00:18:39,220 --> 00:18:41,570
અથવા, વધુ સામાન્ય રીતે સંબોધે છે. તે માત્ર એક પરંપરા છે,

303
00:18:41,570 --> 00:18:45,340
કારણ કે તે થોડા સરળ વાંચો, તે થોડી વધુ રેખાંશ કંઈક કરતાં કોમ્પેક્ટ છે,

304
00:18:45,340 --> 00:18:47,720
અને બાઈનરી નકામી છે એ મોટાભાગના માનવ વાપરવા માટે.

305
00:18:47,720 --> 00:18:50,840
તેથી હવે આ શું અર્થ છે? વેલ, લાગે છે કે ત્યાં એક અમાન્ય લખવા છે

306
00:18:50,840 --> 00:18:54,480
memory.c ઓફ 21 વાક્ય પર 4 માપ છે.

307
00:18:54,480 --> 00:18:59,180
તેથી આપણે 21 લીટી પર પાછા જાઓ, અને ખરેખર, અહીં કે અમાન્ય લખવા છે.

308
00:18:59,180 --> 00:19:02,640
તેથી Valgrind સંપૂર્ણપણે મારી હાથ પકડી અને મને કહો સુધારો છે જે ન રહ્યું છે,

309
00:19:02,640 --> 00:19:05,520
પરંતુ તે શોધવા છે કે હું એક અમાન્ય લખવા કરી રહ્યો છું.

310
00:19:05,520 --> 00:19:08,800
હું 4 બાઇટ્સ સ્પર્શ છું કે હું ન હોવો જોઇએ, અને દેખીતી રીતે કે છે,

311
00:19:08,800 --> 00:19:13,960
જેમ તમે ધ્યાન દોર્યું, હું [9] બદલે [10] કરી રહ્યો છું વધુમાં

312
00:19:13,960 --> 00:19:16,660
અથવા [0] અથવા વચ્ચે કંઈક.

313
00:19:16,660 --> 00:19:19,690
Valgrind સાથે, કોઈપણ સમયે તમે હવે કાર્યક્રમ લખી રહ્યાં ખ્યાલ

314
00:19:19,690 --> 00:19:24,190
કે પોઇંટરો વાપરે છે અને મેમરી વાપરે છે, અને malloc વધુ ખાસ રીતે,

315
00:19:24,190 --> 00:19:27,080
ચોક્કસપણે આ લાંબી ચાલી ની આદત માં વિચાર

316
00:19:27,080 --> 00:19:30,890
પરંતુ ખૂબ સરળતાથી નકલ અને પેસ્ટ Valgrind ના આદેશ

317
00:19:30,890 --> 00:19:32,650
જોવા માટે જો ત્યાં ત્યાં અમુક ભૂલો છે.

318
00:19:32,650 --> 00:19:34,820
અને તે જબરજસ્ત દર વખતે તમે આઉટપુટ જુઓ હશો,

319
00:19:34,820 --> 00:19:39,430
પરંતુ માત્ર એ આઉટપુટ તમામ દૃષ્ટિની મારફતે પાર્સ અને જુઓ જો તમે જોઈ ભૂલો ઉલ્લેખો

320
00:19:39,430 --> 00:19:43,190
અથવા ચેતવણીઓ છે અથવા અમાન્ય છે અથવા હારી ગયા.

321
00:19:43,190 --> 00:19:46,200
કોઈપણ શબ્દ કે તમે જેમ અવાજને અપ ક્યાંક ખરાબ કર્યું.

322
00:19:46,200 --> 00:19:48,580
જેથી ખ્યાલ છે કે જે તમારા ટૂલકીટ એક નવું સાધન છે.

323
00:19:48,580 --> 00:19:51,270
>> સોમવારે હવે, અમે લોકો સંપૂર્ણ સમૂહ હતો અહીં આવો

324
00:19:51,270 --> 00:19:53,150
અને એક કડી થયેલ યાદી વિચારને રજૂ કરે છે.

325
00:19:53,150 --> 00:20:00,970
અને અમે સમસ્યા શું ઉકેલ તરીકે યાદીની લિંક રજૂઆત?

326
00:20:00,970 --> 00:20:04,590
યાહ? [વિદ્યાર્થી જવાબ, દુર્બોધ] ગુડ.

327
00:20:04,590 --> 00:20:06,530
એરે હોઈ શકે નહિં મેમરી તેમને ઉમેર્યા છે.

328
00:20:06,530 --> 00:20:09,440
જો તમે 10 કદ ઝાકઝમાળ, કે બધા તમે વિચાર છે ફાળવો.

329
00:20:09,440 --> 00:20:13,690
તમે realloc જેમ કાર્ય કૉલ જો તમે શરૂઆતમાં malloc કહી શકાય,

330
00:20:13,690 --> 00:20:17,580
અને કે જે એરે વધવા પ્રયાસ જો ત્યાં તે ઓવરને તરફ જગ્યા છે

331
00:20:17,580 --> 00:20:21,610
કે કોઇ મદદથી છે, અને જો નથી ત્યાં, તે માત્ર તમે મોટા ભાગ મળશે બીજે ક્યાંય.

332
00:20:21,610 --> 00:20:25,040
પરંતુ પછી તે નવા એરે માં તે બાઇટ્સ તમામ નકલ થશે.

333
00:20:25,040 --> 00:20:28,310
આ એક ખૂબ જ યોગ્ય ઉકેલ જેવું વાગે છે.

334
00:20:28,310 --> 00:20:34,790
આ શા માટે છે unattractive?

335
00:20:34,790 --> 00:20:36,940
હું તેનો અર્થ તે કામ કરે છે, મનુષ્યો આ સમસ્યા ઉકેલી છે.

336
00:20:36,940 --> 00:20:40,710
અમે સાથે કડી યાદીઓ સાથે સોમવારે તે ઉકેલવા શા માટે જરૂર હતી? યાહ?

337
00:20:40,710 --> 00:20:44,060
[વિદ્યાર્થી જવાબ, દુર્બોધ] તે માટે લાંબો સમય લઈ શકે છે.

338
00:20:44,060 --> 00:20:49,260
હકીકતમાં, કોઈ પણ સમયે તમે malloc અથવા realloc અથવા calloc છે, કે જે હજી સુધી અન્ય એક છે કૉલ કરી રહ્યાં છો,

339
00:20:49,260 --> 00:20:52,470
કોઈપણ સમયે તમે કરો, તો કાર્યક્રમ છે, ઓપરેટિંગ સિસ્ટમ સાથે વાત,

340
00:20:52,470 --> 00:20:54,310
તમે કાર્યક્રમ ધીમી નીચે હોય છે.

341
00:20:54,310 --> 00:20:57,470
અને જો તમે આંટીઓ વસ્તુઓ આ પ્રકારનાં કરી રહ્યા છીએ, તમે ખરેખર વસ્તુઓ ધીમી કરી રહ્યાં નહીં.

342
00:20:57,470 --> 00:21:00,740
તમે "હેલો વર્લ્ડ" પ્રકાર કાર્યક્રમોની સરળ માટે આ નોટિસ નથી જઈ રહ્યાં છો,

343
00:21:00,740 --> 00:21:04,300
પરંતુ મોટા કાર્યક્રમો માં મેમરી માટે ઓપરેટિંગ સિસ્ટમ ફરીથી અને ફરીથી પુછે

344
00:21:04,300 --> 00:21:07,520
અથવા તેને આપીને પાછા ફરી અને ફરી એક સારી વાત નથી હોઇ શકે છે.

345
00:21:07,520 --> 00:21:11,210
ઉપરાંત, તે માત્ર બૌદ્ધિક જેવું - તે સમય સંપૂર્ણ કચરો છે.

346
00:21:11,210 --> 00:21:16,490
શા માટે વધુ અને વધુ મેમરીને ફાળવવા, નવા એરે માં બધું નકલ જોખમ,

347
00:21:16,490 --> 00:21:21,980
જો તમે વૈકલ્પિક કે તમને માત્ર એટલું મેમરીને ફાળવવા તરીકે તમે ખરેખર જરૂર છે?

348
00:21:21,980 --> 00:21:24,130
તેથી અહીં અને પ્લીસસ minuses છે.

349
00:21:24,130 --> 00:21:26,730
એક પ્લીસસ હવે એ છે કે આપણે dynamism છે.

350
00:21:26,730 --> 00:21:29,100
વાંધો જ્યાં મેમરીનો હિસ્સામાં છે કે જે મુક્ત છે,

351
00:21:29,100 --> 00:21:32,070
મેં હમણાં જ બનાવવા પોઇંટરો મારફતે કરી શકો છો આ બ્રેડ crumbs સૉર્ટ

352
00:21:32,070 --> 00:21:34,470
મારા સમગ્ર યાદીની લિંક સાથે મળીને સ્ટ્રિંગ.

353
00:21:34,470 --> 00:21:36,470
પરંતુ હું ઓછામાં ઓછો એક કિંમત ચૂકવે છે.

354
00:21:36,470 --> 00:21:40,060
>> હું શું સાથે કડી યાદીઓ મેળવવાથી માં આપી છે?

355
00:21:40,060 --> 00:21:42,470
યાહ? [વિદ્યાર્થી જવાબ, દુર્બોધ] ગુડ.

356
00:21:42,470 --> 00:21:45,650
તમે વધુ મેમરી જરૂર છે. હવે હું આ પોઇન્ટર જગ્યાની જરૂર હોય,

357
00:21:45,650 --> 00:21:47,900
અને આ સુપર સરળ યાદીની લિંક કિસ્સામાં

358
00:21:47,900 --> 00:21:51,410
કે માત્ર પૂર્ણાંકો, જે 4 બાઇટ્સ છે સ્ટોર કરવાનો પ્રયાસ છે, અમે કહેતા રાખવા

359
00:21:51,410 --> 00:21:54,240
સાથે સાથે, એક નિર્દેશક 4 બાઇટ્સ છે, તેથી હવે હું શાબ્દિક બમણો કર્યો છે

360
00:21:54,240 --> 00:21:57,290
મેમરીનો જથ્થો મેં હમણાં જ આ યાદી સંગ્રહવા માટે જરૂર છે.

361
00:21:57,290 --> 00:21:59,680
પરંતુ ફરીથી, આ કોમ્પ્યુટર વિજ્ઞાન એક સતત સંતુલિત છે

362
00:21:59,680 --> 00:22:03,440
સમય અને જગ્યા અને વિકાસ ઘટાડે છે, અને અન્ય સ્રોતો વચ્ચે.

363
00:22:03,440 --> 00:22:06,630
એક કડી થયેલ યાદી ઉપયોગ અન્ય નુકસાન શું છે? યાહ?

364
00:22:06,630 --> 00:22:10,150
[વિદ્યાર્થી જવાબ, દુર્બોધ]

365
00:22:10,150 --> 00:22:12,600
ગુડ. ઍક્સેસ તરીકે સરળ. અમે લાંબા સમય સુધી કરી શકો છો લાભ

366
00:22:12,600 --> 00:22:15,530
જેમ 0 સિદ્ધાંતો સપ્તાહ વિભાજિત અને જીતી.

367
00:22:15,530 --> 00:22:18,220
અને વધુ ચોક્કસ રીતે, દ્વિસંગી શોધ. કારણ કે તેમ છતાં અમે માનવો

368
00:22:18,220 --> 00:22:20,400
આશરે જુઓ જ્યાં આ યાદી મધ્યમાં છે,

369
00:22:20,400 --> 00:22:25,840
કમ્પ્યુટર માત્ર જાણે છે કે આ યાદીની લિંક પ્રથમ કહેવાય સરનામાં પર શરૂ થાય છે.

370
00:22:25,840 --> 00:22:28,250
અને તે 0x123 અથવા તે કંઈક છે.

371
00:22:28,250 --> 00:22:30,990
અને માત્ર કાર્યક્રમ માર્ગ મધ્યમ તત્વ શોધી શકો છો

372
00:22:30,990 --> 00:22:33,350
ખરેખર આખી યાદી શોધવા છે.

373
00:22:33,350 --> 00:22:35,500
અને એના પછી, તે શાબ્દિક સમગ્ર યાદી શોધવા ધરાવે છે કારણ કે

374
00:22:35,500 --> 00:22:38,950
પણ એક વાર તમે પોઇંટરો પગલે દ્વારા મધ્યમ તત્વ પહોંચે છે,

375
00:22:38,950 --> 00:22:42,380
તમે કરો, તો કાર્યક્રમ, કોઈ વિચાર કેટલા આ યાદી છે સંભવિત હોય છે,

376
00:22:42,380 --> 00:22:45,250
ત્યાં સુધી તમે તેને ઓવરને દબાવો, અને તમે કેવી રીતે પ્રોગ્રામ ખબર નથી

377
00:22:45,250 --> 00:22:48,600
કે તમે યાદીની લિંક ઓવરને અંતે છો?

378
00:22:48,600 --> 00:22:51,120
ત્યાં એક ખાસ NULL નિર્દેશક જેથી ફરીથી, એક સંમેલનમાં છે.

379
00:22:51,120 --> 00:22:53,870
કરતાં આ નિર્દેશક વાપરવા માટે, અમે ચોક્કસપણે તેને કેટલીક કચરો કિંમત કરવા નથી માંગતા

380
00:22:53,870 --> 00:22:57,750
બંધ પોઇન્ટ મંચ ક્યાંક; અમે તેને હાથ પ્રયત્ન કરવા માંગો છો નીચે, NULL,

381
00:22:57,750 --> 00:23:01,530
જેથી અમે આ માહિતી માળખું આ ટર્મિનસ છે, જેથી આપણે જાણીએ છીએ, જ્યાં તે પૂર્ણ થાય છે.

382
00:23:01,530 --> 00:23:03,410
>> જો અમે આ ચાલાકી કરવા માંગો છો?

383
00:23:03,410 --> 00:23:05,980
અમે આ દૃષ્ટિની મોટા ભાગના હતી, અને મનુષ્ય સાથે,

384
00:23:05,980 --> 00:23:07,630
પરંતુ જો આપણે એક નિવેશ કરવા માંગો છો?

385
00:23:07,630 --> 00:23:12,360
જેથી મૂળ યાદી 9, 17, 20, 22, 29, 34 હતી.

386
00:23:12,360 --> 00:23:16,730
જો અમે તે પછી 55 નંબર, તેના માટે નોડ માટે malloc જગ્યા કરવા માગે છે,

387
00:23:16,730 --> 00:23:20,730
અને પછી અમે યાદી માં 55 દાખલ જેમ આપણે સોમવારે કર્યું કરવા માંગો છો?

388
00:23:20,730 --> 00:23:23,690
અમે આ કેવી રીતે કરવું? વેલ, અનિતા આવી અને તે અનિવાર્યપણે યાદી ચાલ્યો.

389
00:23:23,690 --> 00:23:27,500
તેમણે પ્રથમ તત્વ શરૂ, પછી આગામી, આગામી, આગામી, આગામી, આગામી.

390
00:23:27,500 --> 00:23:29,500
છેલ્લે ડાબી બાજુની બધી રીતે ફટકો નીચે

391
00:23:29,500 --> 00:23:34,480
અને ઓહ ભાન, આ NULL છે. તેથી શું નિર્દેશક મેનીપ્યુલેશન પૂર્ણ કરવાની જરૂર છે?

392
00:23:34,480 --> 00:23:37,980
જે વ્યક્તિ ઓવરને પર હતો, 34 નંબર જરૂરી તેના ડાબા હાથ ઉઠાવ્યો હતો

393
00:23:37,980 --> 00:23:46,220
માટે 55 અંતે નિર્દેશ, 55 તેમના ડાબા નીચે તરફ પોઇન્ટ નવા NULL ટર્મીનેટર પ્રયત્ન હાથ જરૂર છે. થઈ ગયું.

394
00:23:46,220 --> 00:23:49,540
સરળ સુંદર એક છટણી યાદી માં 55 દાખલ કરવા માટે.

395
00:23:49,540 --> 00:23:51,800
અને આ કેવી રીતે જુઓ શકે છે?

396
00:23:51,800 --> 00:23:55,690
>> મને આગળ વધો અને અમુક કોડ ઉદાહરણ અહીં ખોલો.

397
00:23:55,690 --> 00:23:58,120
હું gedit ખોલો, પડશે અને દો મને બે ફાઈલો પ્રથમ ખોલો.

398
00:23:58,120 --> 00:24:02,050
એક list1.h છે, અને દો મને ફક્ત યાદ છે કે આ કોડના ભાગ હતો

399
00:24:02,050 --> 00:24:04,920
કે અમે નોડ પ્રતિનિધિત્વ ઉપયોગ થાય છે.

400
00:24:04,920 --> 00:24:13,040
એક નોડ બંને n એ પૂર્ણાંક તરીકે ઓળખાય છે અને નિર્દેશક કે જે હમણાં જ પોઇન્ટ આગામી યાદીમાં આગામી વસ્તુ કહેવામાં આવે છે.

401
00:24:13,040 --> 00:24:15,450
કે જે ક. ફાઈલ હવે છે. શા માટે?

402
00:24:15,450 --> 00:24:19,090
આ સંમેલન છે, અને અમે લાભ આ નથી વિશાળ જથ્થો જાતને લેવામાં આવે છે,

403
00:24:19,090 --> 00:24:22,220
પરંતુ જે વ્યક્તિ printf અને અન્ય કાર્યો લખ્યું હતું

404
00:24:22,220 --> 00:24:27,150
વિશ્વમાં એક ભેટ તરીકે stdio.h તરીકે ઓળખાતી ફાઈલ લખીને તે તમામ કાર્યોને આપી હતી.

405
00:24:27,150 --> 00:24:30,950
અને પછી ત્યાં string.h છે, અને પછી ત્યાં map.h છે, અને ત્યાં આ તમામ ક ફાઈલો છે

406
00:24:30,950 --> 00:24:34,410
કે તમે અથવા જોઈ હોય તો કદાચ અન્ય લોકો દ્વારા લખવામાં ગાળા દરમિયાન ઉપયોગ થાય છે.

407
00:24:34,410 --> 00:24:38,470
ખાસ કરીને તે માં ક ફાઈલો છે. Typedefs જેમ માત્ર વસ્તુઓ છે

408
00:24:38,470 --> 00:24:42,310
અથવા વૈવિધ્યપૂર્ણ પ્રકારના અથવા સ્થિરાંકો જાહેરાતનો જાહેરાતનો.

409
00:24:42,310 --> 00:24:47,890
તમે હેડર ફાઈલો માં 'વિધેયો અમલીકરણો મૂકી નથી.

410
00:24:47,890 --> 00:24:50,570
તમે મૂકી, તેના બદલે, માત્ર તેમના પ્રોટોટાઇપ માટે.

411
00:24:50,570 --> 00:24:53,050
તમે વિશ્વના તેઓ શું જરૂર સાથે વસ્તુઓ તમે શેર કરવા માંગો છો મૂકી

412
00:24:53,050 --> 00:24:55,640
ક્રમમાં તેમની કોડ કમ્પાઈલ કરવા માટે. તેથી ફક્ત આ ટેવ પ્રવેશ મેળવવા માટે,

413
00:24:55,640 --> 00:24:59,110
અમે આ જ વસ્તુ કરવાના નિર્ણય કર્યો છે. ત્યાં ખૂબ list1.h માં નથી,

414
00:24:59,110 --> 00:25:02,070
પરંતુ અમે વિશ્વમાં કંઈક રસ હોઈ શકે લોકો મૂક્યો છે

415
00:25:02,070 --> 00:25:05,030
જે અમારા સંલગ્ન યાદી અમલીકરણ ઉપયોગ કરવા માંગો છો.

416
00:25:05,030 --> 00:25:08,040
હવે, list1.c માં, હું આ આખી વસ્તુ મારફતે જશે

417
00:25:08,040 --> 00:25:11,390
કારણ કે તે એક બીટ લાંબો છે, આ કાર્યક્રમ દો, પરંતુ તે વાસ્તવિક પ્રોમ્પ્ટ પર ઝડપથી ચાલે છે.

418
00:25:11,390 --> 00:25:15,720
મને list1 કમ્પાઇલ, દો મને પછી list1 ચલાવો, અને તમે શું જોશો છે

419
00:25:15,720 --> 00:25:18,070
અમે બનાવટી સરળ અહીં થોડું કાર્યક્રમ કરેલા

420
00:25:18,070 --> 00:25:20,990
કે મને ઉમેરો અને એક યાદી નંબરો દૂર કરવા માટે પરવાનગી આપે બનશે.

421
00:25:20,990 --> 00:25:24,310
તેથી દો મને આગળ વધો અને મેનુ વિકલ્પ 3 માટે 3 લખો.

422
00:25:24,310 --> 00:25:27,880
હું નંબર દાખલ કરવા માંગો છો - ચાલો પ્રથમ નંબર છે, કે જે 9 હતી કરવા માટે,

423
00:25:27,880 --> 00:25:30,550
અને હવે મને કહેવામાં છું યાદીમાં હવે 9.

424
00:25:30,550 --> 00:25:33,760
મને આગળ વધો અને અન્ય નિવેશ કરવા માટે, જેથી હું મેનુ 3 વિકલ્પ નહીં.

425
00:25:33,760 --> 00:25:36,760
શું નંબર હું સામેલ કરવા માંગો છો? 17.

426
00:25:36,760 --> 00:25:39,220
દાખલ કરો. અને હું એક માત્ર વધારે કરીશ.

427
00:25:39,220 --> 00:25:41,720
ચાલો હું 22 નંબર દાખલ કરો.

428
00:25:41,720 --> 00:25:45,850
તેથી અમે સંકળાયેલા યાદી છે કે અમે સ્લાઇડ ફોર્મ માં ક્ષણ પહેલા હતા શરૂઆત છે.

429
00:25:45,850 --> 00:25:48,740
આ કેવી રીતે દાખલ ખરેખર શું થઈ રહ્યું છે?

430
00:25:48,740 --> 00:25:52,000
ખરેખર, 22 યાદી ઓવરને અંતે હવે છે.

431
00:25:52,000 --> 00:25:55,050
વાર્તા કે જેથી અમે સોમવારે સ્ટેજ પર જણાવ્યું હતું અને માત્ર હવે recapped

432
00:25:55,050 --> 00:25:57,460
વાસ્તવમાં કોડ થતું હોવા જ જોઈએ.

433
00:25:57,460 --> 00:25:59,700
ચાલો એક નજર નાખો. મને આ ફાઈલમાં સરકાવો.

434
00:25:59,700 --> 00:26:01,720
અમે ઉપર કેટલાક કાર્યોને ચળકાટ પડશે,

435
00:26:01,720 --> 00:26:05,630
પરંતુ અમે નીચે જાય છે, કહેવું પડશે, જે insert કાર્ય કરે છે.

436
00:26:05,630 --> 00:26:11,720
>> ચાલો કેવી રીતે અમે આ યાદીની લિંક એક નવી નોડ દાખલ વિશે જાઓ.

437
00:26:11,720 --> 00:26:14,550
જ્યાં યાદી જાહેર કરવામાં આવે છે? વેલ, ચાલો ટોચ પર તમામ માર્ગ ઉપર સ્ક્રોલ કરો,

438
00:26:14,550 --> 00:26:19,970
નોટિસ અને કે મારા યાદીની લિંક અનિવાર્યપણે એક નિર્દેશક, જે શરૂઆતમાં NULL છે જાહેર છે.

439
00:26:19,970 --> 00:26:23,180
તેથી હું વૈશ્વિક ચલ ઉપયોગ કરું છું, અહીં છે, કે જે સામાન્ય રીતે આપણે સામે ઉપદેશ કર્યો છે

440
00:26:23,180 --> 00:26:25,280
કારણ કે તે તમારા કોડ બનાવે છે થોડું ગંદું જાળવણી,

441
00:26:25,280 --> 00:26:29,080
તે સુસ્ત, સામાન્ય રીતે જેવું નથી, પણ તે આળસુ અને નથી તે ખોટું નથી અને તે ખરાબ નથી

442
00:26:29,080 --> 00:26:33,660
જો તમારા કાર્યક્રમ જીવનમાં એકમાત્ર હેતુ માટે એક સંલગ્ન યાદી અનુકરણ છે.

443
00:26:33,660 --> 00:26:35,460
જે બરાબર શું અમે કરી રહ્યા છીએ.

444
00:26:35,460 --> 00:26:39,100
તેથી બદલે મુખ્ય આ જાહેર અને પછી તે દરેક કાર્ય પસાર છે

445
00:26:39,100 --> 00:26:42,640
અમે આ કાર્યક્રમ માં લખાયેલ કર્યું છે, અમે કરવાને બદલે જે તે ઓહ, ચાલો તેને વૈશ્વિક બનાવવા

446
00:26:42,640 --> 00:26:47,060
કારણ કે આ કાર્યક્રમ સમગ્ર હેતુ માટે એક અને માત્ર એક જ કડી થયેલ યાદી દર્શાવવાનો છે.

447
00:26:47,060 --> 00:26:50,700
જેથી ઠીક લાગે છે. અહીં મારા પ્રોટોટાઇપ છે, અને અમે આ બધી મારફતે જશે,

448
00:26:50,700 --> 00:26:55,800
પણ હું એક કાઢી નાખો કાર્ય, એક કાર્ય શોધવા માટે, એક insert કાર્ય છે, અને આડાશ કાર્ય લખ્યું હતું.

449
00:26:55,800 --> 00:26:59,080
દો પરંતુ હવે insert કાર્ય પર પાછા ડૂબવું

450
00:26:59,080 --> 00:27:01,490
જુઓ અને કેવી રીતે આ એક અહીં કામ કરે છે.

451
00:27:01,490 --> 00:27:09,940
Insert રેખા પર છે - અહીં અમે જાઓ.

452
00:27:09,940 --> 00:27:12,850
દાખલ કરો. જેથી કોઇ પણ દલીલો ન લો કરતું નથી, કારણ કે અમે કહી રહ્યા છીએ

453
00:27:12,850 --> 00:27:15,930
નંબર તેઓ સામેલ કરવા માંગો છો માટે આ કાર્યનો એક વપરાશકર્તા અંદર.

454
00:27:15,930 --> 00:27:19,410
પરંતુ પ્રથમ, અમે તેમને કેટલાક જગ્યા આપવી તૈયાર.

455
00:27:19,410 --> 00:27:22,050
આ અને અન્ય ઉદાહરણ માંથી નકલ પેસ્ટ જેવું છે.

456
00:27:22,050 --> 00:27:25,110
તે કિસ્સામાં, અમે પૂર્ણાંક allocating હતી; આ સમય અમે નોડ allocating કરી રહ્યાં છો.

457
00:27:25,110 --> 00:27:27,910
હું ખરેખર કેટલી બાઇટ્સ નોડ છે યાદ નથી, પરંતુ તે દંડ છે.

458
00:27:27,910 --> 00:27:30,460
Sizeof કે મારા માટે બહાર આકૃતિ કરી શકો છો.

459
00:27:30,460 --> 00:27:33,340
અને શા માટે હું 120 લીટી માં NULL માટે ચકાસે છે?

460
00:27:33,340 --> 00:27:37,530
શું 119 લીટી માં ખોટી જઈ શકે છે? યાહ?

461
00:27:37,530 --> 00:27:40,530
[વિદ્યાર્થી જવાબ, દુર્બોધ]

462
00:27:40,530 --> 00:27:43,440
ગુડ. માત્ર કેસ કે હું ઘણી બધી મેમરીનો માટે પૂછ્યું છે હોઈ શકે

463
00:27:43,440 --> 00:27:47,020
અથવા કંઈક ખોટું અને ઓપરેટિંગ સિસ્ટમ માટે પૂરતી મને આપી બાઇટ્સ નથી,

464
00:27:47,020 --> 00:27:50,640
તેથી તે NULL પરત દ્વારા તેટલી નહીં, અને જો હું કે ન તપાસ નથી

465
00:27:50,640 --> 00:27:54,710
અને હું માત્ર અકારણ ઉપયોગ કરવા માટે સરનામાં પરત આગળ વધવું તે NULL હોઈ શકે છે.

466
00:27:54,710 --> 00:27:58,400
કેટલાક અજ્ઞાત કિંમત હોઈ શકે છે; સારું ન વાત એ સિવાય હું -

467
00:27:58,400 --> 00:28:00,590
ખરેખર એક અજ્ઞાત કિંમત હશે નહિં. તે NULL હોઇ શકે છે, તેથી હું નથી માંગતા

468
00:28:00,590 --> 00:28:02,550
તેને અપશબ્દો અને તે dereferencing જોખમ રહે છે.

469
00:28:02,550 --> 00:28:07,410
જો આવું થાય છે, હું હમણાં જ પાછા આવો અને અમે જેમ હું કોઇપણ મેમરી નથી બધા ડોળ કરવો પડશે.

470
00:28:07,410 --> 00:28:12,270
>> નહિંતર, હું કહી વપરાશકર્તા મને એક દાખલ નંબર આપી, હું અમારા જૂના મિત્ર GetInt કહી,

471
00:28:12,270 --> 00:28:15,530
અને પછી આ નવા વાક્યરચના અમે સોમવારે રજૂ કરવામાં આવી હતી.

472
00:28:15,530 --> 00:28:20,320
'Newptr-> એન' સરનામું લેવા કે તમે malloc દ્વારા આપવામાં આવી હતી અર્થ થાય છે

473
00:28:20,320 --> 00:28:23,490
જેમાં નવી નોડ પદાર્થ પ્રથમ બાઇટ દર્શાવે છે,

474
00:28:23,490 --> 00:28:26,860
અને પછી n એ કહેવાય ક્ષેત્ર પર જાઓ.

475
00:28:26,860 --> 00:28:35,270
થોડું નજીવી વસ્તુઓ પ્રશ્ન: આ શું કોડ વધુ ભેદી વાક્ય સમકક્ષ છે?

476
00:28:35,270 --> 00:28:38,110
બીજું હું આ કેવી રીતે હોય તેવા પરચૂરણ ખર્ચ કરી શકે છે? માટે ઘણો પ્રયાસ કર્યો લેવા માંગો છો?

477
00:28:38,110 --> 00:28:41,480
[વિદ્યાર્થી જવાબ, દુર્બોધ]

478
00:28:41,480 --> 00:28:44,870
ગુડ. આ એન. મદદથી, પરંતુ તે તદ્દન તરીકે આ સરળ નથી.

479
00:28:44,870 --> 00:28:47,090
હું શું પ્રથમ જરૂર નથી કરી શકું? [વિદ્યાર્થી જવાબ, દુર્બોધ]

480
00:28:47,090 --> 00:28:52,730
ગુડ. હું * newptr.n કરવાની જરૂર છે.

481
00:28:52,730 --> 00:28:55,610
તેથી આ કહેતા છે નવા નિર્દેશક ચોક્કસપણે એક સરનામું છે. શા માટે?

482
00:28:55,610 --> 00:28:59,520
કારણ કે તે malloc દ્વારા પરત ફર્યા હતા. આ * કહેતા newptr "ત્યાં જાઓ,"

483
00:28:59,520 --> 00:29:02,970
અને પછી એકવાર તમે ત્યાં છો, તો પછી તમે વધુ પરિચિત એન. ઉપયોગ કરી શકો છો,

484
00:29:02,970 --> 00:29:05,730
પરંતુ આ થોડી નીચ લાગે છે, ખાસ કરીને જો આપણે મનુષ્યો જોઈ રહ્યા છે

485
00:29:05,730 --> 00:29:10,360
તીરો સાથે તમામ સમય પોઇંટરો દોરવા; વિશ્વમાં આ તીર પર સંકેતલિપિ પ્રમાણિત છે,

486
00:29:10,360 --> 00:29:12,320
જે બરાબર આ જ વાત કરે છે.

487
00:29:12,320 --> 00:29:16,070
સંકેતલિપિ> જ્યારે ડાબી બાજુ વસ્તુ એક નિર્દેશક છે - જેથી તમે માત્ર વાપરો.

488
00:29:16,070 --> 00:29:18,790
નહિંતર, જો તે વાસ્તવિક સ્ટ્રક્ટ છે, જે એન. વાપરો.

489
00:29:18,790 --> 00:29:25,800
અને પછી આ હું newptr-> આગામી શા પ્રારંભ નથી નલ માટે?

490
00:29:25,800 --> 00:29:28,610
અમે સ્ટેજ ઓવરને એક dangling ડાબા હાથમાં બોલ કરવા નથી માંગતા.

491
00:29:28,610 --> 00:29:31,630
અમે તે સીધો જ નીચે તરફ પોઇન્ટ માંગો છો, કે જે આ યાદી ઓવરને અર્થ થાય છે

492
00:29:31,630 --> 00:29:34,980
સંભવિત આ નોડ પર હોઇ શકે છે, તેથી અમે વધુ સારી રીતે ખાતરી કરો કે તે NULL છે.

493
00:29:34,980 --> 00:29:38,460
અને, સામાન્ય રીતે, તમારા ચલો અથવા તમારા દશાંશ માહિતી સભ્યો અને સ્ટ્ર્ક્ટ્સ પ્રારંભ

494
00:29:38,460 --> 00:29:40,470
કંઈક કરવા માટે માત્ર સારો પ્રયાસ છે.

495
00:29:40,470 --> 00:29:45,170
જસ્ટ ભાડા કચરો અસ્તિત્વ ધરાવે છે અને સામાન્ય રીતે ચાલુ રહી છે તમે મુશ્કેલીમાં નોંધાયો નહીં

496
00:29:45,170 --> 00:29:48,650
જો તમે કંઈક પર પછીથી કરો ભૂલી જાવ.

497
00:29:48,650 --> 00:29:51,590
>> અહીં કેટલીક કિસ્સાઓમાં છે. આ ફરીથી, આ insert કાર્ય છે,

498
00:29:51,590 --> 00:29:54,930
અને પ્રથમ વસ્તુ હું ચકાસવા માટે છે જો ચલ પ્રથમ કહેવાય છે,

499
00:29:54,930 --> 00:29:58,240
કે વૈશ્વિક ચલ NULL છે, તેનો અર્થ એ કે ત્યાં કોઈ કડી થયેલ યાદી છે.

500
00:29:58,240 --> 00:30:02,460
અમે કોઈપણ નંબર્સ દાખલ કરી છે, તેથી તેને તુચ્છ છે આ વર્તમાન નંબર દાખલ કરો

501
00:30:02,460 --> 00:30:05,240
આ યાદી માં, કારણ કે તે માત્ર યાદી શરૂઆતમાં અનુસરે છે.

502
00:30:05,240 --> 00:30:08,100
તેથી આ હતા ત્યારે અનિતા હમણાં હતી અહીં એકલા ઊભા હોવાનો ઢોંગ

503
00:30:08,100 --> 00:30:11,390
કોઇ અહીં મંચ પર ત્યાં સુધી અમે એક નોડ ફાળવવામાં આવી હતી,

504
00:30:11,390 --> 00:30:13,940
પછી તે પ્રથમ વખત તેણીના હાથ ઊંચો લાવી શક્યા હોત,

505
00:30:13,940 --> 00:30:17,420
જો બીજું દરેકને અપ સ્ટેજ પર આવવું પડ્યું સોમવારે તેના પછી.

506
00:30:17,420 --> 00:30:22,900
હવે અહીં, આ થોડું ચેક જ્યાં હું કહેવા છે જો n ના નવા નોડ કિંમત

507
00:30:22,900 --> 00:30:27,370
છે વર્તમાન પ્રથમ નોડમાં n ના કિંમત <,

508
00:30:27,370 --> 00:30:29,930
તેનો અર્થ એ કે ત્યાં સંકળાયેલી યાદી છે કે જે શરૂ કરવામાં આવ્યું છે તે છે.

509
00:30:29,930 --> 00:30:32,330
ત્યાં યાદીમાં ઓછામાં ઓછી એક નોડ છે, પરંતુ આ નવી વ્યક્તિ

510
00:30:32,330 --> 00:30:37,230
અનુલક્ષે તે પહેલાં, તેથી અમે વસ્તુઓ ફરતે ખસેડવા માટે જરૂર છે.

511
00:30:37,230 --> 00:30:43,450
અન્ય શબ્દોમાં, જો યાદી માત્ર સાથે શરૂ કરી છે, ચાલો કહે,

512
00:30:43,450 --> 00:30:48,100
માત્ર 17 નંબર, કે છે - વાસ્તવમાં, અમે આ વધુ સ્પષ્ટ કરી શકો છો.

513
00:30:48,100 --> 00:30:56,010
જો અમે અહીં એક નિર્દેશક પ્રથમ કહેવાય સાથે અમારી વાર્તા શરૂ કરવા માટે,

514
00:30:56,010 --> 00:30:59,870
અને પ્રારંભમાં તેને NULL છે, અને અમે 9 નંબર દાખલ કરો,

515
00:30:59,870 --> 00:31:02,510
આ 9 નંબર સ્પષ્ટ યાદી શરૂઆતમાં અનુસરે છે.

516
00:31:02,510 --> 00:31:07,400
તેથી આપણે ડોળ અમે ફક્ત સરનામું અથવા 9 નંબર malloced અને તેને અહીં મૂકો.

517
00:31:07,400 --> 00:31:13,170
જો પ્રથમ 9 મૂળભૂત છે, પ્રથમ દૃશ્ય અમે ચર્ચા માત્ર લેટ્સ બિંદુ આ વ્યક્તિ અહીં અર્થ છે,

518
00:31:13,170 --> 00:31:15,790
આ NULL રજા, હવે અમે 9 નંબર હોય છે.

519
00:31:15,790 --> 00:31:18,280
આગામી નંબર અમે સામેલ કરવા માંગો છો 17 છે.

520
00:31:18,280 --> 00:31:22,420
17 ઉપર અહીં અનુલક્ષે છે, તેથી અમે આ મારફતે કેટલાક તાર્કિક આધાર હોય તો જઈ રહ્યાં છો.

521
00:31:22,420 --> 00:31:26,060
તેથી તેના બદલે દો, પહેલાં અમે કે, ચાલો ડોળ કરવો કે અમે 8 નંબર દાખલ કરવા ઈચ્છતા.

522
00:31:26,060 --> 00:31:28,650
>> તેથી સગવડ ખાતર જ હું અહીં દોરવા જાઉં છું.

523
00:31:28,650 --> 00:31:30,760
પરંતુ યાદ રાખો, malloc તે સૌથી ગમે ત્યાં મૂકી શકો છો.

524
00:31:30,760 --> 00:31:33,460
પરંતુ ચિત્ર ખાતર, હું તેને અહીં મૂકીશું.

525
00:31:33,460 --> 00:31:38,440
તેથી ડોળ હું માત્ર 8 નંબર માટે નોડ ફાળવવામાં કર્યું છે; આ મૂળભૂત દ્દારા NULL છે.

526
00:31:38,440 --> 00:31:42,800
શું હવે થાય છે? વસ્તુઓ એક દંપતિ.

527
00:31:42,800 --> 00:31:47,090
અમે સ્ટેજ પર સોમવારે આ ભૂલ જ્યાં અમે આ જેવા નિર્દેશક સુધારાશે કર્યો હતો,

528
00:31:47,090 --> 00:31:51,890
તો પછી આ કર્યું, અને પછી અમે એવો દાવો કર્યો હતો - અમે સ્ટેજ પર દરેક વ્યક્તિને અનાથ.

529
00:31:51,890 --> 00:31:54,350
કારણ કે તમે can't - અહીં કામગીરી ક્રમ મહત્વનો છે,

530
00:31:54,350 --> 00:31:58,760
હવે કારણ કે અમે આ નોડ 9 કે જે હમણાં જ જગ્યા ફ્લોટિંગ જેવું છે ગુમાવ્યું છે.

531
00:31:58,760 --> 00:32:01,150
તેથી આ સોમવાર પર યોગ્ય અભિગમ ન હતી.

532
00:32:01,150 --> 00:32:03,330
અમે પ્રથમ કંઈક બીજું શું હોય છે.

533
00:32:03,330 --> 00:32:06,280
વિશ્વના રાજ્ય આ જેવો દેખાય છે. શરૂઆતમાં, 8 ફાળવવામાં આવ્યો છે.

534
00:32:06,280 --> 00:32:10,550
શું 8 દાખલ સારી રીતે હશે?

535
00:32:10,550 --> 00:32:14,720
તેના બદલે આ નિર્દેશક પ્રથમ સુધારવાના, ફક્ત આ અહીં એક જગ્યાએ સુધારો.

536
00:32:14,720 --> 00:32:17,720
તેથી અમે કોડ એક વાક્ય છે કે આ NULL અક્ષર ચાલુ રહ્યું છે જરૂર

537
00:32:17,720 --> 00:32:22,020
એક વાસ્તવિક નિર્દેશક જે 9 ગાંઠ પર પોઇન્ટ છે માં,

538
00:32:22,020 --> 00:32:27,970
અને પછી અમે સુરક્ષિત રીતે પ્રથમ બદલવા માટે આ વ્યક્તિ અંતે અહીં નિર્દેશ કરી શકો છો.

539
00:32:27,970 --> 00:32:31,330
હવે અમે એક યાદી, બે ઘટકો એક કડી થયેલ યાદી હોય છે.

540
00:32:31,330 --> 00:32:33,580
અને આ ખરેખર શું નથી અહીં જેમ દેખાય છે?

541
00:32:33,580 --> 00:32:36,900
જો આપણે કોડ જોવા નોટિસ, કે હું કે બરાબર કર્યું છે.

542
00:32:36,900 --> 00:32:41,970
મેં કહ્યું કર્યું છે newptr, અને આ વાર્તામાં, newptr આ વ્યક્તિ તરફ આવી હતી.

543
00:32:41,970 --> 00:32:45,520
>> તેથી દો મને એક વધુ નાની ચીજ દોરવા, અને હું આ માટે થોડી વધુ જગ્યા બાકી છે કરીશું.

544
00:32:45,520 --> 00:32:48,540
જેથી નાના થોડું રેખાંકન ક્ષમા.

545
00:32:48,540 --> 00:32:52,140
આ વ્યક્તિ newptr કહેવામાં આવે છે.

546
00:32:52,140 --> 00:32:57,940
25 ઉપર માત્ર - કે ચલ અમે થોડા લીટીઓ અગાઉ લીટી માં જાહેર છે.

547
00:32:57,940 --> 00:33:03,430
અને તે 8 થી પોઇન્ટ છે. તેથી જ્યારે હું newptr-> આગામી કહે છે કે અર્થ એ થાય કે સ્ટ્રક્ટ પર જાઓ

548
00:33:03,430 --> 00:33:07,910
કે newptr દ્વારા કરવામાં આવી રહી છે અંતે નિર્દેશ છે, તેથી અહીં અમે હોય છે, ત્યાં જાઓ.

549
00:33:07,910 --> 00:33:13,990
પછી તીર કહેતા છે આગામી ક્ષેત્ર વિચાર છે, અને પછી = કહેતા છે શું કિંમત મૂકવા ત્યાં?

550
00:33:13,990 --> 00:33:17,280
આ કિંમત છે કે જે પ્રથમ હતો; કિંમત શું પ્રથમ હતો?

551
00:33:17,280 --> 00:33:21,930
આ નોડ પર પોઇન્ટ હતી, તેથી તેનો અર્થ એ કે આ હવે આ નોડ પર નિર્દેશ કરીશું.

552
00:33:21,930 --> 00:33:25,660
અન્ય શબ્દોમાં, શું મારા હસ્તાક્ષર સાથે હાસ્યાસ્પદ વાસણ જોકે લાગે છે,

553
00:33:25,660 --> 00:33:28,620
માત્ર આસપાસ આ તીર જવાનું સરળ વિચાર શું છે

554
00:33:28,620 --> 00:33:31,560
ફક્ત આ એક લાઇનર સાથે કોડ થીં.

555
00:33:31,560 --> 00:33:38,110
સ્ટોર શું આગામી ક્ષેત્રમાં પ્રથમ છે અને પછી અપડેટ પ્રથમ ખરેખર શું છે.

556
00:33:38,110 --> 00:33:40,900
ચાલો આ અમુક મારફતે આગળ અને ઝડપથી આગળ જવા,

557
00:33:40,900 --> 00:33:44,220
અને આ પૂંછડી નિવેશ પર માત્ર હવે જુઓ.

558
00:33:44,220 --> 00:33:51,210
ધારો કે હું બિંદુ જ્યાં હું શોધવા કે અમુક નોડ આગળના ક્ષેત્ર NULL છે મેળવો.

559
00:33:51,210 --> 00:33:53,410
અને વાર્તા, એક વિગતવાર આ બિંદુએ કે હું પર glossing છું

560
00:33:53,410 --> 00:33:58,170
છે કે હું અન્ય નિર્દેશક રચના કરી છે અપ 142 લાઇન, પુરોગામી નિર્દેશક અહીં.

561
00:33:58,170 --> 00:34:01,320
આવશ્યકપણે, વાર્તામાં આ બિંદુએ, એક વાર યાદી લાંબી નહીં,

562
00:34:01,320 --> 00:34:04,800
હું પ્રકારની તેને બે આંગળીઓ સાથે ચાલવા જરૂર જો હું ખૂબ દૂર જવા કારણ કે,

563
00:34:04,800 --> 00:34:08,219
એક યાદી એક લંબાઈ યાદ રાખો કે, તમે પાછળની જઈ શકો નહિં.

564
00:34:08,219 --> 00:34:13,659
તેથી predptr આ વિચાર મારા ડાબા આંગળી છે, અને newptr - newptr નથી.

565
00:34:13,659 --> 00:34:17,199
અન્ય નિર્દેશક કે અહીં મારા અન્ય આંગળી છે, અને હું માત્ર યાદી વૉકિંગ પ્રકારની છું.

566
00:34:17,199 --> 00:34:22,179
કે શા માટે છે કે જે અસ્તિત્વમાં છે. દો પરંતુ માત્ર એક સરળ અહીં કેસો નક્કી કરો.

567
00:34:22,179 --> 00:34:26,620
જો કે નિર્દેશક આગામી ક્ષેત્ર NULL છે, લોજીકલ સૂચિતાર્થ શું છે?

568
00:34:26,620 --> 00:34:30,840
જો તમે આ યાદી સરકાઉ છે અને તમે એક NULL નિર્દેશક ફટકો?

569
00:34:30,840 --> 00:34:35,780
તમે યાદીમાં ઓવરને અંતે કરશો, અને તેથી કોડ તો પછી આ એક વધારાની તત્વ ઉમેરી માટે

570
00:34:35,780 --> 00:34:41,230
છે સાહજિક જેવું કે નોડ આગામી જેના નિર્દેશક NULL છે લઈ જશે,

571
00:34:41,230 --> 00:34:46,120
તેથી આ હાલમાં NULL છે, અને તે બદલવા માટે, જોકે, નવા નોડને સરનામું.

572
00:34:46,120 --> 00:34:52,260
તેથી અમે માત્ર કોડ માં તીર રેખાંકન કરી રહ્યા છો કે અમે કોઈના ડાબા હાથની એકત્ર દ્વારા સ્ટેજ પર આધારિત હતી.

573
00:34:52,260 --> 00:34:54,070
>> અને આ કેસ કે હું હવે મારા હાથમાં મોજા પડશે,

574
00:34:54,070 --> 00:34:58,020
, ફક્ત કારણ કે મને લાગે છે કે તે સરળ છે હારી કરો ત્યારે અમે તેને પર્યાવરણ આ પ્રકારની શું

575
00:34:58,020 --> 00:35:00,600
એ યાદી મધ્યમ અંતે નિવેશ માટે ચકાસે.

576
00:35:00,600 --> 00:35:03,220
પરંતુ ફક્ત તર્ક, શું કરવા જરૂર છે જો તમે બહાર આકૃતિ માંગો છો

577
00:35:03,220 --> 00:35:06,600
જ્યાં અમુક નંબર મધ્યમાં રહેલો હોય છે તો તમે તેને ચાલવા હોય

578
00:35:06,600 --> 00:35:09,510
એક કરતાં વધુ આંગળી સાથે એક કરતાં વધુ નિર્દેશક,

579
00:35:09,510 --> 00:35:12,920
બહાર આકૃતિ જ્યાં તે ચકાસણી દ્વારા અનુલક્ષે એ તત્વ છે <વર્તમાન એક,

580
00:35:12,920 --> 00:35:15,450
> વર્તમાન એક છે, અને એક વખત તમે તે સ્થાન શોધો,

581
00:35:15,450 --> 00:35:20,400
પછી તમે શેલ રમત આ પ્રકારની કરી છે કે જ્યાં તમે પોઇંટરો આસપાસ ખૂબ કાળજીપૂર્વક ખસેડવા હોય છે.

582
00:35:20,400 --> 00:35:23,850
અને તે જવાબ, જો તમે આ મારફતે તમારા પોતાના પર ઘરે કારણ માંગતા હો,

583
00:35:23,850 --> 00:35:28,340
માત્ર કોડ કે આ બે લીટીઓ માટે નીચે ઉકળે છે, પરંતુ તે રેખાઓ છે તે ક્રમમાં સુપર મહત્વપૂર્ણ છે.

584
00:35:28,340 --> 00:35:31,390
કારણ કે જો તમે કોઈની હાથ છોડી દે છે અને એકત્ર કોઈએ ખોટા ક્રમમાં છે,

585
00:35:31,390 --> 00:35:34,580
ફરીથી, તમે અંત યાદી orphaning શકે છે.

586
00:35:34,580 --> 00:35:39,500
વધુ સરળ રીતે સંક્ષેપમાં પૂંછડી પર દાખલ પ્રમાણમાં સરળ હોય છે.

587
00:35:39,500 --> 00:35:42,940
માથા પર દાખલ પણ પ્રમાણમાં સરળ,

588
00:35:42,940 --> 00:35:45,580
પરંતુ તમે વધારાની નિર્દેશક આ સમયે અપડેટ કરવાની જરૂર

589
00:35:45,580 --> 00:35:47,930
આ યાદીમાં 5 નંબર અહીં સ્વીઝ,

590
00:35:47,930 --> 00:35:51,560
અને પછી મધ્યમાં નિવેશ પણ વધુ પ્રયાસ સમાવેશ થાય છે,

591
00:35:51,560 --> 00:35:56,130
ખૂબ જ કાળજીપૂર્વક તેની યોગ્ય સ્થાન માં 20 નંબર દાખલ કરો,

592
00:35:56,130 --> 00:35:58,350
જે 17 અને 22 ની વચ્ચે હોય છે.

593
00:35:58,350 --> 00:36:02,700
જેથી તમે 22 થી નવી નોડ 20 પોઇન્ટ ધરાવે છે કંઈક કરવાની જરૂર છે,

594
00:36:02,700 --> 00:36:08,470
અને પછી, જે નોડ નિર્દેશક માટે છેલ્લા સુધારાની જરૂર છે?

595
00:36:08,470 --> 00:36:10,630
તે 17 છે, ખરેખર તે દાખલ કરો.

596
00:36:10,630 --> 00:36:14,080
તેથી ફરી, હું ચોક્કસ અમલ માટે વાસ્તવિક કોડ મુલતવી રાખવું પડશે.

597
00:36:14,080 --> 00:36:17,280
>> પ્રથમ નજરમાં, તે થોડી જબરજસ્ત છે, પરંતુ તે ખરેખર માત્ર એક અનંત લૂપ છે

598
00:36:17,280 --> 00:36:21,770
કે રહ્યાં, તે જ રહ્યાં, રહ્યાં, રહ્યાં છે, અને ટૂંક સમયમાં ભંગ તરીકે તમે NULL નિર્દેશક દબાવો,

599
00:36:21,770 --> 00:36:24,590
જે બિંદુએ તમે જરૂરી નિવેશ કરી શકો છો.

600
00:36:24,590 --> 00:36:30,960
આ પછી, પ્રતિનિધિ યાદીની લિંક ઉમેરો કોડ છે.

601
00:36:30,960 --> 00:36:34,590
ઘણી પ્રકારની હતી, અને તે લાગે છે જેમ આપણે એક સમસ્યા ઉકેલી લીધી છે,

602
00:36:34,590 --> 00:36:36,940
પરંતુ અમે એક સંપૂર્ણ અન્ય એક રચના કરી છે. પ્રમાણિકપણે, અમે આ બધા સમય ગાળ્યો કર્યા છે

603
00:36:36,940 --> 00:36:40,540
મોટું ઓ અને Ω પર અને સમય ચાલી, જે સમસ્યાઓ હલ કરવાનો પ્રયાસ કરી વધુ ઝડપથી,

604
00:36:40,540 --> 00:36:43,270
અને અહીં આપણે એક મોટું પગલું લેતા પાછળની, તે લાગે છે.

605
00:36:43,270 --> 00:36:45,380
અને હજુ સુધી, જો ધ્યેય માહિતી સંગ્રહવા છે,

606
00:36:45,380 --> 00:36:48,010
તે પવિત્ર ગ્રેઈલ જેવી લાગે છે, કારણ કે અમે સોમવારે જણાવ્યું હતું કે, ખરેખર હશે

607
00:36:48,010 --> 00:36:50,470
વસ્તુઓ તરત સ્ટોર કરે છે.

608
00:36:50,470 --> 00:36:53,930
>> હકીકતમાં ધારવું, કે જે આપણે મૂકવા એક ક્ષણ માટે કોરે યાદીની લિંક કર્યું

609
00:36:53,930 --> 00:36:56,000
અને અમે તેના બદલે એક ટેબલ વિચારને રજૂ કર્યો હતો.

610
00:36:56,000 --> 00:36:59,110
અને એક એરે તરીકે ક્ષણ માટે આપણે માત્ર એક ટેબલ લાગે છે.

611
00:36:59,110 --> 00:37:03,790
આ એરે અને આ કેસ અહીં 26 કેટલાક ઘટકોને 0 25 મારફતે ધરાવે છે,

612
00:37:03,790 --> 00:37:07,940
ધારવું અને તમે નામો માટે સંગ્રહ કેટલાક ભાગ જરૂરી:

613
00:37:07,940 --> 00:37:10,350
એલિસ અને બોબ અને ચાર્લી અને જેમ.

614
00:37:10,350 --> 00:37:12,880
અને તમે અમુક માહિતી માળખું જરૂર તે નામો સ્ટોર કરે છે.

615
00:37:12,880 --> 00:37:15,000
સારું, તમે એક કડી થયેલ યાદી કંઈક ઉપયોગ કરી શકે છે

616
00:37:15,000 --> 00:37:20,260
અને તમે બોબ અને બોબ બાદ ચાર્લી પહેલા એલિસ દાખલ યાદી ચાલવા અને તેથી આગળ કરી શકે છે.

617
00:37:20,260 --> 00:37:23,850
અને હકીકતમાં, જો તમે એક અલગ તરીકે કે જેવી કોડ જોવા માંગો છો,

618
00:37:23,850 --> 00:37:27,230
ખબર છે કે list2.h માં, અમે તે બરાબર નથી.

619
00:37:27,230 --> 00:37:30,610
અમે આ કોડ દ્વારા ન જાય, પરંતુ આ પ્રથમ ઉદાહરણ એક ચલ છે

620
00:37:30,610 --> 00:37:34,640
કે એક અન્ય સ્ટ્રક્ટ અમે કહેવાતા વિદ્યાર્થી પહેલા જોયેલા પરિચય આપે છે,

621
00:37:34,640 --> 00:37:40,330
અને પછી તે વાસ્તવમાં સંલગ્ન યાદીમાં સંગ્રહ કરે છે કે કયા વિદ્યાર્થી માળખું એક નિર્દેશક છે

622
00:37:40,330 --> 00:37:44,520
કરતાં એક સરળ થોડું પૂર્ણાંક, એન.

623
00:37:44,520 --> 00:37:46,900
જેથી ખ્યાલ ત્યાં કોડ ત્યાં છે કે વાસ્તવિક શબ્દમાળાઓ સમાવેશ થાય છે,

624
00:37:46,900 --> 00:37:49,940
પરંતુ જો હાથ પર ધ્યેય ખરેખર હવે કાર્યક્ષમતા સમસ્યા હલ છે,

625
00:37:49,940 --> 00:37:53,380
સરસ નહિં હોય તે જો આપણે એક એલિસ કહેવાય પદાર્થ આપવામાં કરી રહ્યાં છો,

626
00:37:53,380 --> 00:37:56,020
અમે તેને એક માહિતી માળખામાં યોગ્ય સ્થાન મૂકવામાં માંગો છો,

627
00:37:56,020 --> 00:37:58,860
તે લાગે છે જેમ કે તે ખરેખર સરસ પ્રયત્ન માત્ર એલિસ મૂકવા માંગો છો,

628
00:37:58,860 --> 00:38:01,180
નામ જેની એક સાથે પ્રથમ સ્થાન છે, શરૂ થાય છે.

629
00:38:01,180 --> 00:38:05,270
અને બોબ, નામ જેની બી સાથે બીજા સ્થાને છે, શરૂ થાય છે.

630
00:38:05,270 --> 00:38:09,580
ઝાકઝમાળ સાથે દો, અથવા તે ટેબલ, કે જે એક હેશ ટેબલ કૉલ શરૂ કરવા માટે,

631
00:38:09,580 --> 00:38:13,650
અમે તે બરાબર કરી શકો છો. જો અમે એલિસ જેવું નામ આપવામાં આવે છે,

632
00:38:13,650 --> 00:38:16,700
એલિસ જેવું શબ્દમાળા છે, જ્યાં તમે એક-l-i-c-ઈ મૂકી શકું?

633
00:38:16,700 --> 00:38:20,540
અમે hueristic જરૂર છે. અમે એક કાર્ય કરવાની જરૂર એલિસ જેવા કેટલાક ઇનપુટ લઇ

634
00:38:20,540 --> 00:38:24,610
અને, એક જવાબ પાછા "આ સ્થાન પર એલિસ મૂકો."

635
00:38:24,610 --> 00:38:28,720
અને આ કાર્ય, આ બ્લેક બોક્સ માટે હેશ વિધેય કહેવાય રહ્યું છે.

636
00:38:28,720 --> 00:38:32,330
>> એક હેશ વિધેય કંઈક કે "એલિસ" ઇનપુટ લે છે, છે,

637
00:38:32,330 --> 00:38:38,080
અને તમે વળતર, સામાન્ય રીતે, અમુક માહિતી માળખામાં આંકડાકીય સ્થાન જ્યાં એલિસ અનુસરે છે.

638
00:38:38,080 --> 00:38:40,830
આ કિસ્સામાં, અમારા હેશ વિધેય પ્રમાણમાં સરળ પ્રયત્ન કરીશું.

639
00:38:40,830 --> 00:38:47,510
અમારા હેશ વિધેય કહે, જો તમે "એલિસ" છે, કે જે અક્ષર હું વિશે કાળજી કરીશું આપવામાં આવે છે જોઈએ?

640
00:38:47,510 --> 00:38:55,660
પ્રથમ એક. તેથી હું [0] જુઓ, અને પછી હું કહું છું જો [0] અક્ષર એક છે, જે 0 નંબર આવો.

641
00:38:55,660 --> 00:39:01,130
જો કે તે બી છે, 1 આવો. જો તે સી, 2 પરત છે, અને તેથી આગળ.

642
00:39:01,130 --> 00:39:05,940
બધા 0 અનુક્રમણિકા, અને તે મને એલિસ અને પછી બોબ અને પછી ચાર્લી દાખલ કરવા માટે પરવાનગી આપે છે અને તેથી આગળ કરશે

643
00:39:05,940 --> 00:39:10,960
આ માહિતી માળખામાં. પરંતુ તે એક સમસ્યા છે.

644
00:39:10,960 --> 00:39:13,060
જો અનિતા સાથે ફરીથી આવે છે?

645
00:39:13,060 --> 00:39:17,510
જ્યાં અમે અનિતા મૂકી શકું? તેનું નામ પણ અક્ષર એક સાથે શરૂ થાય છે,

646
00:39:17,510 --> 00:39:20,330
અને તે લાગે છે જેમ અમે આ સમસ્યા પણ મોટા વાસણ કર્યા છે.

647
00:39:20,330 --> 00:39:24,380
હવે અમે એ માહિતી બંધારણ માં તાત્કાલિક નિવેશ, સતત સમય નિવેશ હોય,

648
00:39:24,380 --> 00:39:27,100
ખરાબ કેસ બદલે રેખીય,

649
00:39:27,100 --> 00:39:29,510
પરંતુ અમે શું આ કિસ્સામાં અનિતા સાથે કરી શકો છો?

650
00:39:29,510 --> 00:39:34,110
બે વિકલ્પો શું ખરેખર છે? યાહ?

651
00:39:34,110 --> 00:39:37,410
[વિદ્યાર્થી જવાબ, દુર્બોધ] ઠીક છે, તેથી અમે અન્ય પરિમાણ કરી શકે છે.

652
00:39:37,410 --> 00:39:42,320
કે સારા હોય છે. જેથી અમે વસ્તુઓ બિલ્ડ બહાર 3D માં કરી શકો છો જેમ કે અમારી વિશે સોમવારે મૌખિક વાત કરી.

653
00:39:42,320 --> 00:39:46,700
અમે અન્ય ઍક્સેસ અહીં ઉમેરો કરી શકે છે, પરંતુ ધારો કે કોઈ, હું આ સરળ રાખવા પ્રયાસ કરી રહ્યો છું.

654
00:39:46,700 --> 00:39:50,160
આ સમગ્ર અહીં ધ્યેય તાત્કાલિક વપરાશ સતત સમય હોય છે,

655
00:39:50,160 --> 00:39:52,170
જેથી ઘણો જટિલતા ઉમેરી રહ્યા છે.

656
00:39:52,170 --> 00:39:55,970
અન્ય વિકલ્પો જ્યારે આ માહિતી માળખામાં અનિતા દાખલ કરવાનો પ્રયાસ કરી શું છે? યાહ?

657
00:39:55,970 --> 00:39:58,610
[વિદ્યાર્થી જવાબ, દુર્બોધ] ગુડ. તેથી અમે દરેક વ્યક્તિને નીચે ફરી શકે છે,

658
00:39:58,610 --> 00:40:03,040
બોબ અને એલિસ, નીચે ચાર્લી બનાવ્યો અને પછી જેમ અમે અનિતા મૂકવામાં જ્યાં તેમણે ખરેખર થવા માંગે છે.

659
00:40:03,040 --> 00:40:05,660
>> અલબત્ત, હવે, આ એક બાજુ અસર છે.

660
00:40:05,660 --> 00:40:09,000
આ માહિતી માળખું કદાચ ઉપયોગી નથી કારણ કે અમે લોકોને સામેલ કરવા માંગો છો વાર

661
00:40:09,000 --> 00:40:11,250
પરંતુ કારણ કે અમે તપાસ જો તેઓ ત્યાં પાછળથી છો માંગો છો

662
00:40:11,250 --> 00:40:13,600
જો અમે બહાર દશાંશ માહિતી માળખામાં નામો બધી પ્રિન્ટ માંગો છો.

663
00:40:13,600 --> 00:40:15,850
અમે આ માહિતી સાથે કંઈક છેવટે કરવા જઇ રહ્યા છો.

664
00:40:15,850 --> 00:40:20,810
તેથી હવે અમે પ્રકારની એલિસ, જે હવે જ્યાં તેમણે હશે તેવું માનવામાં પર ખરાબ કરેલા.

665
00:40:20,810 --> 00:40:23,880
નોર બોબ છે, કે ચાર્લી છે.

666
00:40:23,880 --> 00:40:26,060
તેથી કદાચ આ જેવા વિચાર સારો નથી.

667
00:40:26,060 --> 00:40:28,830
પરંતુ ખરેખર, આ એક વિકલ્પ છે. અમે દરેકને પાળી નીચે શકે છે,

668
00:40:28,830 --> 00:40:32,240
અથવા હેક, અનિતા રમત માટે મોડી આવી, શા માટે આપણે માત્ર અનિતા મૂકી નથી

669
00:40:32,240 --> 00:40:35,870
નથી અહીં, નથી અહીં, નથી અહીં, ચાલો પણ તેણીના યાદીમાં થોડો નીચો મૂકો.

670
00:40:35,870 --> 00:40:38,680
પરંતુ તે પછી આ સમસ્યા ફરી એકને શિરેથી ઊતરીને બીજાને શિરે જવું શરૂ થાય છે.

671
00:40:38,680 --> 00:40:41,630
તમે એલિસ શોધવા સક્ષમ તરત જ તેણીના પ્રથમ નામ પર આધારિત શકે હોય છે.

672
00:40:41,630 --> 00:40:44,320
અને તરત બોબ, અને ચાર્લી. પરંતુ તે પછી તમે અનિતા જોવા માટે,

673
00:40:44,320 --> 00:40:46,360
અને તમે જુઓ, હમ્મ, એલિસ માર્ગ છે.

674
00:40:46,360 --> 00:40:48,770
વેલ દો, મને એલિસ નીચે તપાસો. બોબ અનિતા નથી.

675
00:40:48,770 --> 00:40:51,850
ચાર્લી અનિતા નથી. ઓહ, ત્યાં અનિતા છે.

676
00:40:51,850 --> 00:40:54,720
અને જો તમે તર્ક છે કે ટ્રેન બધી રીતે ચાલુ રાખવા માટે,

677
00:40:54,720 --> 00:41:00,690
સૌથી ખરાબ કેસ શોધવા અથવા આ નવી માહિતી માળખામાં અનિતા દાખલ ચાલી રહ્યું સમય શું છે?

678
00:41:00,690 --> 00:41:03,280
તે ઓ (એન) અધિકાર છે?

679
00:41:03,280 --> 00:41:06,280
સૌથી ખરાબ કિસ્સામાં, કારણ કે ત્યાં એલીસ, બોબ, ચાર્લી છે. . .

680
00:41:06,280 --> 00:41:10,150
"વાય" નામની કોઇ વ્યક્તિ તમામ નીચે માર્ગ છે, તેથી ત્યાં માત્ર એક સ્પોટ છે બાકી છે.

681
00:41:10,150 --> 00:41:13,950
Thankfully, અમે કોઈ "Z" કહેવાય છે એક હોય છે, તેથી અમે ખૂબ તળિયે અનિતા મૂકો.

682
00:41:13,950 --> 00:41:16,040
>> અમે ખરેખર સમસ્યા નથી ઉકેલી છે.

683
00:41:16,040 --> 00:41:19,890
તેથી કદાચ અમે આ ત્રીજા પરિમાણ દાખલ કરવાની જરૂર નથી.

684
00:41:19,890 --> 00:41:22,230
અને તે તારણ, જો આપણે આ ત્રીજા પરિમાણ દાખલ નહિં કરો,

685
00:41:22,230 --> 00:41:25,240
અમે આ સંપૂર્ણપણે નથી, પરંતુ પવિત્ર ગ્રેઈલ માટે મળતું હોવું રહ્યું છે

686
00:41:25,240 --> 00:41:28,370
સતત સમય નિવેશ અને ગતિશીલ દાખલ કરો કે જેથી

687
00:41:28,370 --> 00:41:30,960
અમે સખત કોડ 26 કદ એક એરે માટે નથી.

688
00:41:30,960 --> 00:41:34,400
અમે ઘણી નામો તરીકે સામેલ તરીકે અમે માંગો છો કરી શકો છો, પરંતુ આપણે આપણા વિરામ 5-મિનિટ અહીં લેવા

689
00:41:34,400 --> 00:41:38,790
અને પછી યોગ્ય રીતે કે નથી.

690
00:41:38,790 --> 00:41:46,020
અધિકાર છે. હું વાર્તા સુયોજિત ખૂબ કૃત્રિમ ત્યાં

691
00:41:46,020 --> 00:41:48,670
એલિસ અને પછી બોબ અને પછી ચાર્લી અને પછી અનિતા પસંદ કરીને,

692
00:41:48,670 --> 00:41:51,000
નામ જેની ચોક્કસપણે માટે એલિસ સાથે અથડાઈ જવાની હતી.

693
00:41:51,000 --> 00:41:54,120
પરંતુ પ્રશ્ન અમે સાથે સોમવારે પૂરા થયેલા માત્ર સંભવિત તે કેવી રીતે થાય છે

694
00:41:54,120 --> 00:41:56,370
કે તમે આ પ્રકારના અકસ્માતથી વિચાર છો? અન્ય શબ્દોમાં,

695
00:41:56,370 --> 00:42:00,490
જો અમે આ કોઠા માળખું ઉપયોગ શરૂ કરવા માટે, જે ખરેખર માત્ર ઝાકઝમાળ છે,

696
00:42:00,490 --> 00:42:02,460
26 સ્થળોએ આ કિસ્સામાં,

697
00:42:02,460 --> 00:42:05,740
જો અમારા ઇનપુટ્સ બદલે એકસરખી વિતરણ કરવામાં આવે છે?

698
00:42:05,740 --> 00:42:09,620
તે કૃત્રિમ રીતે એલિસ અને બોબ અને ચાર્લી અને ડેવિડ નથી અને તેથી આગળ મૂળાક્ષરોની,

699
00:42:09,620 --> 00:42:12,380
તે એકસરખી ઝેડ મારફતે 'એ ઉપર વિતરિત

700
00:42:12,380 --> 00:42:15,220
>> કદાચ અમે ફક્ત નસીબદાર વિચાર અને પડશે અમે બે એક અથવા બે B હિસ્સો નથી જઈ રહ્યાં છો

701
00:42:15,220 --> 00:42:17,640
ખૂબ જ ઊંચી સંભાવના સાથે, પરંતુ કોઇને ધ્યાન દોર્યું,

702
00:42:17,640 --> 00:42:20,730
જો અમે આ સમસ્યા સામાન્ય છે અને નથી 0 થી 25

703
00:42:20,730 --> 00:42:26,060
પરંતુ કહે છે, 0 364 મારફતે અથવા 65, ઘણીવાર વિશિષ્ટ વર્ષમાં દિવસોની સંખ્યા,

704
00:42:26,060 --> 00:42:31,170
, અને પ્રશ્ન પૂછવામાં "શક્યતા છે કે આ ખંડમાં અમને બે જ જન્મદિવસ છે શું છે?"

705
00:42:31,170 --> 00:42:34,600
તેને બીજી રીતે મૂકો, તો સંભાવના શું છે કે બે અમને એક એક સાથે શરૂ નામ છે?

706
00:42:34,600 --> 00:42:37,190
પ્રશ્ન એ પ્રકારની જ હોય, પરંતુ આ સરનામા જગ્યા,

707
00:42:37,190 --> 00:42:39,940
આ શોધ જગ્યા, જન્મદિવસો કિસ્સામાં મોટી છે,

708
00:42:39,940 --> 00:42:42,820
કારણ કે અમે આમ ઘણા મૂળાક્ષરમાં અક્ષરો કરતાં વધુ વર્ષ દિવસ હોય છે.

709
00:42:42,820 --> 00:42:44,910
ટક્કર થવાની સંભાવના શું છે?

710
00:42:44,910 --> 00:42:48,410
વેલ, અમને આ બહાર ગણિત વિરુદ્ધ રીતે figuring દ્વારા વિચાર કરી શકો છો.

711
00:42:48,410 --> 00:42:50,580
આ બોલ પર કોઈ અકસ્માતથી સંભાવના શું છે?

712
00:42:50,580 --> 00:42:53,970
વેલ, આ અહીં અભિવ્યક્તિ કહે છે કે શું સંભાવના છે

713
00:42:53,970 --> 00:42:58,770
જો ત્યાં ફક્ત આ રૂમમાં એક વ્યક્તિ કે, તેઓ એક અનન્ય જન્મદિવસ હોય છે?

714
00:42:58,770 --> 00:43:01,190
તે 100% છે. કારણ કે જો ત્યાં ઓરડામાં એક માત્ર વ્યક્તિ છે,

715
00:43:01,190 --> 00:43:03,940
તેના અથવા તેણીના જન્મદિવસ એ 365 દિવસ કોઈપણ વર્ષ બહાર હોઇ શકે છે.

716
00:43:03,940 --> 00:43:08,650
જેથી 365/365 વિકલ્પો મને 1 ની કિંમત આપે છે.

717
00:43:08,650 --> 00:43:11,250
તેથી આ સમયે પ્રશ્ન માં સંભાવના ફક્ત 1 છે.

718
00:43:11,250 --> 00:43:13,270
પરંતુ જો ત્યાં રૂમ માં બીજા વ્યક્તિ છે,

719
00:43:13,270 --> 00:43:16,490
સંભાવના છે કે તેમના જન્મદિવસ અલગ છે શું?

720
00:43:16,490 --> 00:43:20,680
ત્યાં 364 જ શક્ય દિવસના અવગણીને લિપ વર્ષ છે,

721
00:43:20,680 --> 00:43:23,580
તેમના જન્મદિવસ માટે ટકરાતા નથી બીજી વ્યક્તિઓ સાથે.

722
00:43:23,580 --> 00:43:31,920
તેથી / 365 364. જો ત્રીજી વ્યક્તિ આવે, તે / 363 365 છે, અને તેથી આગળ.

723
00:43:31,920 --> 00:43:35,790
તેથી અમે સાથે આ અપૂર્ણાંક ગુણાકાર રાખવા, જે વધુ નાના અને નાના મેળવવામાં આવે છે,

724
00:43:35,790 --> 00:43:40,720
બહાર આકૃતિ શક્યતા છે કે અમારા બધા અનન્ય જન્મદિવસ છે શું છે?

725
00:43:40,720 --> 00:43:43,570
પરંતુ તે પછી આપણે, અલબત્ત, માત્ર શકો છો કે જવાબ ભરે છે અને તેને વિમાનની મુસાફરી આસપાસ

726
00:43:43,570 --> 00:43:47,210
અને 1 બાદ તમામ કે, એક અભિવ્યક્તિ અમે આખરે મળશે કરવું

727
00:43:47,210 --> 00:43:51,250
જો તમે તમારા ગણિત પુસ્તકો પાછળ યાદ રાખો કે, તે આ જેમ થોડું કંઈક જુએ છે,

728
00:43:51,250 --> 00:43:54,590
જે ખૂબ વધુ સરળતાથી ગ્રાફિકલી અર્થઘટન છે.

729
00:43:54,590 --> 00:43:57,820
અને આ અહીં ગ્રાફિક x અક્ષ પર જન્મદિવસ સંખ્યા ધરાવે છે,

730
00:43:57,820 --> 00:44:02,030
અથવા જન્મદિવસો સાથે લોકો અને y અક્ષ પર નંબર મેચમાં સંભાવના છે.

731
00:44:02,030 --> 00:44:06,060
અને આ કહેતા છે શું એ છે કે જો તમારી પાસે દો, કહો કે, પણ,

732
00:44:06,060 --> 00:44:10,860
ચાલો 23 22, કંઈક પસંદ કરો.

733
00:44:10,860 --> 00:44:13,160
જો ત્યાં રૂમ માં 22 અથવા 23 લોકો છે,

734
00:44:13,160 --> 00:44:17,100
સંભાવના છે કે બે તે ખૂબ થોડા લોકો જ જન્મદિવસ હોય જવું છે

735
00:44:17,100 --> 00:44:19,560
વાસ્તવમાં સુપર ઊંચી છે combinatorially.

736
00:44:19,560 --> 00:44:23,450
50% મતભેદ કે 22 લોકોના માત્ર, એક પરિસંવાદ, વ્યવહારીક એક વર્ગ છે,

737
00:44:23,450 --> 00:44:25,790
2 તે લોકો માટે જ જન્મદિવસ હોય જતાં હોય છે.

738
00:44:25,790 --> 00:44:28,520
કારણ કે ત્યાં ઘણા માર્ગો કે જેમાં તમે જ જન્મદિવસ હોઈ શકે છે.

739
00:44:28,520 --> 00:44:31,110
ખરાબ પણ, જો તમે ચાર્ટ બાજુ જમણી બાજુ જુઓ,

740
00:44:31,110 --> 00:44:34,040
સમય દ્વારા તમે તેને 58 વિદ્યાર્થીઓ સાથે એક વર્ગ છે,

741
00:44:34,040 --> 00:44:39,270
2 એક જન્મદિવસ કર્યા લોકોની સંભાવના સુપર, સુપર ઉચ્ચ લગભગ 100% છે.

742
00:44:39,270 --> 00:44:41,880
હવે, કે જે વાસ્તવિક જીવન વિશે મજા હકીકત જેવું છે.

743
00:44:41,880 --> 00:44:45,850
>> પરંતુ અસરો, હવે દશાંશ માહિતી માળખાં માટે, અને સંગ્રહવા માહિતી

744
00:44:45,850 --> 00:44:51,100
એનો અર્થ એ થાય કે જે હમણાં જ ધારી રહ્યા છીએ તમે સરસ, સ્વચ્છ, માહિતી સમાન વિતરણ હોય

745
00:44:51,100 --> 00:44:53,650
અને તમે એક મોટું માટે પૂરતી વસ્તુઓ સમૂહ ફિટ એરે છે

746
00:44:53,650 --> 00:44:59,360
નથી તેનો અર્થ નથી તમે અનન્ય સ્થળોએ લોકો વિચાર જઈ રહ્યાં છો.

747
00:44:59,360 --> 00:45:03,810
તમે અથડામણમાં હોય રહ્યા છીએ. પાસવર્ડ હેશીંગ આ વિચારને તેથી, કારણ કે તે કહેવાય છે,

748
00:45:03,810 --> 00:45:07,450
જેમ કે "એલિસ" ઇનપુટ લેતા અને તે કેટલીક રીતે માલિશ

749
00:45:07,450 --> 00:45:10,190
અને પછી પાછા 0 અથવા 1 અથવા 2 જેવા જવાબ મળતો.

750
00:45:10,190 --> 00:45:17,500
પાછા પેલા વિધેય માંથી કેટલીક આઉટપુટ મેળવી રહ્યા છે અથડામણ આ સંભાવના દ્વારા ભારે ઉપદ્વવ છે.

751
00:45:17,500 --> 00:45:19,530
તેથી અમે કેવી રીતે તે અકસ્માતથી સંભાળી શકે છે?

752
00:45:19,530 --> 00:45:21,940
વેલ, એક કેસ પર, અમે વિચાર કે સૂચવવામાં આવ્યું હતું લઈ શકો છો.

753
00:45:21,940 --> 00:45:25,100
અમે હમણાં જ દરેકને પાળી નીચે કરી શકો છો, અથવા કદાચ થોડી વધુ સરળ,

754
00:45:25,100 --> 00:45:29,870
ચાલ બીજું દરેકને બદલે, ચાલો ફક્ત ઉપલબ્ધ હાજર નીચે અનિતા ખસેડો.

755
00:45:29,870 --> 00:45:32,810
તેથી જો એલિસ 0 છે, બોબ 1 છે, ચાર્લી 2 માં છે,

756
00:45:32,810 --> 00:45:35,260
અમે ફક્ત 3 સ્થાન પર અનિતા મૂકીશું.

757
00:45:35,260 --> 00:45:38,860
અને આ માહિતી માળખાં એક તરકીબ રેખીય ચકાસણી કહેવાય છે.

758
00:45:38,860 --> 00:45:41,310
લીનિયર કારણ કે તમે ફક્ત આ વાક્ય વૉકિંગ કરી રહ્યાં છો, અને તમે ચકાસણી જેવું છો

759
00:45:41,310 --> 00:45:43,640
આ માહિતી માળખું ઉપલબ્ધ સ્થળો છે.

760
00:45:43,640 --> 00:45:46,210
અલબત્ત, આ ઓ (n) માં devolves.

761
00:45:46,210 --> 00:45:49,590
જો માહિતી માળખું ખરેખર સંપૂર્ણ છે, તેમાં 25 લોકો પહેલેથી જ છે,

762
00:45:49,590 --> 00:45:54,120
અને પછી અનિતા સાથે આવે છે, તે શું સ્થાન Z હશે ખાતે થાય છે, અને તે લલિત છે.

763
00:45:54,120 --> 00:45:56,540
તેમણે હજુ પણ ફીટ થઈ જાય છે, અને અમે તેના પછી શોધી શકો છો.

764
00:45:56,540 --> 00:46:00,100
>> પરંતુ આ વસ્તુઓ ઝડપી અપ ધ્યેય વિપરીત હતી.

765
00:46:00,100 --> 00:46:02,530
તેથી જો આપણે તેના બદલે આ ત્રીજા પરિમાણ પરિચય?

766
00:46:02,530 --> 00:46:06,400
ટેકનીક જે સામાન્ય રીતે અલગ અલગ chaining કહેવાય છે, અથવા સાંકળો હોય છે.

767
00:46:06,400 --> 00:46:10,030
અને હેશ કોષ્ટક શું હવે, આ કોઠા માળખું,

768
00:46:10,030 --> 00:46:13,450
તમારા ટેબલ માત્ર પોઇંટરો ઝાકઝમાળ છે.

769
00:46:13,450 --> 00:46:18,230
પરંતુ તે પોઇંટરો નિર્દેશિત કરવા માટે શું શું અનુમાન છે?

770
00:46:18,230 --> 00:46:21,970
એક કડી થયેલ યાદી. તેથી જો અમે આ લોકના બંને શ્રેષ્ઠ લાગી?

771
00:46:21,970 --> 00:46:26,500
અમે પ્રારંભિક નિર્દેશિકાઓની માટે એરે ઉપયોગ

772
00:46:26,500 --> 00:46:32,070
આ માહિતી માળખામાં તેથી અમે તરત [1], [30] અથવા તેથી આગળ [0] જઈ શકો છો,

773
00:46:32,070 --> 00:46:36,480
પરંતુ કે જેથી અમે કેટલીક ફ્લેક્સિબિલિટી હોય છે અને અમે અનિતા અને એલિસ અને આદમ ફિટ થઈ શકે છે

774
00:46:36,480 --> 00:46:38,630
અને અન્ય કોઈ પણ એક નામ,

775
00:46:38,630 --> 00:46:43,470
અમે બદલે દો અન્ય ધરી આપખુદ વિકસે છે.

776
00:46:43,470 --> 00:46:47,340
અને અમે આખરે, સોમવાર તરીકે, સંલગ્ન યાદી સાથે એ વ્યક્ત કરવાની ક્ષમતા ધરાવે છે.

777
00:46:47,340 --> 00:46:49,530
અમે એ માહિતી બંધારણ આપખુદ પ્રગતિ કરી શકે છે.

778
00:46:49,530 --> 00:46:52,450
વૈકલ્પિક રીતે, અમે માત્ર એક વિશાળ એરે 2-પરિમાણીય બનાવી શકે છે,

779
00:46:52,450 --> 00:46:57,190
પરંતુ તે એક ભયાનક પરિસ્થિતિ હોઈ શકે જો ચાલી રહ્યું છે એક એરે 2-પરિમાણીય માં પંક્તિઓની

780
00:46:57,190 --> 00:47:01,280
પૂરતો મોટો વધારાના વ્યક્તિ નામ છે, જેની સાથે શરૂ થાય છે એ માટે નથી

781
00:47:01,280 --> 00:47:04,200
ભગવાન મનાઈ ફરમાવવી અમે એક વિશાળ માળખું 2-પરિમાણીય reallocate છે

782
00:47:04,200 --> 00:47:06,600
માત્ર કારણ કે ત્યાં ઘણા ફકત લોકો છે,

783
00:47:06,600 --> 00:47:09,480
ખાસ કરીને જ્યારે ત્યાં તેથી થોડા Z કંઈક નામ લોકો છે.

784
00:47:09,480 --> 00:47:12,170
તે માત્ર ખૂબ સ્પર્શ માહિતી માળખું જ હશે.

785
00:47:12,170 --> 00:47:15,400
જેથી કોઇ પણ માધ્યમ દ્વારા સંપૂર્ણ નથી પરંતુ હવે અમે ઓછામાં ઓછી કરવાની ક્ષમતા હોય છે

786
00:47:15,400 --> 00:47:19,090
તત્ક્ષણ શોધવા જ્યાં એલિસ અથવા અનિતા અનુલક્ષે,

787
00:47:19,090 --> 00:47:21,090
ઓછામાં ઓછા ઊભી ધરી દ્રષ્ટિએ,

788
00:47:21,090 --> 00:47:25,850
અને પછી અમે માત્ર નક્કી જ્યાં આ કડી થયેલ યાદીમાં અનિતા અથવા એલિસ મૂકવા માટે છે.

789
00:47:25,850 --> 00:47:32,480
જો અમે વસ્તુઓ સૉર્ટ વિશે પડી નથી, ઝડપથી કેવી રીતે અમે આ જેવા માળખામાં એલિસ દાખલ કરી શકે છે?

790
00:47:32,480 --> 00:47:35,370
તે સતત સમય છે. અમે [0] માં અનુક્રમણિકા, અને જો કોઈ વ્યક્તિના ત્યાં,

791
00:47:35,370 --> 00:47:37,550
એલિસ કે યાદીની લિંક શરૂઆતમાં જાય છે.

792
00:47:37,550 --> 00:47:40,000
પરંતુ તે એક વિશાળ સોદો નથી. જો કારણ કે અનિતા પછી સાથે આવે છે

793
00:47:40,000 --> 00:47:42,160
કેટલાક પગલાંઓ નંબર બાદ, જ્યાં અનિતા સંબંધ નથી?

794
00:47:42,160 --> 00:47:45,140
વેલ, [0]. Oop. એલિસ કે યાદીની લિંક પહેલેથી જ છે.

795
00:47:45,140 --> 00:47:47,760
>> પરંતુ જો આપણે આ નામો સૉર્ટ વિશે પડી નથી,

796
00:47:47,760 --> 00:47:53,580
અમે ફક્ત એલિસ પર, insert અનિતા ખસેડવા કરી શકો છો, પરંતુ તેમ છતાં પણ સતત સમય છે.

797
00:47:53,580 --> 00:47:57,010
જો ત્યાં એલિસ અને આદમ અને આ બધા અન્ય એક નામો છે,

798
00:47:57,010 --> 00:47:59,410
તે ખરેખર તેમને શારીરિક નથી સ્થળાંતર છે. શા માટે?

799
00:47:59,410 --> 00:48:04,090
કારણ કે અમે માત્ર કડી થયેલ યાદી છે, જે જાણે છે અહીં કર્યું આ ગાંઠો રીતે છે હતા?

800
00:48:04,090 --> 00:48:06,550
બધા તમારે હોય છે બ્રેડ crumbs ખસેડો.

801
00:48:06,550 --> 00:48:10,930
આસપાસ તીરો ખસેડો; તમે શારીરિક કોઈપણ માહિતી ફરતે ખસવાની નથી.

802
00:48:10,930 --> 00:48:14,610
તેથી અમે અનિતા દાખલ કરો, કે જે કિસ્સામાં કરી શકે છે તરત. સતત સમય.

803
00:48:14,610 --> 00:48:20,250
તેથી અમે સતત સમય લૂકઅપ, અને અનિતા જેવા કોઇક લગાવ્યા સતત સમય હોય છે.

804
00:48:20,250 --> 00:48:22,740
પરંતુ દુનિયાના oversimplifying પ્રકારની.

805
00:48:22,740 --> 00:48:28,510
જો અમે પાછળથી એલિસ શોધવા માંગો છો?

806
00:48:28,510 --> 00:48:31,050
જો અમે પાછળથી એલિસ શોધવા માંગો છો?

807
00:48:31,050 --> 00:48:35,690
કેટલી પગલાંઓ કે જે લાગી રહ્યું છે?

808
00:48:35,690 --> 00:48:37,850
[વિદ્યાર્થી જવાબ, દુર્બોધ]

809
00:48:37,850 --> 00:48:40,950
બરાબર. એલિસ પહેલાં લોકો સંકળાયેલા યાદીમાં સંખ્યા.

810
00:48:40,950 --> 00:48:45,420
જેથી તે તદ્દન સંપૂર્ણ નથી કારણ કે અમારા દશાંશ માહિતી માળખું, ફરીથી, આ વર્ટીકલ ઍક્સેસ છે

811
00:48:45,420 --> 00:48:50,240
અને પછી તેને આ સંલગ્ન અટકી યાદીઓ છે - વાસ્તવમાં, તેના એક એરે એક દોરવા ન દો.

812
00:48:50,240 --> 00:48:56,020
આ કડી થયેલ યાદી છે તે છે આ બોલ પર અટકી છે કે આ પ્રકારનાં થોડું કંઈક જુએ છે.

813
00:48:56,020 --> 00:48:59,110
પરંતુ સમસ્યા છે જો એલિસ અને આદમ અને આ બધા અન્ય એક નામો

814
00:48:59,110 --> 00:49:01,720
અપ ત્યાં વધુ અને વધુ અંત,

815
00:49:01,720 --> 00:49:04,810
શોધવામાં કોઈની અંત પગલાંઓ સમૂહ લઈ શકે છે,

816
00:49:04,810 --> 00:49:06,670
bcause તમે સંલગ્ન યાદી પસાર હોય છે,

817
00:49:06,670 --> 00:49:08,090
જે સુરેખ ઓપરેશન ધરાવે છે.

818
00:49:08,090 --> 00:49:14,270
તેથી ખરેખર, ત્યારબાદ દાખલ સમય આખરે (એન) ઓ, જ્યાં n યાદીમાં સંખ્યાબંધ તત્વો છે.

819
00:49:14,270 --> 00:49:21,780
દ્વારા વિભાજી, ચાલો આપખુદ તે મીટર, જ્યાં મીટર સંલગ્ન યાદીઓ સંખ્યા છે કૉલ

820
00:49:21,780 --> 00:49:24,500
કે અમે આ વર્ટીકલ ધરી માં હોય છે.

821
00:49:24,500 --> 00:49:27,180
અન્ય શબ્દોમાં, જો આપણે ખરેખર નામો ની ગણવેશ વિતરણ ધારે,

822
00:49:27,180 --> 00:49:30,150
તદ્દન અવાસ્તવિક. ત્યાં દેખીતી રીતે બીજાઓ કરતાં કેટલાક અક્ષરોના વધુ છે.

823
00:49:30,150 --> 00:49:32,580
>> પરંતુ જો આપણે થોડો સમાન વિતરણ માટે ધારે,

824
00:49:32,580 --> 00:49:37,350
અને અમે કુલ લોકો, અને એમ કુલ સાંકળો n છે

825
00:49:37,350 --> 00:49:40,630
અમને ઉપલબ્ધ છે, તો પછી આ સાંકળો દરેક લંબાઈ

826
00:49:40,630 --> 00:49:44,380
એકદમ સરળ કુલ, એન સાંકળો સંખ્યા દ્વારા વિભાજી પ્રયત્ન રહ્યું છે.

827
00:49:44,380 --> 00:49:48,900
તેથી n / એમ. પરંતુ અહીં જ્યાં અમે તમામ ગાણિતિક હોંશિયાર હોઈ શકે છે.

828
00:49:48,900 --> 00:49:53,030
મીટર સતત હોય છે, કારણ કે ત્યાં આ એક નિશ્ચિત સંખ્યા છે.

829
00:49:53,030 --> 00:49:54,620
તમે શરૂઆતમાં તમારું એરે જાહેર જઈ રહ્યાં છો,

830
00:49:54,620 --> 00:49:58,450
અને અમે ઊભા ધરી માપ બદલવાની નથી. વ્યાખ્યા દ્વારા, કે જે સુધારાઈ રહે.

831
00:49:58,450 --> 00:50:01,220
તે માત્ર ત્યારે જ આડી ધરી છે, તેથી બોલે છે, કે બદલાતી છે.

832
00:50:01,220 --> 00:50:04,760
તેથી ટેકનિકલી, આ સતત છે. હવે તેથી, દાખલ સમય

833
00:50:04,760 --> 00:50:09,700
ખૂબ ખૂબ ઓ (એન) છે.

834
00:50:09,700 --> 00:50:12,410
જેથી તે બધા વધુ સારું ન લાગે નથી.

835
00:50:12,410 --> 00:50:14,940
પરંતુ સત્ય શું અહીં? વેલ, આ બધા સમય, અઠવાડિયા માટે,

836
00:50:14,940 --> 00:50:20,640
અમે કહેતા થઈ ઓ (n ²) હતું. (એન) ઓ, 2 x n ચોરસ - n એ, 2 દ્વારા વિભાજી. . . ech.

837
00:50:20,640 --> 00:50:23,580
તે માત્ર n ચોરસ છે. પરંતુ હવે તો, સત્ર આ ભાગ માં,

838
00:50:23,580 --> 00:50:25,560
અમે વાસ્તવિક દુનિયા વિશે ફરી વાત શરૂ કરી શકો છો.

839
00:50:25,560 --> 00:50:31,520
એન્ડ એન m / સંપૂર્ણપણે માત્ર એકલા n કરતા ઝડપી છે.

840
00:50:31,520 --> 00:50:35,170
જો તમે એક હજાર નામો હોય છે, અને તમે તેમને ઘણા buckets માં વિભાજન

841
00:50:35,170 --> 00:50:37,820
જેથી તમે આ સાંકળો દરેક માત્ર દસ નામો હોય છે,

842
00:50:37,820 --> 00:50:41,670
સંપૂર્ણપણે દસ વસ્તુઓ શોધ માટે એક હજાર વસ્તુઓ કરતાં ઝડપી પ્રયત્ન રહ્યું છે.

843
00:50:41,670 --> 00:50:43,740
અને તેથી એક આગામી સમસ્યા સેટ કરવા માટે તમે પડકાર રહ્યું છે

844
00:50:43,740 --> 00:50:46,100
બરાબર છે કે જે વિશે વિચારવું તેમ છતાં, હા,

845
00:50:46,100 --> 00:50:49,520
asymptotically અને ગાણિતિક, આ હજુ હમણાં જ રેખીય,

846
00:50:49,520 --> 00:50:51,700
જે સામાન્ય રીતે sucks જ્યારે વસ્તુઓ શોધવા પ્રયાસ કરે છે.

847
00:50:51,700 --> 00:50:54,530
વાસ્તવમાં, તે કરતા વધુ ઝડપી જ હશે

848
00:50:54,530 --> 00:50:56,520
કારણ કે આ ભાજક છે.

849
00:50:56,520 --> 00:50:58,310
અને તેથી ફરી આ મડાગાંઠ જ હશે

850
00:50:58,310 --> 00:51:01,390
અને સિદ્ધાંત અને વાસ્તવિકતા વચ્ચે આ સંઘર્ષ,

851
00:51:01,390 --> 00:51:03,550
અને એક knobs ના સત્ર આ બિંદુએ દેવાનો શરૂ કરશે

852
00:51:03,550 --> 00:51:07,510
એક વાસ્તવિકતા વધુ છે અમે સૉર્ટ ની semster ઓવરને માટે તૈયાર કરવા માટે,

853
00:51:07,510 --> 00:51:09,280
અમે વેબ પ્રોગ્રામિંગ દુનિયામાં દાખલ,

854
00:51:09,280 --> 00:51:11,530
ખરેખર, જ્યાં કામગીરી માટે ગણતરી રહ્યું છે કારણ કે તમારા વપરાશકર્તાઓ જોઈ રહ્યા છે

855
00:51:11,530 --> 00:51:14,880
માટે લાગે છે અને ગરીબ ડિઝાઇન નિર્ણયો પ્રશંસા કરવાનું શરૂ કરો.

856
00:51:14,880 --> 00:51:19,950
>> તેથી તમે કેવી રીતે સંકળાયેલી અમલીકરણ વિશે જવા નથી - 31 તત્વો સાથે હેશ ટેબલ?

857
00:51:19,950 --> 00:51:22,600
અને અગાઉના ઉદાહરણ જન્મદિવસ વિશે આપખુદ હતો.

858
00:51:22,600 --> 00:51:26,190
જો કોઈ જાન્યુઆરી 1 અથવા 1 ફેબ્રુઆરી જન્મદિવસ છે, અમે તેમને આ ડોલમાં મૂકીશું.

859
00:51:26,190 --> 00:51:28,960
જો તે જાન્યુઆરી 2, 2 ફેબ્રુઆરી, માર્ચ 2 છે, ત્યારે અમે તેમને આ ડોલમાં મૂકીશું.

860
00:51:28,960 --> 00:51:32,220
કે શા માટે તે 31 હતી. તમે હેશ કોષ્ટક કેવી રીતે જાહેર કરી શકું?

861
00:51:32,220 --> 00:51:37,480
તે ખૂબ સરળ હોઈ શકે છે, નોડ * ટેબલ મારા તે માટે મનસ્વી નામ છે, [31] છે.

862
00:51:37,480 --> 00:51:42,400
આ મને આપે ગાંઠો 31 પોઇન્ટર,

863
00:51:42,400 --> 00:51:45,370
અને જે મને કડી થયેલ લિસ્ટ 31 પોઇંટરો માટે પરવાનગી આપે છે

864
00:51:45,370 --> 00:51:48,800
પણ જો તે સાંકળો શરૂઆતમાં NULL છે.

865
00:51:48,800 --> 00:51:54,860
મારે શું કરવું કરવા માંગો છો જો હું સંગ્રહવા માંગો છો "બોબ", "ચાર્લી" "એલિસ"?

866
00:51:54,860 --> 00:51:57,010
વેલ, અમે એક માળખું તે વસ્તુઓ લપેટી જરૂર

867
00:51:57,010 --> 00:52:00,530
કારણ કે અમે એલિસ બોબ માટે નિર્દેશ માટે, ચાર્લી માટે નિર્દેશ, અને તેથી આગળ. જરૂર

868
00:52:00,530 --> 00:52:04,940
અમે હમણાં જ નામો એકલા નથી શકે છે, તેથી હું એક નવા નોડ અહીં કહેવાય માળખું બનાવી શકે છે.

869
00:52:04,940 --> 00:52:08,310
>> એક વાસ્તવિક નોડ શું છે? આ નવી કડી થયેલ યાદીમાં નોડ શું છે?

870
00:52:08,310 --> 00:52:11,840
પ્રથમ વસ્તુ, શબ્દ ઓળખાય છે, જે વ્યક્તિ નામ માટે છે.

871
00:52:11,840 --> 00:52:14,340
LENGTH, કદાચ, એક માનવ નામ મહત્તમ લંબાઈ સંલગ્ન,

872
00:52:14,340 --> 00:52:18,210
ગમે તે, 20, 30, ઉન્મત્ત ખૂણે કિસ્સાઓમાં 40 અક્ષરો,

873
00:52:18,210 --> 00:52:22,680
અને +1 શું છે? તે માત્ર વધારાની NULL અક્ષર 0 \ છે.

874
00:52:22,680 --> 00:52:27,410
તેથી આ નોડ પોતાની અંદર "કંઈક" રેપિંગ કરવામાં આવે છે,

875
00:52:27,410 --> 00:52:29,640
પરંતુ તે પણ એક આગામી કહેવાય નિર્દેશક જાહેર

876
00:52:29,640 --> 00:52:32,580
તેથી અમે બોબ માટે એલિસ ચાર્લી માટે સાંકળ અને તેથી આગળ કરી શકો છો જે.

877
00:52:32,580 --> 00:52:36,700
NULL પ્રયત્ન શકે છે પરંતુ નથી હોવું જરૂરી નથી.

878
00:52:36,700 --> 00:52:40,110
આ હેશ ટેબલો પર કોઈપણ પ્રશ્ન છે? યાહ?

879
00:52:40,110 --> 00:52:46,190
[વિદ્યાર્થી પ્રશ્ન પૂછવા, દુર્બોધ] હારમાળા - સારો પ્રશ્ન.

880
00:52:46,190 --> 00:52:50,120
એક જગ્યાએ માત્ર કોલસો બનાવો * એરે આ ઘરનાં પરચૂરણ કામો શબ્દ શા માટે છે?

881
00:52:50,120 --> 00:52:53,830
આ મુનસફી ઉદાહરણમાં, હું આશરો નથી માંગતા હતા

882
00:52:53,830 --> 00:52:56,190
મૂળ નામો દરેક માટે malloc છે.

883
00:52:56,190 --> 00:52:59,530
હું શબ્દમાળા માટે મેમરી મહત્તમ રકમ જાહેર કરવા માગે છે

884
00:52:59,530 --> 00:53:06,020
જેથી હું માળખામાં નકલ એલિસ 0 \ અને ન malloc અને મફત અને જેવા સાથે કામ કરી શકે છે.

885
00:53:06,020 --> 00:53:11,710
પરંતુ હું આ કરી જો હું વધુ જગ્યા ઉપયોગ સભાન બનવા ઇચ્છે શકે છે. પ્રશ્ન સારું.

886
00:53:11,710 --> 00:53:14,780
તેથી આપણે આ દૂર સામાન્યીકરણ પ્રયાસ

887
00:53:14,780 --> 00:53:18,350
અને માહિતી બંધારણો પર આજે બાકીની વધુ સામાન્ય ફોકસ

888
00:53:18,350 --> 00:53:21,170
અને અન્ય સમસ્યાઓ કે અમે એ જ ફંડામેન્ટલ્સ મદદથી હલ કરી શકો છો

889
00:53:21,170 --> 00:53:24,590
પણ માહિતી માળખાં છતાં તેમને પોતાને વિગતો અલગ હોઈ શકે છે.

890
00:53:24,590 --> 00:53:27,910
>> તેથી તે કોમ્પ્યુટર વિજ્ઞાન બહાર વળે છે, વૃક્ષો ખૂબ સામાન્ય છે.

891
00:53:27,910 --> 00:53:29,760
અને તમે એક વૃક્ષ જેવું એક પરિવાર વૃક્ષ જેવી લાગે શકે છે,

892
00:53:29,760 --> 00:53:31,830
જ્યાં ત્યાં કેટલાક મૂળ, કેટલાક matriarch અથવા પૂર્વજ છે,

893
00:53:31,830 --> 00:53:34,540
દાદી અથવા grandpa અથવા પહેલાંની બેક,

894
00:53:34,540 --> 00:53:38,880
જે નીચે મમ્મીનું અને પિતા અથવા વિવિધ ભાઇ અથવા ગમે છે.

895
00:53:38,880 --> 00:53:42,500
તેથી એક વૃક્ષ માળખું ગાંઠો હોય છે અને તે બાળકો હોય છે,

896
00:53:42,500 --> 00:53:45,260
સામાન્ય રીતે દરેક નોડ માટે 0 અથવા વધુ બાળકો.

897
00:53:45,260 --> 00:53:47,320
અને કલકલ કેટલાક કે જે તમે આ અહીં ચિત્રમાં જુઓ

898
00:53:47,320 --> 00:53:50,630
છે થોડું ધાર પર અથવા બાળકો grandkids કોઈપણ

899
00:53:50,630 --> 00:53:52,330
જે કોઈ તેમને નીકળતી તીર છે,

900
00:53:52,330 --> 00:53:55,070
તે કહેવાતા પાંદડા, અને અંદરના પર કોઈને છે

901
00:53:55,070 --> 00:53:58,790
આંતરિક નોડ છે; તમે તેને તે રેખાઓ કંઈપણ કહી શકો છો.

902
00:53:58,790 --> 00:54:01,430
પરંતુ આ માળખું ખૂબ સામાન્ય હોય છે. આ એક થોડો મનસ્વી છે.

903
00:54:01,430 --> 00:54:04,930
અમે ડાબી પર એક બાળક છે, તો અમે જમણી બાજુ પર ત્રણ બાળકો હોય,

904
00:54:04,930 --> 00:54:06,830
તળિયે બે બાળકોને છોડી ગયા.

905
00:54:06,830 --> 00:54:10,740
તેથી અમે જુદા જુદા કદના વૃક્ષો હોય શકે છે, પરંતુ જો અમે વસ્તુઓ પ્રમાણિત શરૂ કરવા માટે,

906
00:54:10,740 --> 00:54:15,330
અને તમે એક અગાઉની ટૂંકા માંથી દ્વિસંગી શોધ પર પેટ્રિક વિડિઓ આ યાદ શકે છે

907
00:54:15,330 --> 00:54:19,490
ઑનલાઇન, દ્વિસંગી શોધ કરવા માટે એક એરે સાથે અમલ કરી શકાય નથી

908
00:54:19,490 --> 00:54:21,410
એક બ્લેકબોર્ડ પર અથવા કાગળ ટુકડાઓ.

909
00:54:21,410 --> 00:54:25,490
ધારો કે તમે વધુ વ્યવહારદક્ષ માહિતી માળખું તમારા નંબરો સ્ટોર કરવા માંગતા હતા.

910
00:54:25,490 --> 00:54:27,680
તમે આ જેવા વૃક્ષ બનાવી શક્યા.

911
00:54:27,680 --> 00:54:35,290
તમે એક સી જાહેર નોડ છે, અને શકે કે નોડ તે અંદર ઓછામાં ઓછા બે તત્વો હોય શકે છે.

912
00:54:35,290 --> 00:54:39,470
એક નંબર તમે સંગ્રહવા માંગો છો, અને અન્ય છે - અને સાથે સાથે, અમે એક વધુ જરૂર છે.

913
00:54:39,470 --> 00:54:41,540
અન્ય તેના બાળકો છે.

914
00:54:41,540 --> 00:54:45,150
તેથી અહીં અન્ય માહિતી માળખું છે. આ જ સમયે, ગાંઠ નંબર સ્ટોર તરીકે વ્યાખ્યાયિત થયેલ છે n

915
00:54:45,150 --> 00:54:49,060
અને પછી બે પોઇંટરો; ડાબી અને જમણી બાળક બાળક.

916
00:54:49,060 --> 00:54:52,100
અને તેઓ આર્બીટરી નથી. શું આ વૃક્ષ વિશે રસપ્રદ છે?

917
00:54:52,100 --> 00:55:00,550
>> કેવી રીતે અમે આ નાખ્યો કર્યું છે બહાર અથવા કેવી રીતે પેટ્રિક તેના વિડિઓ બહાર નાખ્યો માં પેટર્ન શું છે?

918
00:55:00,550 --> 00:55:02,790
તે પ્રકારની છે સ્પષ્ટ કે ત્યાં અમુક અહીં રહ્યું સોર્ટિંગ છે,

919
00:55:02,790 --> 00:55:04,460
પરંતુ સરળ નિયમ શું છે? યાહ?

920
00:55:04,460 --> 00:55:08,350
[વિદ્યાર્થી જવાબ, દુર્બોધ]

921
00:55:08,350 --> 00:55:12,040
પરફેક્ટ. જો તમે આ અંતે ઝબકવું, તો તમે ડાબી બાજુ નાના નંબરો જોવા માટે,

922
00:55:12,040 --> 00:55:14,690
ડાબી બાજુ પર મોટી સંખ્યામાં છે, પરંતુ તે દરેક નોડ માટે સાચું છે.

923
00:55:14,690 --> 00:55:20,370
દરેક નોડ માટે, તેના ડાબા બાળક તે કરતાં ઓછી, અને તેની યોગ્ય બાળક તે કરતાં વધારે હતો.

924
00:55:20,370 --> 00:55:25,210
હવે એનો અર્થ એ થાય શું છે જો હું કહેવા માટે, 44 નંબર માટે આ માહિતી માળખું શોધવા માંગો છો,

925
00:55:25,210 --> 00:55:29,320
હું રુટ શરૂ આ વધુ જટિલ માહિતી માળખાં હવે બધા સાથે કારણ કે છે,

926
00:55:29,320 --> 00:55:31,910
અમે ફક્ત એક વસ્તુ માટે નિર્દેશક હોય, તો શરૂઆતમાં.

927
00:55:31,910 --> 00:55:35,010
અને આ કિસ્સામાં, શરૂઆતમાં મૂળ છે. તે ડાબી ઓવરને નથી,

928
00:55:35,010 --> 00:55:39,530
આ માળખું રુટ છે. તેથી હું જોઈ અહીં 55, અને હું 44 શોધી રહ્યો છું.

929
00:55:39,530 --> 00:55:41,430
જે દિશામાં હું જવા માંગો છો?

930
00:55:41,430 --> 00:55:45,680
વેલ, હું ડાબી પર જાઓ કરવા માંગો છો, કારણ કે દેખીતી રીતે, યોગ્ય કરવા માટે ખૂબ મોટી હશે છે.

931
00:55:45,680 --> 00:55:49,050
તેથી અહીં નોટિસ, તમે કલ્પનાત્મક અડધા માં વૃક્ષ કકડો જેવું છો

932
00:55:49,050 --> 00:55:51,700
કારણ કે તમે બાજુ જમણી બાજુ ક્યારેય રહ્યા છીએ.

933
00:55:51,700 --> 00:55:55,410
તેથી હવે હું 55 થી 33 માટે જાઓ. તે ખૂબ સંખ્યાબંધ નાના છે.

934
00:55:55,410 --> 00:56:01,590
હું 44 શોધી રહ્યો છું, પરંતુ હવે મને ખબર છે જો 44 આ વૃક્ષ છે, હું ચોક્કસપણે અધિકાર જઈ શકો છો.

935
00:56:01,590 --> 00:56:04,460
તેથી ફરી, હું અડધી માં વૃક્ષ કાપણી છું.

936
00:56:04,460 --> 00:56:06,780
તે ખરેખર ખૂબ ફોન બુકમાં માટે સરળ સમાન છે.

937
00:56:06,780 --> 00:56:09,510
તે સમાન અમે શું બ્લેકબોર્ડ પર કાગળો સાથે હતી,

938
00:56:09,510 --> 00:56:13,940
પરંતુ તે વધુ વ્યવહારદક્ષ બંધારણ છે કે અમને વાસ્તવમાં આવું કરવા માટે પરવાનગી આપે છે

939
00:56:13,940 --> 00:56:16,880
આ વિભાજિત અને ગાણિતીક ડિઝાઇન દ્વારા જીતી,

940
00:56:16,880 --> 00:56:19,420
અને હકીકતમાં, આ જેવા માળખું સરકાઉ - દેખીતી ભૂલ માટે માફી (માગવી તે).

941
00:56:19,420 --> 00:56:22,870
આ જેવી માળખું સરકાઉ, જ્યાં તે માત્ર "આ રીતે જવું અથવા તે માર્ગ જાય છે,"

942
00:56:22,870 --> 00:56:26,870
કે તમામ કોડ કે જે પ્રથમ તમારું મન વલણ જ્યારે તે વિભાગમાં અમલીકરણ અર્થ થાય છે

943
00:56:26,870 --> 00:56:31,270
અથવા ઘરે તે મારફતે વૉકિંગ, દ્વિસંગી શોધ માટે, રિકર્ઝન અથવા પુનરાવૃત્તિ વાપરી રહ્યા હોય,

944
00:56:31,270 --> 00:56:35,060
તે જે ગળામાં એક પીડા છે. મધ્યમ તત્વ શોધો, પછી તમારા rounding અથવા નીચે કામ કરે છે.

945
00:56:35,060 --> 00:56:39,230
>> આ માટે એક સૌંદર્ય છે કારણ કે અમે હવે રિકર્ઝન ફરી ઉપયોગ કરી શકો છો,

946
00:56:39,230 --> 00:56:43,760
પરંતુ ઘણી વધુ સ્વચ્છ. ખરેખર, જો તમે 55 નંબર પર છો અને તમે 44 શોધવા માંગો છો,

947
00:56:43,760 --> 00:56:48,450
તમે જાઓ આ કિસ્સામાં બાકી છે, પછી તમે શું કરી શકું? તમે ચોક્કસ જ અલ્ગોરિધમનો ચલાવો.

948
00:56:48,450 --> 00:56:51,560
તમે નોડ મૂલ્ય તપાસો, પછી તમે ડાબે અથવા જમણે જાઓ.

949
00:56:51,560 --> 00:56:53,670
પછી તમારે નોડ કિંમત ચકાસવા માટે, ડાબે અથવા જમણે જાઓ.

950
00:56:53,670 --> 00:56:56,710
આ સંપૂર્ણપણે રિકર્ઝન માટે અનુકૂળ છે.

951
00:56:56,710 --> 00:57:00,920
તેથી ભલે ભૂતકાળમાં અમે કેટલીક એકદમ મનસ્વી રિકર્ઝન સંડોવતા ઉદાહરણો કર્યું છે

952
00:57:00,920 --> 00:57:03,430
કે ફરી યાદ આવવું હોવું માહિતી stuctures સાથે જરૂર ન હતી,

953
00:57:03,430 --> 00:57:07,820
ખાસ કરીને વૃક્ષો, તે સમસ્યા લેવાના આ વિચાર એક સંપૂર્ણ એપ્લિકેશન છે,

954
00:57:07,820 --> 00:57:12,920
તે સંકોચાઇ, અને પછી એ જ પ્રકાર છે, પરંતુ નાના કાર્યક્રમ, ઉકેલ.

955
00:57:12,920 --> 00:57:14,590
>> તેથી ત્યાં બીજી માહિતી બંધારણ છે કે અમે દાખલ કરી શકો છો.

956
00:57:14,590 --> 00:57:18,760
આ એક પ્રથમ ભેદી જોવા નજરમાં રચાયેલ છે, પરંતુ આ એક આશ્ચર્યજનક છે.

957
00:57:18,760 --> 00:57:25,090
તેથી આ એક માહિતી trie, trie છે, કે જે શબ્દ પુનઃપ્રાપ્તિ ઉતરી આવે છે માળખું છે,

958
00:57:25,090 --> 00:57:30,210
જે ફરીથી પ્રયાસ કરો-Val ઉચ્ચાર થતો નથી, પરંતુ કે દુનિયા શું આ બાબતો કહે છે. પ્રયત્ન કરે છે. ટી-r-i-ઈ.

959
00:57:30,210 --> 00:57:35,190
તે અમુક પ્રકારની એક વૃક્ષ માળખું છે, પરંતુ trie માં ગાંઠો દરેક

960
00:57:35,190 --> 00:57:41,280
શું હોય તેવું લાગે છે? અને આ એક બીટ ભ્રામક છે કારણ કે તે સંક્ષિપ્ત પ્રકારની છે.

961
00:57:41,280 --> 00:57:45,960
પરંતુ લાગે છે કે આ trie દરેક નોડ ખરેખર એક વ્યૂહરચના છે.

962
00:57:45,960 --> 00:57:48,840
અને આમ છતાં આ રેખાકૃતિ લેખક નથી તે દર્શાવે છે,

963
00:57:48,840 --> 00:57:54,130
આ કિસ્સામાં, આ trie એ માહિતી બંધારણ હેતુ જેના જીવન માં શબ્દો સ્ટોર છે

964
00:57:54,130 --> 00:57:57,330
એક-l-i-c-ઈ અથવા B-o-બો જેવા હોય છે.

965
00:57:57,330 --> 00:58:02,480
અને માર્ગ કે જેમાં આ માહિતી સ્ટોર્સ એલિસ અને બોબ અને ચાર્લી અને અનિતા અને તેથી આગળ

966
00:58:02,480 --> 00:58:06,970
છે તે એરે ઉપયોગ કરે છે જેમાં એક trie એલિસ ઇન સંગ્રહ,

967
00:58:06,970 --> 00:58:09,820
અમે રુટ નોડ કે જે એરે જેવી લાગે શરૂ થાય છે,

968
00:58:09,820 --> 00:58:12,080
અને તે લઘુલિપિ નોટેશનમાં લખવામાં આવ્યું છે.

969
00:58:12,080 --> 00:58:15,070
લેખક abcdefg અવગણવામાં કારણ કે ત્યાં સાથે કોઈ નામો હતા.

970
00:58:15,070 --> 00:58:19,150
તેઓ માત્ર એમ અને અને પી ટી દર્શાવ્યું હતું, પરંતુ આ કિસ્સામાં,

971
00:58:19,150 --> 00:58:22,780
ચાલો કેટલાક નામો છે કે અહીં એલિસ અને બોબ અને ચાર્લી દૂર ચાલ્યા જાય.

972
00:58:22,780 --> 00:58:25,670
મેક્સવેલ આ ડાયાગ્રામમાં ખરેખર છે.

973
00:58:25,670 --> 00:58:29,570
આમ કેવી રીતે લેખક સ્ટોર હતી એમ એક-x-વાઇડ ઈ-l-l?

974
00:58:29,570 --> 00:58:36,990
તે અથવા તેણી રુટ નોડ શરૂ, અને ગયા [એમ], જેથી 13 આશરે, એરે માં 13 મી સ્થાન.

975
00:58:36,990 --> 00:58:40,750
ત્યાંથી પછી, ત્યાં એક નિર્દેશક છે.

976
00:58:40,750 --> 00:58:42,760
એક અન્ય એરે માટે અગ્રણી નિર્દેશક.

977
00:58:42,760 --> 00:58:47,880
ત્યાં ના લેખક એક સ્થાન પર તે એરે માં અનુક્રમિત છે, ટોચ ડાબી બાજુએ ત્યાં ચિત્રિત,

978
00:58:47,880 --> 00:58:52,250
અને પછી તે અથવા તેણીએ અન્ય એરે કે નિર્દેશક અનુસર્યું હોય,

979
00:58:52,250 --> 00:58:55,460
અને સ્થાન એક્સ ખાતે નિર્દેશક ગયા

980
00:58:55,460 --> 00:58:59,840
પછી આગળની એરે સ્થાન ડબલ્યુ, ઇ, એલ, એલ, અને તેથી આગળ છે,

981
00:58:59,840 --> 00:59:03,090
અને છેલ્લે, ચાલો ખરેખર આ એક ચિત્ર મૂકવામાં પ્રયાસ કરો.

982
00:59:03,090 --> 00:59:05,380
કોડ જેમ નોડ દેખાવ શું કરે છે?

983
00:59:05,380 --> 00:59:11,820
એક trie એક નોડ વધુ ગાંઠો પોઇંટરો ઝાકઝમાળ સમાવે છે.

984
00:59:11,820 --> 00:59:16,090
પરંતુ ત્યાં પણ બુલિયન કિંમત કેટલાક પ્રકારની આ અમલીકરણ, ઓછામાં ઓછું હોવું મળ્યું છે.

985
00:59:16,090 --> 00:59:18,770
હું તેને is_word કૉલ થાય છે. શા માટે?

986
00:59:18,770 --> 00:59:22,670
કારણ કે જ્યારે તમે મેક્સવેલ દાખલ કરી રહ્યાં છો, તમે નથી કરી રહ્યાં છો દાખલ

987
00:59:22,670 --> 00:59:25,300
આ માહિતી માળખામાં કંઈપણ.

988
00:59:25,300 --> 00:59:27,480
તમે એમ ન લખવાનું તમે એક્સ નથી લખી રહ્યાં રહ્યાં છો

989
00:59:27,480 --> 00:59:30,240
બધા તમે કરી રહ્યા પોઇંટરો પગલે છે.

990
00:59:30,240 --> 00:59:33,360
આ નિર્દેશક કે એમ, પછી નિર્દેશક કે એક પ્રતિનિધિત્વ દર્શાવે છે,

991
00:59:33,360 --> 00:59:36,310
પછી નિર્દેશક કે એક્સ, પછી ડબલ્યુ, ઇ, એલ, એલ રજૂ કરે છે,

992
00:59:36,310 --> 00:59:41,950
પરંતુ તમે ઓવરને અંતે જરૂર શું જાય છે, તપાસ જેવું છે, હું આ સ્થાન પર પહોંચ્યા છો.

993
00:59:41,950 --> 00:59:45,560
ત્યાં એક શબ્દ કે માહિતી માળખું અહીં અંત થાય હતું.

994
00:59:45,560 --> 00:59:48,190
>> તેથી શું trie ખરેખર ભરવામાં આવે છે અને લેખક માટે પ્રતિનિધિત્વ પસંદ કર્યું

995
00:59:48,190 --> 00:59:51,880
થોડું ત્રિકોણ સાથે આ terminuses.

996
00:59:51,880 --> 00:59:56,470
આ માત્ર અર્થ એ છે કે હકીકત આ ત્રિકોણ છે, સાચું આ બુલિયન કિંમત

997
00:59:56,470 --> 00:59:59,200
અર્થ છે જો તમે વૃક્ષ પાછળની જાઓ,

998
00:59:59,200 --> 01:00:02,420
કે જે મેક્સવેલ આ છે નામવાળી શબ્દ અર્થ છે.

999
01:00:02,420 --> 01:00:04,870
પરંતુ હમણાં પૂરતું શબ્દ foo,

1000
01:00:04,870 --> 01:00:07,970
આ વૃક્ષ નથી, તો હું રુટ નોડ પર ટોચ પર અહીં શરૂ કારણ કે,

1001
01:00:07,970 --> 01:00:14,030
ત્યાં કોઈ એફ નિર્દેશક, કોઈ ઓ નિર્દેશક, કોઈ ઓ નિર્દેશક છે. Foo આ શબ્દકોશમાં એક નામ નથી.

1002
01:00:14,030 --> 01:00:22,460
પરંતુ તેનાથી વિપરીત, ટ્યુરિંગ, ટી યુ-r-i-n-ત. ફરીથી, હું ટી અથવા યુ અથવા r અથવા i અથવા n અથવા ત ન સંગ્રહિત નહોતો.

1003
01:00:22,460 --> 01:00:29,820
પરંતુ હું આ માહિતી માળખું સ્ટોર સાચું નીચે આ નોડ અહીં માર્ગ ની કિંમત કર્યું - આ વૃક્ષ

1004
01:00:29,820 --> 01:00:33,030
સાચું માટે is_word આ બુલિયન કિંમત સુયોજિત કરીને.

1005
01:00:33,030 --> 01:00:35,740
તેથી trie આ ખૂબ જ રસપ્રદ મેટા માળખું પ્રકારની છે,

1006
01:00:35,740 --> 01:00:39,810
જ્યાં તમે ખરેખર આ શબ્દો પોતે સ્ટોર કરી રહ્યાં છો શબ્દકોશ આ પ્રકારની છે.

1007
01:00:39,810 --> 01:00:45,100
સ્પષ્ટ હોય છે, તમે માત્ર હા અથવા ના સ્ટોર કરી રહ્યાં છો, ત્યાં એક શબ્દ છે જે અહીં થાય છે.

1008
01:00:45,100 --> 01:00:46,430
>> હવે સૂચિતાર્થ શું છે?

1009
01:00:46,430 --> 01:00:51,120
જો તમે શબ્દકોશમાં 150,000 શબ્દો હોય કે જે તમે મેમરીમાં સ્ટોર કરવાનો પ્રયાસ કરી રહ્યાં છો

1010
01:00:51,120 --> 01:00:53,400
એક કડી થયેલ યાદી કંઈક વાપરી રહ્યા હોય,

1011
01:00:53,400 --> 01:00:56,870
તમે તમારા કડી થયેલ યાદીમાં 150,000 નોડ્સ ધરાવતા નથી જતા હોય છે.

1012
01:00:56,870 --> 01:01:00,250
અને એક તે શબ્દો મૂળાક્ષરોની શોધવામાં ઓ સમય (એન) લઇ શકે છે.

1013
01:01:00,250 --> 01:01:04,370
લીનિયર સમય. પરંતુ trie ના અહીં કિસ્સામાં,

1014
01:01:04,370 --> 01:01:09,210
એક શબ્દ શોધવાની ચાલી રહેલ સમય શું છે?

1015
01:01:09,210 --> 01:01:17,390
તેને સુંદરતા વળે અહીં એ છે કે જો તમે આ શબ્દકોશ પહેલેથી જ 149.999 શબ્દો છે,

1016
01:01:17,390 --> 01:01:20,170
કારણ કે આ માહિતી બંધારણ સાથે અમલ,

1017
01:01:20,170 --> 01:01:25,560
કેટલી સમયે તે શોધવા માટે અથવા વધુ એક વ્યક્તિ સામેલ છે કે જે માં, એલિસને જેવા એલિસ, લે!

1018
01:01:25,560 --> 01:01:30,640
વેલ, તે માત્ર 5 છે, કદાચ પાછળનો અક્ષર માટે 6 પગલાંઓ.

1019
01:01:30,640 --> 01:01:32,880
કારણ કે માળખામાં અન્ય નામોની presense

1020
01:01:32,880 --> 01:01:35,340
એલિસ દાખલ ના રીતે મળી નથી.

1021
01:01:35,340 --> 01:01:39,640
વધુમાં, એલિસ શોધવામાં એક વખત આ શબ્દકોશમાં 150,000 શબ્દો છે

1022
01:01:39,640 --> 01:01:41,960
નથી બધા વિચાર નથી એલિસ શોધવામાં તમારી રીતે,

1023
01:01:41,960 --> 01:01:46,880
કારણ કે એલિસ છે. . . . . અહીં, કારણ કે હું એક બુલિયન કિંમત મળી નથી.

1024
01:01:46,880 --> 01:01:50,920
અને જો ત્યાં કોઈ બુલિયન સાચું હોય, તો પછી એલિસ છે શબ્દો અને આ માહિતી માળખું નથી.

1025
01:01:50,920 --> 01:01:56,220
અન્ય શબ્દોમાં, વસ્તુઓ શોધવામાં અને દાખલ આ નવા માં વસ્તુઓ ચાલી રહેલ સમય

1026
01:01:56,220 --> 01:02:01,920
trie ઓફ માહિતી માળખું ઓ છે - તે નથી n છે.

1027
01:02:01,920 --> 01:02:05,730
કારણ કે 150,000 લોકો presense એલિસ પર કોઈ અસર થતી નથી, એવું લાગે છે.

1028
01:02:05,730 --> 01:02:11,560
તેથી આપણે તે k, જ્યાં k ઇંગલિશ એક શબ્દ મહત્તમ લંબાઈ છે કૉલ

1029
01:02:11,560 --> 01:02:14,050
જે સામાન્ય રીતે કોઈ વધુ અક્ષરો 20-કંઈક કરતાં.

1030
01:02:14,050 --> 01:02:17,940
તેથી k સતત છે. હોલી ગ્રેઇલનો તેથી અમે હવે મળી છે એવું લાગે છે

1031
01:02:17,940 --> 01:02:26,000
એક trie, દાખલ માટે સતત સમય કે નાશ માટે લુકઅપો માટે, છે.

1032
01:02:26,000 --> 01:02:29,170
કારણ કે માળખું પહેલેથી જ વસ્તુઓ સંખ્યા,

1033
01:02:29,170 --> 01:02:32,600
જે પણ શારીરિક ત્યાં નથી. ફરીથી, તેઓ માત્ર સૉર્ટ કરી રહ્યા છો બંધ ચકાસાયેલ, હા અથવા ના,

1034
01:02:32,600 --> 01:02:35,050
તેના ભાવિ ચાલી સમય પર કોઇ અસર ધરાવે છે.

1035
01:02:35,050 --> 01:02:37,940
>> પરંતુ એક કેચ પ્રયત્ન મળ્યું છે, અન્યથા અમે ખૂબ જ સમય ન પામે કરશે

1036
01:02:37,940 --> 01:02:41,460
આ તમામ અન્ય માહિતી માળખા પર માત્ર આખરે ગુપ્ત એક કે આશ્ચર્યજનક છે મેળવવા માટે.

1037
01:02:41,460 --> 01:02:46,410
તેથી શું કિંમત અમે આ મહત્તા અહીં હાંસલ ભરવા આવે છે? જગ્યા.

1038
01:02:46,410 --> 01:02:49,010
આ બાબત વ્યાપક છે. અને કારણ કે લેખક

1039
01:02:49,010 --> 01:02:52,400
નહોતી અહીં હાજર નથી તે નોટિસ, આ વસ્તુઓ છે કે જે એરે આના જેવો તમામ કે,

1040
01:02:52,400 --> 01:02:55,400
તેમણે વૃક્ષ બાકીના માટે, trie બાકીના ન દોરવા નહોતી,

1041
01:02:55,400 --> 01:02:58,060
કારણ કે તેઓ ફક્ત વાર્તા સાથે સંબંધિત નથી.

1042
01:02:58,060 --> 01:03:01,870
પરંતુ આ ગાંઠો બધી વ્યાપક સુપર છે, અને વૃક્ષ દરેક નોડ અપ લે છે

1043
01:03:01,870 --> 01:03:07,780
26 અથવા વાસ્તવમાં, 27 અક્ષરો કારણ કે આ કિસ્સામાં હું એપોસ્ટ્રોફી માટે જગ્યા સહિત હતી હોઈ શકે છે

1044
01:03:07,780 --> 01:03:09,980
તેથી અમે apostrophized શબ્દો હોઇ શકે છે.

1045
01:03:09,980 --> 01:03:14,450
આ કિસ્સામાં, આ વિશાળ એરે છે. તેથી ભલે તેઓ picutured કરી રહ્યાં છો,

1046
01:03:14,450 --> 01:03:18,190
આ અપ RAM ની એક વ્યાપક જથ્થો લે છે.

1047
01:03:18,190 --> 01:03:20,670
જે દંડ હોઇ શકે છે, આધુનિક હાર્ડવેર especilly શકે છે,

1048
01:03:20,670 --> 01:03:25,650
પણ જે સંતુલિત છે. અમે વધુ જગ્યા ખર્ચીને ઓછો સમય મળે છે.

1049
01:03:25,650 --> 01:03:28,580
તેથી જ્યાં આ તમામ રહ્યું છે?

1050
01:03:28,580 --> 01:03:32,640
વેલ, જે દો - માતાનો અહીં જોવા દો.

1051
01:03:32,640 --> 01:03:39,510
માતાનો આ વ્યક્તિ માટે જમ્પ અહીં દો.

1052
01:03:39,510 --> 01:03:43,450
>> તે માને છે કે નહિં, કારણ કે ખૂબ મજા તરીકે સી કેટલાક સમય માટે કરવામાં આવી છે, હવે,

1053
01:03:43,450 --> 01:03:48,130
અમે સત્ર જ્યાં તેને વધુ આધુનિક વસ્તુઓ પર સંક્રમિત કરવા સમય માં બિંદુ સુધી પહોંચી રહ્યાં છો.

1054
01:03:48,130 --> 01:03:50,950
ઊંચા સ્તર પર વસ્તુઓ. અને પણ અઠવાડિયા ના આગળના દંપતિ માટે છતાં

1055
01:03:50,950 --> 01:03:54,580
અમે હજુ જાતને પોઇંટરો અને મેમરી વ્યવસ્થાપનની વિશ્વમાં નિમજ્જન ચાલુ રાખીશું

1056
01:03:54,580 --> 01:03:57,210
કે આરામ કે જેની સાથે આપણે પછી પર બિલ્ડ કરી શકો છો,

1057
01:03:57,210 --> 01:04:01,270
ઓવરને અંતે રમત છે રજૂઆત, કટાક્ષરૂપે આ ભાષામાં નથી.

1058
01:04:01,270 --> 01:04:03,330
અમે, 10 એચટીએમએલ વિશે વાત મિનિટ જેવી ખર્ચવા પડશે.

1059
01:04:03,330 --> 01:04:05,950
બધા HTML છે એક માર્કઅપ ભાષા છે, અને એક માર્કઅપ ભાષા શું છે

1060
01:04:05,950 --> 01:04:10,220
ઓપન કૌંસ અને બંધ કૌંસ છે કે કહેવું 'આ છૂટ લેવી' આ શ્રેણી છે

1061
01:04:10,220 --> 01:04:12,000
'બનાવવા આ ત્રાંસા', 'આ કેન્દ્રિત બનાવે છે.'

1062
01:04:12,000 --> 01:04:14,250
તે બધા બુદ્ધિપૂર્વક રસપ્રદ, નથી પરંતુ તે ઉપયોગી સુપર છે.

1063
01:04:14,250 --> 01:04:16,650
અને તે ચોક્કસપણે છે સર્વવ્યાપી આ દિવસોમાં.

1064
01:04:16,650 --> 01:04:19,450
પરંતુ શું HTML ની ​​વિશ્વ વિશે શક્તિશાળી છે, અને વેબ પ્રોગ્રામિંગ વધુ સામાન્ય રીતે,

1065
01:04:19,450 --> 01:04:25,910
છે ગતિશીલ વસ્તુઓ મકાન; PHP અથવા Python અથવા રૂબી અથવા જાવા અથવા C # જેવી ભાષાઓમાં કોડ લખ્યું.

1066
01:04:25,910 --> 01:04:30,360
ખરેખર, ગમે પસંદગીના તમારી ભાષા છે, અને HTML ગતિશીલ બનાવવા.

1067
01:04:30,360 --> 01:04:32,960
સીએસએસ ગતિશીલ કહેવાય કંઈક પેદા.

1068
01:04:32,960 --> 01:04:35,810
કેસ્કેડીંગ સ્ટાઇલ શીટ્સ, જે સૌંદર્ય શાસ્ત્ર વિષે પણ છે.

1069
01:04:35,810 --> 01:04:41,360
અને તેથી આજે ભલે, જો હું પરિચિત Google.com જેવા કેટલાક વેબસાઇટ પર જાઓ,

1070
01:04:41,360 --> 01:04:46,100
અને હું જોવા, વિકાસકર્તા, દૃશ્ય સ્ત્રોત છે, જે કદાચ તમે પહેલાં કર્યું જાઓ,

1071
01:04:46,100 --> 01:04:49,800
પરંતુ સ્ત્રોત જોઈ જવાનું, આ સામગ્રી કદાચ ખૂબ ભેદી જુએ છે.

1072
01:04:49,800 --> 01:04:55,320
પરંતુ આ અંતર્ગત કોડ કે Google.com અમલીકરણ છે.

1073
01:04:55,320 --> 01:04:57,940
આ બોલ પર ઓવરને. અને ખરેખર આ તમામ રુંવાટીવાળું સૌંદર્ય શાસ્ત્ર સામગ્રી છે.

1074
01:04:57,940 --> 01:05:01,740
આ અહીં CSS છે અપ. જો હું સ્ક્રોલિંગને નીચે રાખવા અમે કેટલીક સામગ્રી રંગ કોડેડ મળશે.

1075
01:05:01,740 --> 01:05:06,890
આ HTML છે. Google ની કોડ વાસણ જેવી લાગે છે, પરંતુ જો હું ખરેખર એક અલગ વિન્ડોમાં ખોલો,

1076
01:05:06,890 --> 01:05:09,380
અમે આ માટે કેટલાક માળખું જોઈ શકો છો.

1077
01:05:09,380 --> 01:05:12,640
જો હું આ અપ ખોલવા માટે, અહીં નોટિસ, તે થોડી વધુ વાંચનીય છે.

1078
01:05:12,640 --> 01:05:16,850
અમે લાંબા સમય અગાઉ આ ટૅગને જોઈ રહ્યા છીએ, [શબ્દ] ટૅગ છે,

1079
01:05:16,850 --> 01:05:23,520
HTML, માથું, શરીર, div, સ્ક્રિપ્ટ, લખાણ વિસ્તારમાં, span, કેન્દ્રી, DIV.

1080
01:05:23,520 --> 01:05:26,770
અને આ પણ પ્રથમ નજરમાં છે ભેદી દેખાવ ઓફ સૉર્ટ,

1081
01:05:26,770 --> 01:05:30,890
પરંતુ આ વાસણ તમામ કેટલીક ચોક્કસ પ્રકારની પેટર્ન, અને પુનરાવર્તિત પેટર્ન અનુસરે છે,

1082
01:05:30,890 --> 01:05:33,850
જેથી કરીને અમે મૂળભૂત વિચાર નીચે, તમે આ જેવી કોડ લખી કરવાનો પ્રયત્ન કરીશું

1083
01:05:33,850 --> 01:05:37,550
અને પછી હજુ સુધી બીજી ભાષા, જાવાસ્ક્રીપ્ટ કહેવાય મદદથી આ જેવી કોડ ચાલાકી.

1084
01:05:37,550 --> 01:05:40,440
અને જાવાસ્ક્રિપ્ટ એક બ્રાઉઝર એક ભાષા કે અંદર ચલાવે છે

1085
01:05:40,440 --> 01:05:44,380
આજે કે અમે જે કોર્સમાં શોપિંગ સાધન કે Google નકશાઓ વાપરે માટે હાર્વર્ડ અભ્યાસક્રમો પર ઉપયોગ

1086
01:05:44,380 --> 01:05:48,660
તમને dynamism સંપૂર્ણ ઝૂડો આપો, ફેસબુક તમે આપે ઇન્સ્ટન્ટ સ્થિતિ અપડેટ્સ બતાવે છે,

1087
01:05:48,660 --> 01:05:51,430
Twitter પર તે વાપરે તમે ટ્વીટ્સ તત્કાલ દર્શાવે છે.

1088
01:05:51,430 --> 01:05:53,820
આ તમામ અમે જાતને નિમજ્જન સાઇન શરૂ થશે

1089
01:05:53,820 --> 01:05:57,190
પરંતુ ત્યાં વિચાર, અમે ઇન્ટરનેટ વિશે થોડું કંઈક સમજી જરૂર છે.

1090
01:05:57,190 --> 01:06:01,130
આ અહીં ક્લિપ માત્ર એક લાંબા મિનિટ છે, અને ચાલો ધારે હવે માટે આ હકીકત છે,

1091
01:06:01,130 --> 01:06:08,380
કેવી રીતે ઈન્ટરનેટ શું આવવા વિશે માટે સતામણી કરનાર તરીકે કામ કરે છે. હું તમને આપી "વોરિયર ઓફ ધ નેટ."

1092
01:06:08,380 --> 01:06:14,720
>> [♫ ધીમો સમૂહગીત સંગીત ♫]

1093
01:06:14,720 --> 01:06:20,450
[પુરૂષ વર્ણનકાર] તેમણે એક સંદેશો હતો.

1094
01:06:20,450 --> 01:06:23,770
એ પ્રોટોકોલ છે તેના બધા પોતાની સાથે.

1095
01:06:23,770 --> 01:06:37,270
[♫ ઝડપી ઇલેક્ટ્રોનિક સંગીત ♫]

1096
01:06:37,270 --> 01:06:41,330
તેમણે ઠંડી ફાયરવોલ એક વિશ્વ આવ્યા હતા, રાઉટર્સ uncaring,

1097
01:06:41,330 --> 01:06:45,690
અને અત્યાર સુધી મૃત્યુ કરતાં વધુ ખરાબ જોખમો.

1098
01:06:45,690 --> 01:06:55,400
તેમણે ઝડપી છે. તેમણે મજબૂત છે. તેમણે TCP / IP છે, અને તે તમારું સરનામું મળ્યું છે.

1099
01:06:55,400 --> 01:06:59,250
વોરિયર ઓફ ધ નેટ.

1100
01:06:59,250 --> 01:07:05,290
[Malan] આગળ સપ્તાહ, પછી. ઇન્ટરનેટ. વેબ પ્રોગ્રામિંગ. આ CS50 છે.

1101
01:07:05,290 --> 01:07:08,290
[CS50.TV]