1
00:00:00,000 --> 00:00:02,570
[Powered by Google Translate] [Дел 3 - поудобно]

2
00:00:02,570 --> 00:00:05,070
[Роб Бауден - Универзитетот Харвард]

3
00:00:05,070 --> 00:00:07,310
>> [Ова е CS50. - CS50.TV]

4
00:00:07,310 --> 00:00:12,700
>> Па првото прашање е чудно формулиран.

5
00:00:12,700 --> 00:00:17,480
GDB ви овозможува "debug" програма, но, поточно, она што не го да ви направам?

6
00:00:17,480 --> 00:00:22,590
Јас ќе ви одговорам дека еден, и јас не знам што точно се очекува,

7
00:00:22,590 --> 00:00:27,910
па јас сум Сомневајќи се дека е нешто по должината на линиите на што ви овозможува да чекор по чекор

8
00:00:27,910 --> 00:00:31,540
прошетка низ програмата, да разговарате со него, промена променливи, прават сите овие работи -

9
00:00:31,540 --> 00:00:34,270
во основа целосно контрола на извршувањето на програмата

10
00:00:34,270 --> 00:00:38,410
и врши увид секој даден дел од извршувањето на програмата.

11
00:00:38,410 --> 00:00:43,030
Значи оние карактеристики ви овозможи да debug работи.

12
00:00:43,030 --> 00:00:44,830
Во ред.

13
00:00:44,830 --> 00:00:50,520
Зошто бинарни пребарување бараат низа да бидат подредени?

14
00:00:50,520 --> 00:00:53,360
Кој сака да одговори на тоа?

15
00:00:56,120 --> 00:01:00,070
[Студент] Поради тоа не функционира ако тоа не е сортирана. >> Да. [Смеа]

16
00:01:00,070 --> 00:01:04,910
Ако тоа не е сортирани, тогаш е невозможно да го подели на половина

17
00:01:04,910 --> 00:01:07,850
и знае дека сè на лево е помалку и се на правото

18
00:01:07,850 --> 00:01:10,490
е поголема од средната вредност.

19
00:01:10,490 --> 00:01:12,790
Па затоа треба да се решат.

20
00:01:12,790 --> 00:01:14,170
Во ред.

21
00:01:14,170 --> 00:01:17,570
Зошто е балон вид во О од n квадрат?

22
00:01:17,570 --> 00:01:23,230
Дали некој прв сакате да им даде многу брз високо ниво преглед на она што меур вид е?

23
00:01:25,950 --> 00:01:33,020
[Студент] Вие во основа поминат низ секој елемент и да се провери првите неколку елементи.

24
00:01:33,020 --> 00:01:37,150
Ако тие се надвор од местото каде што можете да ги трампа, тогаш проверете на следните неколку елементи и така натаму.

25
00:01:37,150 --> 00:01:40,770
Кога ќе стигне до крајот, тогаш знаете дека најголемиот елемент се наоѓа на крајот,

26
00:01:40,770 --> 00:01:42,750
така да се игнорира дека еден тогаш продолжи да оди преку,

27
00:01:42,750 --> 00:01:48,490
и секој пат кога ќе треба да се провери еден помалку елемент додека не направи никакви промени. >> Да.

28
00:01:48,490 --> 00:01:58,470
Таа се вика меур вид, бидејќи ако флип низа на негова страна, па тоа е нагоре и надолу, вертикална,

29
00:01:58,470 --> 00:02:03,100
тогаш големи вредности ќе потоне на дното и мали вредности ќе меур до врвот.

30
00:02:03,100 --> 00:02:05,210
Тоа е како тоа го добило името.

31
00:02:05,210 --> 00:02:08,220
И да, само одат преку.

32
00:02:08,220 --> 00:02:11,190
Можете Продолжувам да одам преку низа, Замена на поголема вредност

33
00:02:11,190 --> 00:02:14,040
за да се добие најголем вредности на дното.

34
00:02:14,040 --> 00:02:17,500
>> Зошто е О од n квадрат?

35
00:02:18,690 --> 00:02:24,620
Прво, дали некој сака да каже зошто тоа е О од n квадрат?

36
00:02:24,620 --> 00:02:28,760
[Студент] Бидејќи за секој работи оди n пати.

37
00:02:28,760 --> 00:02:32,100
Можете само да бидете сигурни дека сте ги направиле најголемите елемент на целиот пат,

38
00:02:32,100 --> 00:02:35,230
тогаш мора да повторам дека за толку многу елементи. >> Да.

39
00:02:35,230 --> 00:02:41,800
Значи имајте на ум она што големите О значи и она што големите Омега средства.

40
00:02:41,800 --> 00:02:50,560
Големите О е како горна граница за тоа како бавно тоа всушност може да работи.

41
00:02:50,560 --> 00:02:58,990
Значи, велејќи дека е О од n квадрат, тоа не е O на n или на друго место ќе биде во можност да се кандидира

42
00:02:58,990 --> 00:03:02,640
во линеарна време, но тоа е О од n коцки

43
00:03:02,640 --> 00:03:06,390
бидејќи тоа се граничи со О на n коцки.

44
00:03:06,390 --> 00:03:12,300
Ако тоа е граничи со О на n квадрат, тогаш тоа е граничи и со n коцки.

45
00:03:12,300 --> 00:03:20,280
Па тоа е N квадрат, а во апсолутна најлош случај таа не може да го направи подобро од n квадрат,

46
00:03:20,280 --> 00:03:22,830
кој е зошто тоа е О на N квадрат.

47
00:03:22,830 --> 00:03:31,200
Значи да се види мала математика како тоа излегува да биде n квадрат,

48
00:03:31,200 --> 00:03:40,530
ако имаме пет нешта во нашата листа, прв пат колку свопови може да се потенцијално треба да се направи

49
00:03:40,530 --> 00:03:47,170
со цел да се добие оваа? Да, всушност, само -

50
00:03:47,170 --> 00:03:52,040
Колку свопови сме ние ќе треба да се направи во првиот рок на меурот вид преку низа?

51
00:03:52,040 --> 00:03:53,540
[Студент] n - 1. >> Да.

52
00:03:53,540 --> 00:03:58,340
>> Ако има 5 елементи, ние ќе треба да се направи n - 1.

53
00:03:58,340 --> 00:04:01,100
Потоа на втората колку свопови сме ние ќе треба да се направи?

54
00:04:01,100 --> 00:04:03,440
[Студент] n - 2. >> Да.

55
00:04:03,440 --> 00:04:11,640
А третиот ќе биде n - 3, а потоа за погодност јас ќе напишам во последните две

56
00:04:11,640 --> 00:04:15,270
како тогаш ние ќе треба да се направи 2 свопови и 1 swap.

57
00:04:15,270 --> 00:04:19,899
Претпоставувам дека последната може или не, всушност може да треба да се случи.

58
00:04:19,899 --> 00:04:22,820
Тоа е трампа? Не знам.

59
00:04:22,820 --> 00:04:26,490
Значи овие се вкупните износи на свопови или барем споредби треба да се направи.

60
00:04:26,490 --> 00:04:29,910
Дури и ако не трампа, се уште треба да се споредуваат вредностите.

61
00:04:29,910 --> 00:04:33,910
Значи постојат n - 1 споредби во првиот рок преку низа.

62
00:04:33,910 --> 00:04:42,050
Ако ги преуредите овие работи, да всушност го направи шест работи па работите магацинот убаво,

63
00:04:42,050 --> 00:04:44,790
а потоа јас ќе сторам 3, 2, 1.

64
00:04:44,790 --> 00:04:49,910
Па само преуредување овие суми, ние сакаме да видиме колку споредби правиме

65
00:04:49,910 --> 00:04:52,700
во целиот алгоритам.

66
00:04:52,700 --> 00:04:56,550
Значи, ако ние ги овие момци овде долу,

67
00:04:56,550 --> 00:05:07,470
тогаш ние сме сè уште само собирање сепак многу споредби имало.

68
00:05:07,470 --> 00:05:13,280
Но, ако ги сумира овие и ние сумира овие и ние сумира овие,

69
00:05:13,280 --> 00:05:18,130
тоа е уште истиот проблем. Ние само сумира оние одредени групи.

70
00:05:18,130 --> 00:05:22,400
>> Па сега ние сме собирање 3 на n. Тоа не е само 3 на n.

71
00:05:22,400 --> 00:05:27,650
Тоа секогаш ќе биде n / 2 на n.

72
00:05:27,650 --> 00:05:29,430
Па овде се случи да имаат 6.

73
00:05:29,430 --> 00:05:34,830
Ако имавме 10 работи, тогаш можеме да го направите ова групирање за 5 различни пара работи

74
00:05:34,830 --> 00:05:37,180
и завршуваат со N + N + N + N + N.

75
00:05:37,180 --> 00:05:45,840
Па ти си секогаш ќе добиете n / 2 л, и така ова ние ќе го трошка до n квадрат / 2.

76
00:05:45,840 --> 00:05:48,890
И така, иако тоа е фактор на половина, што се случува да дојде во

77
00:05:48,890 --> 00:05:54,190
поради фактот дека низ секоја итерација во текот на низа ја споредиме 1 помалку

78
00:05:54,190 --> 00:05:58,040
па тоа е како ние се добие повеќе од 2, но тоа се уште n квадрат.

79
00:05:58,040 --> 00:06:01,650
Ние не се грижат за постојан фактор на половина.

80
00:06:01,650 --> 00:06:07,760
Значи многу големи О работи како оваа се потпира на само вид на прави овој вид на математика,

81
00:06:07,760 --> 00:06:12,260
прави аритметички суми и геометриски серии работи,

82
00:06:12,260 --> 00:06:17,750
но повеќето од нив во овој курс се прилично јасна.

83
00:06:17,750 --> 00:06:19,290
Во ред.

84
00:06:19,290 --> 00:06:24,430
Зошто е вметнување вид со омега на n? Што значи омега значи?

85
00:06:24,430 --> 00:06:27,730
[Двајца ученици зборува одеднаш - неразбирливо] >> Да.

86
00:06:27,730 --> 00:06:30,630
Омега можете да замислите како долниот врзани.

87
00:06:30,630 --> 00:06:36,550
>> Значи без оглед на тоа колку ефикасна вашата вметнување вид алгоритам е,

88
00:06:36,550 --> 00:06:41,810
без оглед на листата што е донесен во, таа секогаш има да се споредат најмалку n работи

89
00:06:41,810 --> 00:06:44,620
или таа има да iterate во текот n работи.

90
00:06:44,620 --> 00:06:47,280
Зошто е тоа така?

91
00:06:47,280 --> 00:06:51,190
[Студент] Затоа што ако листата е веќе сортирани, тогаш во текот на првата итерација

92
00:06:51,190 --> 00:06:54,080
вие само може да гарантира дека првиот елемент е и најмалку важно,

93
00:06:54,080 --> 00:06:56,490
и втората итерација вие само може да гарантира првите две се

94
00:06:56,490 --> 00:07:00,010
затоа што не знаат дека остатокот од листата се подредени. >> Да.

95
00:07:00,010 --> 00:07:08,910
Ако помине во сосема подредени листата, во најмала рака треба да се оди во текот на сите елементи

96
00:07:08,910 --> 00:07:12,180
да се види дека ништо не треба да се пресели наоколу.

97
00:07:12,180 --> 00:07:14,720
Па поминува преку листата и велејќи ох, ова е веќе сортирани,

98
00:07:14,720 --> 00:07:18,240
тоа е невозможно за вас да знаете дека е сортирана додека не се провери секој елемент

99
00:07:18,240 --> 00:07:20,660
да се види дека тие се во подредени цел.

100
00:07:20,660 --> 00:07:25,290
Па на долниот граница на вметнување вид е омега на n.

101
00:07:25,290 --> 00:07:28,210
Што е најлошото трчање време на спојување вид,

102
00:07:28,210 --> 00:07:31,390
Најлошото е голема О повторно?

103
00:07:31,390 --> 00:07:37,660
Па во најлош случај сценарио, како се спојат вид работи?

104
00:07:42,170 --> 00:07:43,690
[Студент] N најавите n. >> Да.

105
00:07:43,690 --> 00:07:49,990
Најбрз општо сортирање алгоритми се n најавите n. Вие не може да се направи подобро.

106
00:07:51,930 --> 00:07:55,130
>> Постојат посебни случаи, и ако имаме време денес - но ние веројатно won't -

107
00:07:55,130 --> 00:07:59,330
можеме да видиме оној кој го прави подобро од n најавите n.

108
00:07:59,330 --> 00:08:04,050
Но во општата случај, не можете да го направите подобро од n најавите n.

109
00:08:04,050 --> 00:08:09,680
И се спојат вид се случува да биде оној што треба да знаете за овој курс кој е n најавите n.

110
00:08:09,680 --> 00:08:13,260
И така ние всушност ќе се спроведува тоа денес.

111
00:08:13,260 --> 00:08:18,070
И, конечно, не повеќе од три реченици, како го прави селекција вид работа?

112
00:08:18,070 --> 00:08:20,370
Дали некој сака да одговори, а јас ќе брои вашите реченици

113
00:08:20,370 --> 00:08:22,390
затоа што ако поминат 3 -

114
00:08:25,530 --> 00:08:28,330
Не се сеќавам некој избор вид?

115
00:08:31,280 --> 00:08:37,809
Избор вид обично е прилично лесно да се сетам само од името.

116
00:08:37,809 --> 00:08:45,350
Вие само iterate во текот на низа, најдете она што најголемата вредност е или најмалиот -

117
00:08:45,350 --> 00:08:47,290
кој редослед ќе бидете сортирање внатре

118
00:08:47,290 --> 00:08:50,750
Па да речеме ние сме сортирање од најмалите до најголемите.

119
00:08:50,750 --> 00:08:55,250
Можете iterate во текот на низа, во потрага по она што минималната елемент е,

120
00:08:55,250 --> 00:08:59,750
одберете ја, и потоа само да го трампа што е на прво место.

121
00:08:59,750 --> 00:09:04,090
А потоа на вториот помине во текот на низа, погледнете за минимум елемент, повторно,

122
00:09:04,090 --> 00:09:07,490
одберете ја, а потоа се разменуваат со она што е во втората позиција.

123
00:09:07,490 --> 00:09:10,650
Значи ние сме само подигање и изборот на минималните вредности

124
00:09:10,650 --> 00:09:16,050
и вметнување на нив во предниот дел на низа се додека не се подредени.

125
00:09:19,210 --> 00:09:21,560
Прашања за тоа?

126
00:09:21,560 --> 00:09:25,710
>> Овие неизбежно се појавуваат во форми што треба да пополните кога сте поднесување на pset.

127
00:09:29,010 --> 00:09:32,360
Тоа се во основа на одговорите на овие.

128
00:09:32,360 --> 00:09:34,230
Океј, па сега кодирање проблеми.

129
00:09:34,230 --> 00:09:40,140
Јас веќе испратена преку е-мејл - никој ништо не добие овој е-мејл? Во ред.

130
00:09:40,140 --> 00:09:46,630
Јас веќе испратена преку е-мејл просторот што ние ќе биде со користење,

131
00:09:46,630 --> 00:09:52,120
и ако кликнете на моето име - па мислам дека ќе одам да биде на дното

132
00:09:52,120 --> 00:09:57,170
поради наназад r - но ако кликнете на моето име ќе видите 2 ревизии.

133
00:09:57,170 --> 00:10:02,650
Ревизија 1 ќе биде веќе копирани и атипичен кодот во простори

134
00:10:02,650 --> 00:10:06,900
за пребарување нешто што ќе мора да ги спроведе.

135
00:10:06,900 --> 00:10:10,540
И ревизија 2 ќе биде вид работа што ги спроведуваме после тоа.

136
00:10:10,540 --> 00:10:15,770
Значи можете да кликнете на мојот верзии 1 и работи од таму.

137
00:10:17,350 --> 00:10:22,060
И сега ние сакаме да се имплементира бинарни пребарување.

138
00:10:22,060 --> 00:10:26,470
>> Сака ли некој да му го даде на pseudocode високо ниво објаснување

139
00:10:26,470 --> 00:10:31,440
на она што ние ќе треба да направите за пребарување? Да.

140
00:10:31,440 --> 00:10:36,170
[Студент] Вие само ги преземе средината на полето и види дали она што го барате

141
00:10:36,170 --> 00:10:38,650
е помала од онаа или повеќе од тоа.

142
00:10:38,650 --> 00:10:41,080
И, ако е помала, ќе се обратите на половина од тоа е помалку,

143
00:10:41,080 --> 00:10:44,750
и ако тоа е повеќе, одете на половина од тоа е повеќе и ќе повторам дека додека вие само се една работа.

144
00:10:44,750 --> 00:10:46,570
[Бауден] Да.

145
00:10:46,570 --> 00:10:51,320
Забележиш дека нашите броеви низа е веќе сортирани,

146
00:10:51,320 --> 00:10:57,190
и така тоа значи дека ние може да ги искористат предностите на тоа и ние прво да се провери,

147
00:10:57,190 --> 00:11:00,390
Океј, јас сум во потрага по бројот 50.

148
00:11:00,390 --> 00:11:03,720
За да можам да одам во средината.

149
00:11:03,720 --> 00:11:07,380
Средината е тешко да се дефинира кога е парен број на нештата,

150
00:11:07,380 --> 00:11:10,820
но ајде да речеме ние секогаш ќе скрати на средината.

151
00:11:10,820 --> 00:11:14,420
Значи тука имаме 8 нешта, па на средината ќе биде 16.

152
00:11:14,420 --> 00:11:17,330
Јас сум во потрага за 50, па 50 е поголем од 16.

153
00:11:17,330 --> 00:11:21,310
Па сега јас во основа може да се третираат мојот низа како овие елементи.

154
00:11:21,310 --> 00:11:23,450
Можам да фрлаат се што во текот од 16.

155
00:11:23,450 --> 00:11:27,440
Сега, мојот низа е само овие 4 елементи, и јас повторувам.

156
00:11:27,440 --> 00:11:31,910
Па тогаш сакам да се најде во средината, повторно, кој ќе биде 42.

157
00:11:31,910 --> 00:11:34,730
42 е помалку од 50, па можам да фрлаат овие два елементи.

158
00:11:34,730 --> 00:11:36,890
Ова е мојот останатите низа.

159
00:11:36,890 --> 00:11:38,430
Одам да се најде среде повторно.

160
00:11:38,430 --> 00:11:42,100
Претпоставувам дека 50 е лош пример, бидејќи јас секогаш беше фрлање работите на лево,

161
00:11:42,100 --> 00:11:48,280
но со иста мерка, ако јас сум во потрага по нешто

162
00:11:48,280 --> 00:11:52,100
и тоа е помалку од елементот Јас сум во моментов во потрага на,

163
00:11:52,100 --> 00:11:55,080
тогаш јас ќе одам да фрлаат се што десно.

164
00:11:55,080 --> 00:11:58,150
Па сега ние треба да се спроведе тоа.

165
00:11:58,150 --> 00:12:02,310
Забележете дека ние треба да го поминат во големина.

166
00:12:02,310 --> 00:12:06,730
Ние не може, исто така, треба да се хард-кодот големина.

167
00:12:06,730 --> 00:12:11,640
Значи, ако ние се ослободи од таа # define -

168
00:12:19,630 --> 00:12:21,430
Во ред.

169
00:12:21,430 --> 00:12:27,180
Како можам убаво да дознаам што големината на броеви низа во моментов е?

170
00:12:27,180 --> 00:12:30,950
>> Колку елементи се броеви низа?

171
00:12:30,950 --> 00:12:33,630
[Студент] Броеви, загради,. Должина?

172
00:12:33,630 --> 00:12:36,600
[Бауден] Тоа не постои во C.

173
00:12:36,600 --> 00:12:38,580
Треба. Должина.

174
00:12:38,580 --> 00:12:42,010
Низи немаат својства, така што не постои должина сопственост на низи

175
00:12:42,010 --> 00:12:45,650
тоа само ќе ви даде сепак долго тоа се случува да биде.

176
00:12:48,180 --> 00:12:51,620
[Студент] Види колку меморија има и подели со колку - >> Да.

177
00:12:51,620 --> 00:12:55,810
Па како можеме да видиме колку меморија има тоа? >> [Студент] sizeof. >> Да, sizeof.

178
00:12:55,810 --> 00:13:01,680
Sizeof е оператор кој нема да се вратат на големината на броеви низа.

179
00:13:01,680 --> 00:13:10,060
И тоа ќе биде сепак многу броеви постојат моменти големината на целобројни

180
00:13:10,060 --> 00:13:14,050
бидејќи тоа е колку меморија е всушност преземањето.

181
00:13:14,050 --> 00:13:17,630
Значи, ако сакам бројот на нештата во низа,

182
00:13:17,630 --> 00:13:20,560
тогаш јас ќе одам да сакате да го подели со големината на цел број.

183
00:13:22,820 --> 00:13:26,010
Во ред. Така што ми овозможува да помине во големина тука.

184
00:13:26,010 --> 00:13:29,430
Зошто треба да го поминат во големина на сите?

185
00:13:29,430 --> 00:13:38,570
Зошто не можам само не се тука int големина = sizeof (стогот) / sizeof (int)?

186
00:13:38,570 --> 00:13:41,490
Зошто ова не функционира?

187
00:13:41,490 --> 00:13:44,470
[Студент] Тоа не е глобалната променлива.

188
00:13:44,470 --> 00:13:51,540
[Бауден] haystack постои и ние поминува во бројки како сено,

189
00:13:51,540 --> 00:13:54,700
и ова е вид на предзнак за она што е да дојде. Да.

190
00:13:54,700 --> 00:14:00,170
[Студент] haystack е само повикување на него, па затоа ќе се врати колку е голема дека референцата е.

191
00:14:00,170 --> 00:14:02,150
Да.

192
00:14:02,150 --> 00:14:09,000
Се сомневам во предавање дека сте виделе на магацинот уште навистина, нели?

193
00:14:09,000 --> 00:14:11,270
Ние само се зборува за тоа.

194
00:14:11,270 --> 00:14:16,090
Така магацинот е местото каде што сите ваши променливи се случува да бидат складирани.

195
00:14:16,090 --> 00:14:19,960
>> Секое меморија, која е наменета за локалните променливи се случува во магацинот,

196
00:14:19,960 --> 00:14:24,790
и секоја функција добива свој простор на магацинот, свој магацинот рамка е она што се вика.

197
00:14:24,790 --> 00:14:31,590
Значи главната има магацинот рамка, и во него се случува да постои оваа броеви низа,

198
00:14:31,590 --> 00:14:34,270
и тоа ќе биде со големина sizeof (броеви).

199
00:14:34,270 --> 00:14:38,180
Тоа се случува да имаат големина на броеви поделено со големина на елементи,

200
00:14:38,180 --> 00:14:42,010
но дека сите животи во магацинот рамка главниот е.

201
00:14:42,010 --> 00:14:45,190
Кога ние го нарекуваме пребарување, барај добива свој магацинот рамка,

202
00:14:45,190 --> 00:14:48,840
свој простор за складирање на сите свои локални променливи.

203
00:14:48,840 --> 00:14:56,420
Но, овие аргументи - па стогот не е копија на целиот спектар.

204
00:14:56,420 --> 00:15:00,990
Ние не го положи во целата низа како копија во пребарувањето.

205
00:15:00,990 --> 00:15:04,030
Тоа само поминува упатување кон таа низа.

206
00:15:04,030 --> 00:15:11,470
Значи за пребарување може да пристапите до овие броеви преку оваа референца.

207
00:15:11,470 --> 00:15:17,100
Тоа е уште пристапува на работите кои живеат во внатрешноста на оџакот рамка главната е,

208
00:15:17,100 --> 00:15:22,990
но во основа, кога ќе дојде до покажувачи, која треба да биде наскоро,

209
00:15:22,990 --> 00:15:24,980
тоа е она што покажувачи се.

210
00:15:24,980 --> 00:15:29,400
Совети се само препораки за нештата, и можете да го користите совети како да пристапите работи

211
00:15:29,400 --> 00:15:32,030
кои се во магацинот рамки други работи.

212
00:15:32,030 --> 00:15:37,660
Па дури и броеви е локално до главна, ние се уште може да ја пристапите преку овој покажувач.

213
00:15:37,660 --> 00:15:41,770
Но, бидејќи тоа е само покажувач и тоа е само појдовна референца,

214
00:15:41,770 --> 00:15:45,040
sizeof (стогот) само се враќа на големина на референтните себе.

215
00:15:45,040 --> 00:15:47,950
Тоа не го врати големината на нешто што е посочувајќи да.

216
00:15:47,950 --> 00:15:51,110
Тоа не се вратат на вистинската големина на броеви.

217
00:15:51,110 --> 00:15:55,660
И така ова не е оди на работа како што сакаме да.

218
00:15:55,660 --> 00:15:57,320
>> Прашања за тоа?

219
00:15:57,320 --> 00:16:03,250
Покажувачи ќе се качил во со значително повеќе крвави детали во недели да дојде.

220
00:16:06,750 --> 00:16:13,740
И ова е причината зошто многу нешта што те гледам, повеќето интернет работи или вид работи,

221
00:16:13,740 --> 00:16:16,990
тие се речиси сите ќе треба да ги преземе вистинските големина на низата,

222
00:16:16,990 --> 00:16:20,440
бидејќи во C, немаме идеја што големината на низата е.

223
00:16:20,440 --> 00:16:22,720
Ќе треба рачно да го помине внатре

224
00:16:22,720 --> 00:16:27,190
А ти да не рачно да помине во целата низа, бидејќи сте само поминува во референтната

225
00:16:27,190 --> 00:16:30,390
и не може да се добие со големина од референца.

226
00:16:30,390 --> 00:16:32,300
Во ред.

227
00:16:32,300 --> 00:16:38,160
Па сега ние сакаме да се спроведе она што беше објаснето.

228
00:16:38,160 --> 00:16:41,530
Можете да работите на неа за една минута,

229
00:16:41,530 --> 00:16:45,250
а вие не мора да се грижите за добивање на сето совршено 100% работи.

230
00:16:45,250 --> 00:16:51,410
Само напишете ја сочинуваат половина pseudocode за тоа како мислите дека треба да работат.

231
00:16:52,000 --> 00:16:53,630
Во ред.

232
00:16:53,630 --> 00:16:56,350
Нема потреба да бидат целосно направено со ова сеуште.

233
00:16:56,350 --> 00:17:02,380
Но, дали некој се чувствуваат удобно со она што тие имаат досега,

234
00:17:02,380 --> 00:17:05,599
како нешто можеме да работиме со заедно?

235
00:17:05,599 --> 00:17:09,690
Сака ли некој да волонтираат? Или јас случајно ќе го избере.

236
00:17:12,680 --> 00:17:18,599
Тоа не мора да биде во право за секоја мерка, но нешто што може да го менува во работна состојба.

237
00:17:18,599 --> 00:17:20,720
[Студент] Секако. >> Океј.

238
00:17:20,720 --> 00:17:27,220
Така можете да заштедите на ревизија со кликнување на малата Зачувај икона.

239
00:17:27,220 --> 00:17:29,950
Ти си Ramya, нели? >> [Студент] Да. >> [Бауден] Во ред.

240
00:17:29,950 --> 00:17:35,140
Па сега јас да ја видите вашата ревизија и секој може да се повлече до ревизија.

241
00:17:35,140 --> 00:17:38,600
И тука имаме - Добро.

242
00:17:38,600 --> 00:17:43,160
Значи Ramya отиде со рекурзивен решение, што е дефинитивно добро решение.

243
00:17:43,160 --> 00:17:44,970
Постојат два начини можете да го направите овој проблем.

244
00:17:44,970 --> 00:17:48,060
Можете или да го направите iteratively или рекурзивно.

245
00:17:48,060 --> 00:17:53,860
Повеќето проблеми ќе се судрите со кои може да се направи рекурзивно, исто така, може да се направи iteratively.

246
00:17:53,860 --> 00:17:58,510
Па еве ние сме го направиле рекурзивно.

247
00:17:58,510 --> 00:18:03,730
>> Дали некој сака да дефинира што значи да се направи функција рекурзивен?

248
00:18:07,210 --> 00:18:08,920
[Студент] Кога ќе имаат функција се нарекува

249
00:18:08,920 --> 00:18:13,470
а потоа се нарекува додека таа излегува со точни и вистинити. >> Да.

250
00:18:13,470 --> 00:18:17,680
Рекурзивен функција е само функција која се нарекува себеси.

251
00:18:17,680 --> 00:18:24,140
Постојат три големи нешта кои рекурзивен функција мора да има.

252
00:18:24,140 --> 00:18:27,310
Првиот е очигледно, тоа се нарекува себеси.

253
00:18:27,310 --> 00:18:29,650
Вториот е на база случај.

254
00:18:29,650 --> 00:18:33,390
Па во одреден момент функцијата треба да престанат да повикуваат себе,

255
00:18:33,390 --> 00:18:35,610
и тоа е она што на база случај е за.

256
00:18:35,610 --> 00:18:43,860
Значи тука знаеме дека ние треба да престане, ние треба да се откажат во нашата пребарување

257
00:18:43,860 --> 00:18:48,150
кога почеток еднаква на крајот - и ќе одиме над она што тоа значи.

258
00:18:48,150 --> 00:18:52,130
Но, конечно, последната работа која е важна за рекурзивен функции:

259
00:18:52,130 --> 00:18:59,250
функциите некако мора да се пријде на база случај.

260
00:18:59,250 --> 00:19:04,140
Како и ако вие не сте всушност ажурирање ништо кога ќе се направи вториот рекурзивен повик,

261
00:19:04,140 --> 00:19:07,880
ако сте буквално само повикување на функцијата повторно со истите аргументи

262
00:19:07,880 --> 00:19:10,130
и без глобални променливи се промениле или ништо,

263
00:19:10,130 --> 00:19:14,430
никогаш нема да стигне до база случај, во кој случај тоа е лошо.

264
00:19:14,430 --> 00:19:17,950
Тоа ќе биде бесконечна рекурзија и магацинот претекување.

265
00:19:17,950 --> 00:19:24,330
Но, тука можеме да видиме дека ажурирање се случува бидејќи ние сме ажурирање започне + крај / 2,

266
00:19:24,330 --> 00:19:28,180
ние сме ажурирање на крајот аргумент тука, ние сме ажурирање на почетокот аргумент тука.

267
00:19:28,180 --> 00:19:32,860
Значи во сите рекурзивните повици ние сме ажурирање нешто. Во ред.

268
00:19:32,860 --> 00:19:38,110
Дали сакате да ни прошетка низ вашето решение? >> Секако.

269
00:19:38,110 --> 00:19:44,270
Јас сум со користење SearchHelp, така што секој пат кога ќе се направи овој повик на функција

270
00:19:44,270 --> 00:19:47,910
Имам почеток на тоа каде јас сум во потрага по во низа и на крајот

271
00:19:47,910 --> 00:19:49,380
на тоа каде јас сум во потрага на низата.

272
00:19:49,380 --> 00:19:55,330
>> На секој чекор каде што тоа е велејќи дека тоа е средината елемент, кој е почеток + крај / 2,

273
00:19:55,330 --> 00:19:58,850
е дека еднаков на она што го барате?

274
00:19:58,850 --> 00:20:04,650
И ако е така, тогаш ние го најде, и претпоставувам дека ќе поминуваат до нивото на рекурзија.

275
00:20:04,650 --> 00:20:12,540
И ако тоа не е точно, тогаш провери дали средна вредност на низата е премногу голема,

276
00:20:12,540 --> 00:20:19,320
во кој случај ние се погледне на левата половина од низата со одење од почеток до средината индекс.

277
00:20:19,320 --> 00:20:22,710
А инаку тоа го правиме на крајот половина.

278
00:20:22,710 --> 00:20:24,740
[Бауден] Во ред.

279
00:20:24,740 --> 00:20:27,730
Тоа звучи добро.

280
00:20:27,730 --> 00:20:36,640
Океј, па неколку работи, а всушност, ова е многу високо ниво работа

281
00:20:36,640 --> 00:20:41,270
дека никогаш нема да треба да знаете за овој курс, но тоа е вистина.

282
00:20:41,270 --> 00:20:46,080
Рекурзивен функции, секогаш слушам дека тие се лош договор

283
00:20:46,080 --> 00:20:51,160
бидејќи ако рекурзивно себе се нарекуваш многу пати, ќе го добиете оџакот преливник

284
00:20:51,160 --> 00:20:54,990
бидејќи, како што реков претходно, секоја функција добива свој магацинот рамка.

285
00:20:54,990 --> 00:20:59,500
Значи секој повик на рекурзивен функција добива свој магацинот рамка.

286
00:20:59,500 --> 00:21:04,140
Значи, ако направиме 1000 рекурзивните повици, ќе добиете 1000 магацинот рамки,

287
00:21:04,140 --> 00:21:08,390
и брзо ќе доведе до кои имаат премногу магацинот рамки и работи едноставно се скрши.

288
00:21:08,390 --> 00:21:13,480
Па затоа рекурзивен функции се генерално лоши.

289
00:21:13,480 --> 00:21:19,370
Но, постои еден убав подмножество на рекурзивен функции наречен опашката рекурзивен функции,

290
00:21:19,370 --> 00:21:26,120
и ова се случува да биде пример на една каде што ако на компајлерот забележува ова

291
00:21:26,120 --> 00:21:29,920
и што треба, мислам дека - во ѕвекот ако помине тоа, О2 знаме

292
00:21:29,920 --> 00:21:33,250
тогаш ќе забележите ова е опашка рекурзивен и да работи добро.

293
00:21:33,250 --> 00:21:40,050
>> Тоа ќе повторна употреба на истиот магацинот рамка одново и одново за секој рекурзивен повик.

294
00:21:40,050 --> 00:21:47,010
И така, бидејќи сте со користење на истите магацинот рамка, вие не треба да се грижите за

295
00:21:47,010 --> 00:21:51,690
некогаш магацинот преплавени, а во исто време, како што рече пред,

296
00:21:51,690 --> 00:21:56,380
каде што некогаш ќе се вратите точно, тогаш тоа треба да се вратат до сите овие магацинот рамки

297
00:21:56,380 --> 00:22:01,740
и 10 повик за SearchHelp има да се вратат на 9-ти, има да се врати во 8.

298
00:22:01,740 --> 00:22:05,360
Така што не треба да се случи кога функции се опашка рекурзивен.

299
00:22:05,360 --> 00:22:13,740
И така она што ја прави оваа функција опашка рекурзивен е известување дека за секој даден повик за searchHelp

300
00:22:13,740 --> 00:22:18,470
рекурзивен повик дека тоа е правење е она што е враќање.

301
00:22:18,470 --> 00:22:25,290
Значи, во првиот повик да SearchHelp, ние или веднаш да се врати лажни,

302
00:22:25,290 --> 00:22:29,590
веднаш да се врати точно, или ние правиме рекурзивен повик да се SearchHelp

303
00:22:29,590 --> 00:22:33,810
каде што ние сме враќање е она што тој повик се враќа.

304
00:22:33,810 --> 00:22:51,560
И не можевме да го направите ова, ако ние го сторивме нешто како int x = SearchHelp, враќање X * 2,

305
00:22:51,560 --> 00:22:55,440
само некои случајни промени.

306
00:22:55,440 --> 00:23:01,470
>> Па сега овој рекурзивен повик, ова int x = SearchHelp рекурзивен повик,

307
00:23:01,470 --> 00:23:05,740
не е веќе опашка рекурзивен бидејќи тоа всушност мора да се вратат

308
00:23:05,740 --> 00:23:10,400
назад кон претходниот магацинот рамка, така што таа претходниот повик на функција

309
00:23:10,400 --> 00:23:13,040
тогаш може да се направи нешто со враќањето вредност.

310
00:23:13,040 --> 00:23:22,190
Значи ова не е опашка рекурзивен, но она што го имавме пред е убаво опашка рекурзивен. Да.

311
00:23:22,190 --> 00:23:27,000
[Студент] не втората база случај треба да се провери прво

312
00:23:27,000 --> 00:23:30,640
бидејќи може да има ситуација каде што кога ќе го положат аргумент

313
00:23:30,640 --> 00:23:35,770
ќе се започне = крај, но тие се на игла вредност.

314
00:23:35,770 --> 00:23:47,310
Прашањето беше да не можеме да се кандидира во случај кога на крајот не е игла вредност

315
00:23:47,310 --> 00:23:52,000
или започнете = крај, соодветно, почнете = крај

316
00:23:52,000 --> 00:23:59,480
и не сте всушност проверени дека одредена вредност, сепак,

317
00:23:59,480 --> 00:24:03,910
потоа започнете + крај / 2 е само ќе биде иста вредност.

318
00:24:03,910 --> 00:24:07,890
Но, ние веќе се врати лажни и ние всушност никогаш не проверив вредност.

319
00:24:07,890 --> 00:24:14,240
Значи, во најмала рака, во првиот повик, ако големината е 0, тогаш ние сакаме да се врати лажни.

320
00:24:14,240 --> 00:24:17,710
Но, ако големината е 1, тогаш почетокот нема да се еднакви крајот,

321
00:24:17,710 --> 00:24:19,820
и ние барем ќе провери еден елемент.

322
00:24:19,820 --> 00:24:26,750
Но, мислам дека вие сте во право во тоа што може да завршат во случај кога започне + крај / 2,

323
00:24:26,750 --> 00:24:31,190
почеток завршува се исти како почеток + крај / 2,

324
00:24:31,190 --> 00:24:35,350
но никогаш не сме всушност проверени тој елемент.

325
00:24:35,350 --> 00:24:44,740
>> Значи, ако ние прво се провери е средината елемент на вредноста што го барате,

326
00:24:44,740 --> 00:24:47,110
тогаш може веднаш да се врати вистина.

327
00:24:47,110 --> 00:24:50,740
Друго, ако тие се еднакви, тогаш нема точка за продолжување на

328
00:24:50,740 --> 00:24:58,440
бидејќи ние сме само ќе да се ажурира на случај каде што сме на еден елемент низа.

329
00:24:58,440 --> 00:25:01,110
Ако тоа еден елемент не е оној што го барате,

330
00:25:01,110 --> 00:25:03,530
тогаш сè е во ред. Да.

331
00:25:03,530 --> 00:25:08,900
[Студент] Работата е дека од големината е всушност поголем од бројот на елементи во низа,

332
00:25:08,900 --> 00:25:13,070
веќе има офсет - >> Така ќе големината -

333
00:25:13,070 --> 00:25:19,380
[Студент] Велат дека ако низата е големина 0, тогаш SearchHelp, всушност, ќе се провери стогот од 0

334
00:25:19,380 --> 00:25:21,490
на првиот повик.

335
00:25:21,490 --> 00:25:25,300
Низата има големина 0, па 0 е - >> Да.

336
00:25:25,300 --> 00:25:30,750
Има уште нешто што - тоа би можело да биде добро. Ајде да мислам.

337
00:25:30,750 --> 00:25:40,120
Значи, ако низата имаше 10 елементи и средната ние ќе да се провери е индекс 5,

338
00:25:40,120 --> 00:25:45,700
па ние сме проверка 5, и да речеме дека вредноста е помала.

339
00:25:45,700 --> 00:25:50,720
Па ние сме фрлање се далеку од 5 до денес.

340
00:25:50,720 --> 00:25:54,030
Така на проектот + крај / 2 ќе биде нашиот нов крајот,

341
00:25:54,030 --> 00:25:57,450
Така да, тоа е секогаш ќе остане надвор од крајот на низата.

342
00:25:57,450 --> 00:26:03,570
Ако тоа е случај, ако тоа беше дури и или непарни, тогаш ние ќе провери, да речеме, 4,

343
00:26:03,570 --> 00:26:05,770
но ние сме уште фрлањето -

344
00:26:05,770 --> 00:26:13,500
Така да, крајот е секогаш ќе биде надвор од реалните крајот на низата.

345
00:26:13,500 --> 00:26:18,350
Па елементи ние се фокусираме на, на крајот е секогаш ќе биде оној после тоа.

346
00:26:18,350 --> 00:26:24,270
И така, ако проектот не секогаш еднаков крајот, ние сме во низа на големината 0.

347
00:26:24,270 --> 00:26:35,600
>> Од друга работа јас мислев е ние сме ажурирање на почеток да се започне + крај / 2,

348
00:26:35,600 --> 00:26:44,020
па ова е случај дека јас сум имаат проблеми со, каде започне + крај / 2

349
00:26:44,020 --> 00:26:46,820
е елемент сме проверка.

350
00:26:46,820 --> 00:26:58,150
Да речеме дека имавме оваа 10-елемент низа. Сеедно.

351
00:26:58,150 --> 00:27:03,250
Така на проектот + крај / 2 ќе биде нешто како овој,

352
00:27:03,250 --> 00:27:07,060
и ако тоа не е вредност, велат сакаме да се ажурира.

353
00:27:07,060 --> 00:27:10,060
Вредноста е поголема, затоа сакаме да се погледне во оваа половина на низата.

354
00:27:10,060 --> 00:27:15,910
Па како ние сме ажурирање почеток, ние сме ажурирање почеток до сега да биде овој елемент.

355
00:27:15,910 --> 00:27:23,790
Но, ова сè уште може да работи, или во најмала рака, можете да направите почеток + крај / 2 + 1.

356
00:27:23,790 --> 00:27:27,850
[Студент] Вие не треба да се започне + крај [недоловим] >> Да.

357
00:27:27,850 --> 00:27:33,240
Ние веќе ја приметивте овој елемент и знаат дека тоа не е она што го барате.

358
00:27:33,240 --> 00:27:36,800
Значи ние не треба да се ажурира на проектот да бидат на овој елемент.

359
00:27:36,800 --> 00:27:39,560
Ние само може да го прескокнете и надградба на проектот да бидат на овој елемент.

360
00:27:39,560 --> 00:27:46,060
А, постои ли некогаш случај, да речеме, дека ова беше крајот,

361
00:27:46,060 --> 00:27:53,140
па потоа започнете би било ова, почнете + крај / 2 ќе биде тоа,

362
00:27:53,140 --> 00:28:00,580
започне + крајот - Да, мислам дека може да заврши во бесконечна рекурзија.

363
00:28:00,580 --> 00:28:12,690
Да речеме дека тоа е само низа од големината 2 или низа на големина 1. Мислам дека ова ќе функционира.

364
00:28:12,690 --> 00:28:19,490
Па во моментов, проектот е тој елемент и крајот е 1 подалеку од него.

365
00:28:19,490 --> 00:28:24,110
Па елемент кој ние ќе се провери е овој,

366
00:28:24,110 --> 00:28:29,400
и тогаш кога ние ажурирање почеток, ние сме ажурирање на почеток да биде 0 + 1/2,

367
00:28:29,400 --> 00:28:33,160
која ќе ни стави крај назад со почеток биде овој елемент.

368
00:28:33,160 --> 00:28:36,210
>> Па ние сме проверка на истиот елемент одново и одново.

369
00:28:36,210 --> 00:28:43,310
Значи ова е случај каде што секој рекурзивен повик, всушност, мора да се ажурираат нешто.

370
00:28:43,310 --> 00:28:48,370
Значи ние треба да направите почеток + крај / 2 + 1, или на друго место не е случај

371
00:28:48,370 --> 00:28:50,710
каде што ние не сме всушност ажурирање почеток.

372
00:28:50,710 --> 00:28:53,820
Секој види тоа?

373
00:28:53,820 --> 00:28:56,310
Во ред.

374
00:28:56,310 --> 00:29:03,860
Дали некој има прашања за тоа решение или повеќе коментари?

375
00:29:05,220 --> 00:29:10,280
Во ред. Дали некој има итеративен решение кое сите ние може да се погледне?

376
00:29:17,400 --> 00:29:20,940
Дали сите ние го направи тоа рекурзивно?

377
00:29:20,940 --> 00:29:25,950
Или, исто така претпоставувам дека ако нејзините се отвори, тогаш можеби ќе мора прескокнат вашиот претходниот.

378
00:29:25,950 --> 00:29:28,810
Дали тоа автоматски спаси? Јас не сум позитивен.

379
00:29:35,090 --> 00:29:39,130
Дали некој има итеративен?

380
00:29:39,130 --> 00:29:42,430
Можеме да одиме низ него заедно, ако не.

381
00:29:46,080 --> 00:29:48,100
Идејата се случува да бидат исти.

382
00:30:00,260 --> 00:30:02,830
Итеративен решение.

383
00:30:02,830 --> 00:30:07,140
Ние ќе сакате да се основа го стори истото идеја

384
00:30:07,140 --> 00:30:16,530
каде што сакате да ги пратите на нови крајот на низата и нов почеток на низата

385
00:30:16,530 --> 00:30:18,510
и го правам тоа одново и одново.

386
00:30:18,510 --> 00:30:22,430
И ако она што ние следење на како на почетокот и на крајот секогаш се сечат,

387
00:30:22,430 --> 00:30:29,020
тогаш ние не го најдете, а ние може да се врати лажни.

388
00:30:29,020 --> 00:30:37,540
Па, како да го направам тоа? Некој има сугестии или код за мене да се повлече до?

389
00:30:42,190 --> 00:30:47,450
[Студент] Дали време јамка. >> Да.

390
00:30:47,450 --> 00:30:49,450
Ви се случува да сакаат да се направи јамка.

391
00:30:49,450 --> 00:30:51,830
>> Дали имате кодот би можел да се повлече, или она што се ви се случува да навестиле?

392
00:30:51,830 --> 00:30:56,340
[Студент] Јас мислам така. >> Ред. Ова го прави работите полесно. Што е вашето име?

393
00:30:56,340 --> 00:30:57,890
[Студент] Лукас.

394
00:31:00,140 --> 00:31:04,190
Ревизија 1. Во ред.

395
00:31:04,190 --> 00:31:13,200
Ниско е она што се нарекува започне порано.

396
00:31:13,200 --> 00:31:17,080
До не е она што се нарекува крајот порано.

397
00:31:17,080 --> 00:31:22,750
Всушност, на крајот е сега во низа. Тоа е елемент што треба да се разгледа.

398
00:31:22,750 --> 00:31:26,890
Толку ниско е 0, до е големината на низата - 1,

399
00:31:26,890 --> 00:31:34,780
а ние сега се looping, и ние сме проверка -

400
00:31:34,780 --> 00:31:37,340
Претпоставувам дека може да оди преку неа.

401
00:31:37,340 --> 00:31:41,420
Што е вашето размислување преку ова? Прошетка нас преку вашиот код.

402
00:31:41,420 --> 00:31:49,940
[Студент] Секако. Погледни го стогот вредност во средината и го Спореди со игла.

403
00:31:49,940 --> 00:31:58,520
Па ако е поголема од вашата игла, тогаш ќе сакате да - ох, всушност, тоа треба да биде наназад.

404
00:31:58,520 --> 00:32:05,180
Сте ќе сакате да го фрлаат на десната половина, и така да, тоа треба да биде на патот.

405
00:32:05,180 --> 00:32:08,830
[Бауден] Значи ова треба да биде помал? Е дека она што го рече? >> [Студент] Да.

406
00:32:08,830 --> 00:32:10,390
[Бауден] Во ред. Помалку.

407
00:32:10,390 --> 00:32:15,700
Значи, ако она што го барате е помал од она што го сакаме,

408
00:32:15,700 --> 00:32:19,410
тогаш да, ние сакаме да фрлаат левата половина,

409
00:32:19,410 --> 00:32:22,210
што значи ние сме ажурирање сè што си размислува

410
00:32:22,210 --> 00:32:26,610
со поместување ниско на правото на низата.

411
00:32:26,610 --> 00:32:30,130
Ова изгледа добро.

412
00:32:30,130 --> 00:32:34,550
Мислам дека тоа го има истиот проблем што рековме на претходната,

413
00:32:34,550 --> 00:32:49,760
каде што ако ниска е 0 и до е 1, тогаш ниски + Стрелка горе / 2 ќе се постави да биде иста работа повторно.

414
00:32:49,760 --> 00:32:53,860
>> И дури и ако тоа не е случај, тоа е уште поефикасен во најмала рака

415
00:32:53,860 --> 00:32:57,630
само фрлаат на елементот ние само погледна кои знаеме е во ред.

416
00:32:57,630 --> 00:33:03,240
Толку ниско + Стрелка горе / 2 + 1 - >> [студент] Тоа треба да биде на друг начин.

417
00:33:03,240 --> 00:33:05,900
[Бауден] Или ова треба да биде - 1, а другиот треба да биде + 1.

418
00:33:05,900 --> 00:33:09,580
[Студент] и таму треба да биде двојно изнесува знак. >> [Бауден] Да.

419
00:33:09,580 --> 00:33:11,340
[Студент] Да.

420
00:33:14,540 --> 00:33:15,910
Во ред.

421
00:33:15,910 --> 00:33:21,280
И, конечно, дека сега имаме оваа + 1-1 работа,

422
00:33:21,280 --> 00:33:31,520
е тоа - тоа не може да биде - тоа е што е можно за ниско да се заокружи со вредност поголема од се?

423
00:33:35,710 --> 00:33:40,320
Мислам дека единствениот начин на кој може да се случи - Дали е можно? >> [Студент] Не знам.

424
00:33:40,320 --> 00:33:45,220
Но, ако станува скратена, а потоа добива минус дека 1 и потоа - >> Да.

425
00:33:45,220 --> 00:33:47,480
[Студент] Тоа веројатно ќе се збркана.

426
00:33:49,700 --> 00:33:53,940
Мислам дека тоа треба да биде добро само затоа што

427
00:33:53,940 --> 00:33:58,800
за тоа да се заокружи пониски тие ќе треба да бидат еднакви, мислам.

428
00:33:58,800 --> 00:34:03,070
Но, ако тие се еднакви, тогаш ние не би го сторил додека јамка за да започнете со

429
00:34:03,070 --> 00:34:06,670
и ние само ќе се врати на вредност. Па јас мислам дека ние сме добро сега.

430
00:34:06,670 --> 00:34:11,530
Забележете дека иако овој проблем не е рекурзивен,

431
00:34:11,530 --> 00:34:17,400
ист вид на идеи применува кога можеме да видиме како тоа толку лесно помага на самата

432
00:34:17,400 --> 00:34:23,659
на рекурзивен решение од фактот дека ние сме само ажурирање на индекси одново и одново,

433
00:34:23,659 --> 00:34:29,960
правиме проблемот помали и помали, ние се фокусираме на подмножество на низата.

434
00:34:29,960 --> 00:34:40,860
[Студент] Ако ниска е 0 и до е 1, тие ќе бидат 0 + 1/2, кој ќе оди на 0,

435
00:34:40,860 --> 00:34:44,429
а потоа еден ќе биде + 1, еден ќе биде - 1.

436
00:34:47,000 --> 00:34:50,870
[Студент] Каде проверка еднаквост?

437
00:34:50,870 --> 00:34:55,100
Како ако средината е всушност игла?

438
00:34:55,100 --> 00:34:58,590
Ние не сме во моментов прави тоа? Ох!

439
00:35:00,610 --> 00:35:02,460
Ако it's -

440
00:35:05,340 --> 00:35:13,740
Да. Ние не може само да се направи тестот долу тука, бидејќи да речеме првиот средината -

441
00:35:13,740 --> 00:35:16,430
[Студент] Тоа е всушност како да не фрлаат врзани.

442
00:35:16,430 --> 00:35:20,220
Значи, ако фрлаат врзани, мора да го провери прво или whatever.

443
00:35:20,220 --> 00:35:23,350
Ах. Да. >> [Студент] Да.

444
00:35:23,350 --> 00:35:29,650
Така, сега имаме фрлени онаа што во моментов ја погледна,

445
00:35:29,650 --> 00:35:33,260
што значи ние сега треба да имаат

446
00:35:33,260 --> 00:35:44,810
ако (стогот [(низок + до) / 2] == игла), тогаш можеме да се вратат вистина.

447
00:35:44,810 --> 00:35:52,070
И дали го ставам друг или само ако, тоа значи буквално истото

448
00:35:52,070 --> 00:35:57,110
бидејќи тоа би се вратиле точно.

449
00:35:57,110 --> 00:36:01,450
Затоа јас ќе се стави друго, ако, но тоа не е важно.

450
00:36:01,450 --> 00:36:10,440
>> Па друго, ако ова, друг ова, и ова е заеднички нешто што правам

451
00:36:10,440 --> 00:36:14,340
каде што дури и ако тоа е случај каде што сè е добро овде,

452
00:36:14,340 --> 00:36:22,780
како ниски никогаш не може да биде поголема од горе, не вреди размислување околу тоа дали тоа е вистина.

453
00:36:22,780 --> 00:36:28,010
Па може и да се каже додека ниските е помала или еднаква на

454
00:36:28,010 --> 00:36:30,720
или додека ниските е помал од

455
00:36:30,720 --> 00:36:35,300
Значи, ако тие се секогаш еднакви или ниско се случува да помине нагоре,

456
00:36:35,300 --> 00:36:40,130
тогаш можеме да се пробие на овој циклус.

457
00:36:41,410 --> 00:36:44,630
Прашања, грижи коментари?

458
00:36:47,080 --> 00:36:49,270
Во ред. Ова изгледа добро.

459
00:36:49,270 --> 00:36:52,230
Сега сакаме да го стори вид.

460
00:36:52,230 --> 00:37:04,030
Ако одиме во мојата втора ревизија, гледаме истите броеви,

461
00:37:04,030 --> 00:37:07,550
но сега тие веќе не се во подредени цел.

462
00:37:07,550 --> 00:37:12,840
И ние сакаме да се спроведе вид користење на било кој алгоритам во О од n најавите n.

463
00:37:12,840 --> 00:37:17,240
Значи кој алгоритам мислите дека треба да се спроведе тука? >> [Студент] Merge вид.

464
00:37:17,240 --> 00:37:23,810
[Бауден] Да. Се спојат вид е О (n најавите л), па тоа е она што ние ќе треба да се направи.

465
00:37:23,810 --> 00:37:26,680
И проблемот ќе биде прилично слични,

466
00:37:26,680 --> 00:37:31,920
каде што лесно помага на самата да рекурзивен решение.

467
00:37:31,920 --> 00:37:35,580
Ние, исто така може да излезе со итеративен решение ако сакаме,

468
00:37:35,580 --> 00:37:42,540
но рекурзија ќе биде полесно тука и ние треба да направите рекурзија.

469
00:37:45,120 --> 00:37:49,530
Претпоставувам ние ќе одиме преку спојување вид првиот,

470
00:37:49,530 --> 00:37:54,280
иако постои една прекрасна видео на спојување вид веќе. [Смеа]

471
00:37:54,280 --> 00:37:59,780
Значи се логирате вид постојат - Јас сум трошат толку многу на овој труд.

472
00:37:59,780 --> 00:38:02,080
Ох, има само една лево.

473
00:38:02,080 --> 00:38:03,630
Значи се логирате.

474
00:38:08,190 --> 00:38:12,470
О, 1, 3, 5.

475
00:38:26,090 --> 00:38:27,440
Во ред.

476
00:38:29,910 --> 00:38:33,460
Спои се две одделни низи.

477
00:38:33,460 --> 00:38:36,780
Поединечно овие две низи се двете подредени.

478
00:38:36,780 --> 00:38:40,970
Значи оваа низа, 1, 3, 5, подредени. Оваа низа, 0, 2, 4, подредени.

479
00:38:40,970 --> 00:38:46,710
Сега што се спојуваат треба да направите е да ги комбинирате во една низа која и самата е подредени.

480
00:38:46,710 --> 00:38:57,130
Затоа сакаме низа на големина 6 што се случува да имаат овие елементи во него

481
00:38:57,130 --> 00:38:59,390
во подредени цел.

482
00:38:59,390 --> 00:39:03,390
>> И така ние може да ги искористат предностите на фактот дека овие две низи се подредени

483
00:39:03,390 --> 00:39:06,800
да го направите ова во линеарна време,

484
00:39:06,800 --> 00:39:13,510
линеарен пат значење ако оваа низа е големината x и ова е големината y,

485
00:39:13,510 --> 00:39:20,970
тогаш вкупната алгоритам треба да бидат О (x + y). Во ред.

486
00:39:20,970 --> 00:39:23,150
Значи предлози.

487
00:39:23,150 --> 00:39:26,030
[Студент] би можеле да започнеме од лево?

488
00:39:26,030 --> 00:39:30,150
Па ќе стави 0 надолу, а потоа на 1 и потоа тука си во 2.

489
00:39:30,150 --> 00:39:33,320
Значи тоа е вид на како да имаш таб кој се движи на десно. >> [Бауден] Да.

490
00:39:33,320 --> 00:39:41,070
За двете од овие низи ако ние само се фокусираат на најлева елемент.

491
00:39:41,070 --> 00:39:43,530
Бидејќи и двете низи се подредени, ние знаеме дека овие 2 елементи

492
00:39:43,530 --> 00:39:46,920
се најмалите елементи или во низа.

493
00:39:46,920 --> 00:39:53,500
Тоа значи дека 1 од тие 2 елементи мора да бидат најмалиот елемент во нашиот спои низа.

494
00:39:53,500 --> 00:39:58,190
Тоа само така се случува, дека најмалата е на десната страна на овој период.

495
00:39:58,190 --> 00:40:02,580
Па ние се 0, внесете ја на левата бидејќи 0 е помала од 1,

496
00:40:02,580 --> 00:40:08,210
па се 0, внесете ја во нашите првата позиција, а потоа ние ја ажурирате оваа

497
00:40:08,210 --> 00:40:12,070
до сега се фокусира на првиот елемент.

498
00:40:12,070 --> 00:40:14,570
И сега ние се повторува.

499
00:40:14,570 --> 00:40:20,670
Па сега ние споредите 2 и 1. 1 е помала, па ние ќе вметнете 1.

500
00:40:20,670 --> 00:40:25,300
Ние ажурирање на оваа покажувачот да укаже на овој човек.

501
00:40:25,300 --> 00:40:33,160
Сега можеме да го направи тоа повторно, па 2. Ова ќе се ажурира, да ги споредиме овие 2, 3.

502
00:40:33,160 --> 00:40:37,770
Ова надградби, тогаш 4 и 5.

503
00:40:37,770 --> 00:40:42,110
Па тоа е логирате.

504
00:40:42,110 --> 00:40:49,010
>> Тоа треба да биде прилично очигледно дека тоа е линеарна време, бидејќи ние само одиме низ секој елемент еднаш.

505
00:40:49,010 --> 00:40:55,980
И тоа е најголемиот чекор кон спроведување логирате вид е тоа.

506
00:40:55,980 --> 00:40:59,330
И тоа не е толку тешко.

507
00:40:59,330 --> 00:41:15,020
Неколку работи кои треба да се грижите за е Да речеме дека ние се спојуваат 1, 2, 3, 4, 5, 6.

508
00:41:15,020 --> 00:41:30,930
Во овој случај ние ќе завршат во сценарио каде ова се случува да бидат помали,

509
00:41:30,930 --> 00:41:36,160
тогаш ние ја ажурирате оваа покажувач, ова ќе биде помал, ажурирање тоа,

510
00:41:36,160 --> 00:41:41,280
ова ми е помал, а сега ќе мора да се признае

511
00:41:41,280 --> 00:41:44,220
кога сте всушност снема елементи да се споредуваат со.

512
00:41:44,220 --> 00:41:49,400
Бидејќи ние веќе се користи целата оваа низа,

513
00:41:49,400 --> 00:41:55,190
се што е во оваа низа е сега само вметната во тука.

514
00:41:55,190 --> 00:42:02,040
Значи, ако некогаш работат во точката каде што еден од нашите низи е целосно споени веќе,

515
00:42:02,040 --> 00:42:06,510
тогаш ние само ги преземе сите елементи на други низа и вметнете ги во крајот на низата.

516
00:42:06,510 --> 00:42:13,630
Па ние само може да се вметне 4, 5, 6. Во ред.

517
00:42:13,630 --> 00:42:18,070
Тоа е една работа да внимаваш за.

518
00:42:22,080 --> 00:42:26,120
Спроведување кои треба да бидат чекор 1.

519
00:42:26,120 --> 00:42:32,600
Логирате сортирање потоа врз основа на тоа, тоа е 2 чекори, 2 смешни чекори.

520
00:42:38,800 --> 00:42:42,090
Ајде само им даде на оваа низа.

521
00:42:57,920 --> 00:43:05,680
Значи се логирате вид, чекор 1 е за рекурзивно да се скрши низа во половини.

522
00:43:05,680 --> 00:43:09,350
Значи подели оваа низа во половини.

523
00:43:09,350 --> 00:43:22,920
Сега имаме 4, 15, 16, 50 и 8, 23, 42, 108.

524
00:43:22,920 --> 00:43:25,800
И сега ние го направи тоа повторно и ние поделени овие во половини.

525
00:43:25,800 --> 00:43:27,530
Јас само ќе го направи на оваа страна.

526
00:43:27,530 --> 00:43:34,790
Значи 4, 15 и 16, 50.

527
00:43:34,790 --> 00:43:37,440
Ние ќе го стори истото одново тука.

528
00:43:37,440 --> 00:43:40,340
И сега ние го подели на половина повторно.

529
00:43:40,340 --> 00:43:51,080
И ние имаме 4, 15, 16, 50.

530
00:43:51,080 --> 00:43:53,170
Па тоа е нашата база случај.

531
00:43:53,170 --> 00:44:00,540
Откако низи се со големина од 1, тогаш ние престануваме со разделување во половини.

532
00:44:00,540 --> 00:44:03,190
>> Сега што ќе правиме со ова?

533
00:44:03,190 --> 00:44:15,730
На крајот ќе заврши ова исто така ќе се прекине во 8, 23, 42, и 108.

534
00:44:15,730 --> 00:44:24,000
Па сега дека ние сме во овој момент, сега се чекор два на спојување вид е само спојување парови на листи.

535
00:44:24,000 --> 00:44:27,610
Затоа сакаме да се спојат овие. Ние само повик се логирате.

536
00:44:27,610 --> 00:44:31,410
Ние знаеме спојување ќе се вратат овие во подредени цел.

537
00:44:31,410 --> 00:44:33,920
4, 15.

538
00:44:33,920 --> 00:44:41,440
Сега ние сакаме да се спојат овие, и дека ќе се врати листа со оние во подредени цел,

539
00:44:41,440 --> 00:44:44,160
16, 50.

540
00:44:44,160 --> 00:44:57,380
Ние се спојат тие - Не можам да пишувам - 8, 23 и 42, 108.

541
00:44:57,380 --> 00:45:02,890
Значи имаме спои парови еднаш.

542
00:45:02,890 --> 00:45:05,140
Сега ние само се спојат повторно.

543
00:45:05,140 --> 00:45:10,130
Забележете дека секоја од овие листи се подредени во себе,

544
00:45:10,130 --> 00:45:15,220
а потоа ние едноставно може да се спојат овие листи за да добиете листа на големината 4 кој е сортирана

545
00:45:15,220 --> 00:45:19,990
и се спојат овие две листи за да добиете листа на големина од 4 дека е сортирана.

546
00:45:19,990 --> 00:45:25,710
И, конечно, можеме да се спојат овие две листи на големина од 4 да се добие една листа на големина 8, кој е сортирана.

547
00:45:25,710 --> 00:45:34,030
Па да се види дека ова е целокупната n најавите n, ние веќе видовме дека спојувањето е линеарна,

548
00:45:34,030 --> 00:45:40,390
па кога ние сме се занимаваат со спојување на овие, па како вкупната цена на спојување

549
00:45:40,390 --> 00:45:43,410
за овие две листи е само 2 бидејќи -

550
00:45:43,410 --> 00:45:49,610
Или добро, тоа е О од n, но n тука е само овие 2 елементи, така што е 2.

551
00:45:49,610 --> 00:45:52,850
И овие 2 ќе биде 2 и овие 2 ќе биде 2 и овие 2 ќе биде 2,

552
00:45:52,850 --> 00:45:58,820
па низ сите спои дека ние треба да се направи, на крајот ќе заврши прави n.

553
00:45:58,820 --> 00:46:03,210
Како 2 + 2 + 2 + 2 е 8, кој е n,

554
00:46:03,210 --> 00:46:08,060
па цената на спојување во овој сет е n.

555
00:46:08,060 --> 00:46:10,810
А потоа истото тука.

556
00:46:10,810 --> 00:46:16,980
Ние ќе се спојат овие 2, тогаш овие 2, и поединечно ова спојување ќе ги преземе четирите операции,

557
00:46:16,980 --> 00:46:23,610
ова спојување ќе ги преземе четирите операции, но уште еднаш, меѓу сите овие,

558
00:46:23,610 --> 00:46:29,030
на крајот ќе заврши спојување n вкупниот работи, и така овој чекор потребно n.

559
00:46:29,030 --> 00:46:33,670
И така секое ниво потребно n елементи се спои.

560
00:46:33,670 --> 00:46:36,110
>> И колку нивоа постојат?

561
00:46:36,110 --> 00:46:40,160
На секое ниво, нашата низа расте со големина 2.

562
00:46:40,160 --> 00:46:44,590
Тука нашите низи се со големина 1, тука тие се на големината 2, тука тие се на големината 4,

563
00:46:44,590 --> 00:46:46,470
и конечно, тие се со големина од 8.

564
00:46:46,470 --> 00:46:56,450
Значи, бидејќи тоа е удвојување, таму се случува да биде вкупно најавите n на овие нивоа.

565
00:46:56,450 --> 00:47:02,090
Така е и со најавите n нивоа, секое индивидуално ниво преземање n вкупниот промет,

566
00:47:02,090 --> 00:47:05,720
ние се добие најавите N N алгоритам.

567
00:47:05,720 --> 00:47:07,790
Прашања?

568
00:47:08,940 --> 00:47:13,320
Има луѓе веќе постигна напредок за тоа како да се спроведе ова?

569
00:47:13,320 --> 00:47:18,260
Дали некој веќе во една држава каде што само можат да ги повлечат своите код?

570
00:47:20,320 --> 00:47:22,260
Можам да дадам една минута.

571
00:47:24,770 --> 00:47:27,470
Ова е ќе биде подолго.

572
00:47:27,470 --> 00:47:28,730
Силно препорачувам повтори -

573
00:47:28,730 --> 00:47:30,510
Вие не треба да направите рекурзија за спојување

574
00:47:30,510 --> 00:47:33,750
бидејќи со рекурзија за спојување, ви се случува да мора да поминат еден куп на различни големини.

575
00:47:33,750 --> 00:47:37,150
Можете да, но тоа е досадно.

576
00:47:37,150 --> 00:47:43,720
Но рекурзија за вид сам по себе е прилично лесно.

577
00:47:43,720 --> 00:47:49,190
Вие само буквално се јавите вид на левата половина, вид на десната половина. Во ред.

578
00:47:51,770 --> 00:47:54,860
Секој има нешто што можам да се повлече до уште?

579
00:47:54,860 --> 00:47:57,540
Или на друго место ќе ти дадам една минута.

580
00:47:58,210 --> 00:47:59,900
Во ред.

581
00:47:59,900 --> 00:48:02,970
Секој има нешто што може да работи со?

582
00:48:05,450 --> 00:48:09,680
Или друг ние само ќе работат со овој и потоа се прошири од таму.

583
00:48:09,680 --> 00:48:14,050
>> Секој имате повеќе од тоа што ќе можам да се повлече до?

584
00:48:14,050 --> 00:48:17,770
[Студент] Да. Можете да се повлече до рудникот. >> Ред.

585
00:48:17,770 --> 00:48:19,730
Да!

586
00:48:22,170 --> 00:48:25,280
[Студент] Имаше многу услови. >> О, пука. Можете ли -

587
00:48:25,280 --> 00:48:28,110
[Студент] морам да го спаси. >> Да.

588
00:48:32,420 --> 00:48:35,730
Значи ние не го правел обединувањето одделно.

589
00:48:35,730 --> 00:48:38,570
О, но тоа не е толку лошо.

590
00:48:39,790 --> 00:48:41,650
Во ред.

591
00:48:41,650 --> 00:48:47,080
Значи вид е сама по себе само повикување mergeSortHelp.

592
00:48:47,080 --> 00:48:49,530
Објасни ни што mergeSortHelp прави.

593
00:48:49,530 --> 00:48:55,700
[Студент] MergeSortHelp доста прави две главни чекори,

594
00:48:55,700 --> 00:49:01,270
што е за сортирање секоја половина на низата, а потоа да се логирате двата од нив.

595
00:49:04,960 --> 00:49:08,050
[Бауден] Океј, па ми даде една секунда.

596
00:49:10,850 --> 00:49:13,210
Мислам дека ова - >> [студент] Јас треба да -

597
00:49:17,100 --> 00:49:19,400
Да. Јас сум недостасува нешто.

598
00:49:19,400 --> 00:49:23,100
Во логирате, сфаќам дека јас треба да се создаде нова низа

599
00:49:23,100 --> 00:49:26,530
бидејќи не можев да го стори тоа во место. >> Да. Вие не може. Точни.

600
00:49:26,530 --> 00:49:28,170
[Студент] Па јас создаде нова низа.

601
00:49:28,170 --> 00:49:31,510
Го заборавив на крајот на логирате за да повторно се промени.

602
00:49:31,510 --> 00:49:34,490
Во ред. Ни треба нов низа.

603
00:49:34,490 --> 00:49:41,000
Во логирате вид, ова е скоро секогаш вистина.

604
00:49:41,000 --> 00:49:44,340
Дел од трошоците за подобар алгоритам време мудро

605
00:49:44,340 --> 00:49:47,310
е речиси секогаш има потреба да се користи малку повеќе меморија.

606
00:49:47,310 --> 00:49:51,570
Па еве, не е важно како ќе го направите спојат вид,

607
00:49:51,570 --> 00:49:54,780
вие неминовно ќе треба да користите некои дополнителна меморија.

608
00:49:54,780 --> 00:49:58,240
Тој или таа создаде нова низа.

609
00:49:58,240 --> 00:50:03,400
А потоа велиш на крајот ние само треба да го копирате нова низа во оригинална низа.

610
00:50:03,400 --> 00:50:04,830
[Студент] Јас мислам така, да.

611
00:50:04,830 --> 00:50:08,210
Јас не знам дали тоа работи во услови на броење со повикување или што -

612
00:50:08,210 --> 00:50:11,650
Да, тоа ќе работат. >> [Студент] Во ред.

613
00:50:20,620 --> 00:50:24,480
Се обидовте ли работи ова? >> [Студент] Не, сеуште не. >> Океј.

614
00:50:24,480 --> 00:50:28,880
Обиди се со трчање, а потоа ќе зборуваме за тоа за една секунда.

615
00:50:28,880 --> 00:50:35,200
[Студент] Јас треба да имаат сите на функција прототипи и над сè, иако, нели?

616
00:50:37,640 --> 00:50:40,840
Функција прототипи. Ох, мислиш како - Да.

617
00:50:40,840 --> 00:50:43,040
Сортирај повикува mergeSortHelp.

618
00:50:43,040 --> 00:50:47,390
>> Значи, со цел за вид да се јавите mergeSortHelp, mergeSortHelp мора или да се дефинирани

619
00:50:47,390 --> 00:50:56,370
пред вид или ние само треба прототип. Само копирајте го и ставете тоа.

620
00:50:56,370 --> 00:50:59,490
И слично, mergeSortHelp е повикувајќи се спојуваат,

621
00:50:59,490 --> 00:51:03,830
но спојување не е дефинирана, па ние само може да mergeSortHelp знаете

622
00:51:03,830 --> 00:51:08,700
дека тоа е она што се спојуваат се случува да изгледа, и тоа е тоа.

623
00:51:09,950 --> 00:51:15,730
Значи mergeSortHelp.

624
00:51:22,770 --> 00:51:32,660
Имаме проблем тука, каде што ние немаме база случај.

625
00:51:32,660 --> 00:51:38,110
MergeSortHelp е рекурзивен, па секој рекурзивен функција

626
00:51:38,110 --> 00:51:42,610
ќе треба некој вид на база случај да знаете кога да прекинете рекурзивно се повикува.

627
00:51:42,610 --> 00:51:45,590
Која е нашата база случај ќе биде тука? Да.

628
00:51:45,590 --> 00:51:49,110
[Студент] Ако големината е 1? >> [Бауден] Да.

629
00:51:49,110 --> 00:51:56,220
Значи како што видовме во право, таму, па престанавме да разделување низи

630
00:51:56,220 --> 00:52:01,850
Откако ќе влезе во низи од 1 големина, кои неизбежно самите се подредени.

631
00:52:01,850 --> 00:52:09,530
Значи, ако големина е еднаква на 1, знаеме низата е веќе сортирани,

632
00:52:09,530 --> 00:52:12,970
па ние само може да се врати.

633
00:52:12,970 --> 00:52:16,880
>> Забележете дека е празнина, па ние не се враќа ништо особено, ние само се вратат.

634
00:52:16,880 --> 00:52:19,580
Во ред. Значи тоа е нашата база случај.

635
00:52:19,580 --> 00:52:27,440
Претпоставувам нашата база случај, исто така, може да биде ако ние се случи да биде спојување низа на големина 0,

636
00:52:27,440 --> 00:52:30,030
ние најверојатно сакаат да престанат во некоја точка,

637
00:52:30,030 --> 00:52:33,610
па ние само може да се каже големина помала од 2 или помалку од или еднаква на 1

638
00:52:33,610 --> 00:52:37,150
така што ова ќе работат за било која низа сега.

639
00:52:37,150 --> 00:52:38,870
Во ред.

640
00:52:38,870 --> 00:52:42,740
Значи тоа е нашата база случај.

641
00:52:42,740 --> 00:52:45,950
Сега сакаш да одиме преку спојување?

642
00:52:45,950 --> 00:52:49,140
Што прават сите овие случаи значи?

643
00:52:49,140 --> 00:52:54,480
До тука, ние сме само го прават истото идеја, -

644
00:52:56,970 --> 00:53:02,470
[Студент] Јас треба да се поминува големина со сите mergeSortHelp повици.

645
00:53:02,470 --> 00:53:10,080
Јас додадов големина како дополнителен основните и тоа не е таму, како големина / 2.

646
00:53:10,080 --> 00:53:16,210
[Бауден] О, големина / 2, големина / 2. >> [Студент] Да, а исто така во горната функција, како и.

647
00:53:16,210 --> 00:53:21,320
[Бауден] Еве? >> [Студент] Само големина. >> [Бауден] О. Големина, големина? >> [Студент] Да.

648
00:53:21,320 --> 00:53:23,010
[Бауден] Во ред.

649
00:53:23,010 --> 00:53:26,580
Дозволете ми да мислам за една секунда.

650
00:53:26,580 --> 00:53:28,780
Не трчаме во прашање?

651
00:53:28,780 --> 00:53:33,690
Ние сме секогаш лекување на лево како 0. >> [Студент] бр

652
00:53:33,690 --> 00:53:36,340
Тоа е во ред премногу. Жал ми е. Тоа треба да биде почеток. Да.

653
00:53:36,340 --> 00:53:39,230
[Бауден] Во ред. Ми се допаѓа тоа подобро.

654
00:53:39,230 --> 00:53:43,880
И крај. Во ред.

655
00:53:43,880 --> 00:53:47,200
Па сега сакаш да одиме преку спојување? >> [Студент] Во ред.

656
00:53:47,200 --> 00:53:52,150
Јас сум само одење преку оваа нова низа која сум создадена.

657
00:53:52,150 --> 00:53:57,420
Нејзината големина е големината на делот од низа што ние сакаме да се решат

658
00:53:57,420 --> 00:54:03,460
и се обидува да најде елементот што треба да се стави во нова низа чекор.

659
00:54:03,460 --> 00:54:10,140
Па да го направат тоа, прво јас сум проверка, ако на левата половина од низата продолжува да има повеќе елементи,

660
00:54:10,140 --> 00:54:14,260
и ако тоа не се случи, тогаш слезе дека друг услов, кој само вели дека

661
00:54:14,260 --> 00:54:20,180
во ред, тоа мора да биде во вистинската низа, а ние ќе се стави дека во сегашниот индекс на newArray.

662
00:54:20,180 --> 00:54:27,620
>> А потоа инаку, јас сум проверка, ако на десната страна на низата е завршена,

663
00:54:27,620 --> 00:54:30,630
во кој случај јас само се стави во лево.

664
00:54:30,630 --> 00:54:34,180
Тоа, всушност, не може да биде потребно. Јас не сум сигурен.

665
00:54:34,180 --> 00:54:40,970
Но сепак, другите две проверка која од двете се помали во лево или десно.

666
00:54:40,970 --> 00:54:49,770
И во секој случај, јас сум зголемување, кое случаеви јас прираст.

667
00:54:49,770 --> 00:54:52,040
[Бауден] Во ред.

668
00:54:52,040 --> 00:54:53,840
Што изгледа добро.

669
00:54:53,840 --> 00:54:58,800
Дали некој има коментари или проблеми или прашања?

670
00:55:00,660 --> 00:55:07,720
Значи четирите случаи кои треба да се донесе работите во само да биде - или тоа изгледа како пет -

671
00:55:07,720 --> 00:55:13,100
но ние треба да се разгледа дали левата низа има снема на работите што треба да се логирате,

672
00:55:13,100 --> 00:55:16,390
дали правото низа има снема на работите што треба да се спојат -

673
00:55:16,390 --> 00:55:18,400
Јас сум укажува на ништо.

674
00:55:18,400 --> 00:55:21,730
Па дали левата низа има снема на нештата или право низа има снема на нештата.

675
00:55:21,730 --> 00:55:24,320
Тоа се два случаи.

676
00:55:24,320 --> 00:55:30,920
Ние исто така ќе треба тривијални случај на тоа дали левицата работа е помалку од вистинската работа.

677
00:55:30,920 --> 00:55:33,910
Тогаш ние сакаме да изберете од левата работа.

678
00:55:33,910 --> 00:55:37,630
Тоа се случаи.

679
00:55:37,630 --> 00:55:40,990
Значи ова беше во право, па тоа е тоа.

680
00:55:40,990 --> 00:55:46,760
Низа лево. Тоа е 1, 2, 3. Во ред. Така да, тоа се четири работи што можеби ќе сакате да се направи.

681
00:55:50,350 --> 00:55:54,510
И ние не ќе оди преку итеративен решение.

682
00:55:54,510 --> 00:55:55,980
Јас не би препорачуваме -

683
00:55:55,980 --> 00:56:03,070
Се спојат вид е пример на функција како што е не опашка рекурзивен,

684
00:56:03,070 --> 00:56:07,040
тоа не е лесно да се направи тоа опашка рекурзивен,

685
00:56:07,040 --> 00:56:13,450
но, исто така, дека не е многу лесно да се направи тоа итеративен.

686
00:56:13,450 --> 00:56:16,910
Ова е многу лесно.

687
00:56:16,910 --> 00:56:19,170
Оваа имплементација на спојување вид,

688
00:56:19,170 --> 00:56:22,140
се спојат, без разлика што правиш, си оди за да се изгради логирате.

689
00:56:22,140 --> 00:56:29,170
>> Значи се логирате вид изграден на врвот на спојување рекурзивно е само овие три линии.

690
00:56:29,170 --> 00:56:34,700
Iteratively, тоа е повеќе досадни и потешко да се размислува за.

691
00:56:34,700 --> 00:56:41,860
Но, забележуваат дека тоа не е опашка рекурзивен од mergeSortHelp - кога тоа се нарекува -

692
00:56:41,860 --> 00:56:46,590
сеуште е потребно да се прават работите по овој рекурзивен повик се враќа.

693
00:56:46,590 --> 00:56:50,830
Значи ова магацинот рамка мора да продолжи да постои дури и по повикување ова.

694
00:56:50,830 --> 00:56:54,170
И тогаш кога ќе се јавите ова, магацинот рамка мора да продолжи да постои

695
00:56:54,170 --> 00:56:57,780
бидејќи дури и откако тој повик, ние сеуште треба да се логирате.

696
00:56:57,780 --> 00:57:01,920
И тоа е nontrivial да се направи овој опашка рекурзивен.

697
00:57:04,070 --> 00:57:06,270
Прашања?

698
00:57:08,300 --> 00:57:09,860
Во ред.

699
00:57:09,860 --> 00:57:13,400
Па кога ќе се вратам да го решите - О, има две работи сакам да се покажуваат. Во ред.

700
00:57:13,400 --> 00:57:17,840
Да се ​​вратам на вид, ние ќе го направите ова брзо.

701
00:57:17,840 --> 00:57:21,030
Или пребарување. Вид? Вид. Да.

702
00:57:21,030 --> 00:57:22,730
Да се ​​вратам на почетокот на вид.

703
00:57:22,730 --> 00:57:29,870
Ние сакаме да се создаде алгоритам кој ги сортира низа користење на било кој алгоритам

704
00:57:29,870 --> 00:57:33,660
во О од n.

705
00:57:33,660 --> 00:57:40,860
Па, како е ова можно? Дали некој има било кој вид на -

706
00:57:40,860 --> 00:57:44,300
Јас навести пред во -

707
00:57:44,300 --> 00:57:48,300
Ако ние сме за да се подобри од N најавите n да О од n,

708
00:57:48,300 --> 00:57:51,450
ние сме подобри нашите алгоритам време-мудар,

709
00:57:51,450 --> 00:57:55,250
што значи она што сме ние ќе треба да направите за да се направи се за тоа?

710
00:57:55,250 --> 00:57:59,520
[Студент] простор. >> Да. Ние ќе биде со користење на повеќе простор.

711
00:57:59,520 --> 00:58:04,490
И дури и не само повеќе простор, тоа е експоненцијално повеќе простор.

712
00:58:04,490 --> 00:58:14,320
Па мислам дека овој вид на алгоритам е псевдо нешто, псевдо polynom -

713
00:58:14,320 --> 00:58:18,980
псевдо - Не можам да се сетам. Псевдо нешто.

714
00:58:18,980 --> 00:58:22,210
Но, тоа е затоа што ние треба да ги користите толку многу простор

715
00:58:22,210 --> 00:58:28,610
дека тоа е остварливо, но не е реална.

716
00:58:28,610 --> 00:58:31,220
>> И како да се постигне тоа?

717
00:58:31,220 --> 00:58:36,810
Ние може да се постигне ова, ако ние гаранција дека некој посебен елемент во низа

718
00:58:36,810 --> 00:58:39,600
е под одредена големина.

719
00:58:42,070 --> 00:58:44,500
Па да речеме дека големината е 200,

720
00:58:44,500 --> 00:58:48,130
секој елемент во низата е под големина 200.

721
00:58:48,130 --> 00:58:51,080
И ова е всушност многу реална.

722
00:58:51,080 --> 00:58:58,660
Вие многу лесно може да имаат низа дека знаете се што е во него

723
00:58:58,660 --> 00:59:00,570
ќе биде помалку од одреден број.

724
00:59:00,570 --> 00:59:07,400
Како ако имате некои апсолутно масивни вектор или нешто

725
00:59:07,400 --> 00:59:11,810
но знаете што се случува да биде помеѓу 0 и 5,

726
00:59:11,810 --> 00:59:14,790
тогаш тоа ќе биде значително побрзо го направите тоа.

727
00:59:14,790 --> 00:59:17,930
И врзани на било кој од елементите е 5,

728
00:59:17,930 --> 00:59:21,980
па ова врзани, тоа е колку меморија ви се случува да биде во употреба.

729
00:59:21,980 --> 00:59:26,300
Така врзани е 200.

730
00:59:26,300 --> 00:59:32,960
Во теорија, секогаш постои врзана од цел број може да биде само до 4 милијарди долари,

731
00:59:32,960 --> 00:59:40,600
но тоа е нереално, бидејќи тогаш ќе ни биде користење на просторот

732
00:59:40,600 --> 00:59:44,400
од редот на 4 милијарди. Значи тоа е нереално.

733
00:59:44,400 --> 00:59:47,060
Но тука ние ќе каже нашиот врзани е 200.

734
00:59:47,060 --> 00:59:59,570
Трикот да го прави тоа во О на n е што направи уште низа наречен точки од обвинението за големината врзани.

735
00:59:59,570 --> 01:00:10,470
Така, всушност, ова е кратенка за - Јас всушност не знам дали ѕвекот го прави ова.

736
01:00:11,150 --> 01:00:15,330
Но во GCC во најмала рака - I'm претпоставувајќи ѕвекот го прави тоа премногу -

737
01:00:15,330 --> 01:00:18,180
ова само ќе се иницијализира на целата низа да биде 0-ти.

738
01:00:18,180 --> 01:00:25,320
Значи, ако јас не сакате да го направите тоа, тогаш јас поединечно не можеше да стори за (int i = 0;

739
01:00:25,320 --> 01:00:31,500
з <врзани; i + +) и точки [i] = 0;

740
01:00:31,500 --> 01:00:35,260
Па сега што е иницијализиран на 0.

741
01:00:35,260 --> 01:00:39,570
Јас iterate над мојата низа,

742
01:00:39,570 --> 01:00:51,920
и она што го правам е јас сум броење на бројот на секој - Ајде да одиме доле.

743
01:00:51,920 --> 01:00:55,480
Имаме 4, 15, 16, 50, 8, 23, 42, 108.

744
01:00:55,480 --> 01:01:00,010
Она што јас сум броење е бројот на појавувања на секоја од овие елементи.

745
01:01:00,010 --> 01:01:03,470
Да, всушност, додадете неколку повеќе тука со некои повторува.

746
01:01:03,470 --> 01:01:11,070
Значи вредноста имаме тука, вредноста на која ќе бидат низа [i].

747
01:01:11,070 --> 01:01:14,850
Значи вредност може да биде 4 или 8 или whatever.

748
01:01:14,850 --> 01:01:18,870
А сега сум броење колку од таа вредност сум видел,

749
01:01:18,870 --> 01:01:21,230
па точки [вредност] + +;

750
01:01:21,230 --> 01:01:29,430
По ова е направено, точки ќе изгледа нешто како 0001.

751
01:01:29,430 --> 01:01:42,190
Да направиме точки [вредност] - ОБВРЗАНИ + 1.

752
01:01:42,190 --> 01:01:48,230
>> Сега тоа е само за да сметка за фактот дека ние сме почнувајќи од 0.

753
01:01:48,230 --> 01:01:50,850
Значи, ако 200 ќе биде нашиот најголем број,

754
01:01:50,850 --> 01:01:54,720
тогаш 0-200 е 201 работи.

755
01:01:54,720 --> 01:02:01,540
Значи точки, тоа ќе изгледа 00001 бидејќи имаме една 4.

756
01:02:01,540 --> 01:02:10,210
Тогаш ќе имаме 0001, каде што ќе имаме 1 во 8 индекс на пребројувањето.

757
01:02:10,210 --> 01:02:14,560
Ќе имаме 2 во 23 индексот брои.

758
01:02:14,560 --> 01:02:17,630
Ќе имаме 2 во индекс 42 на број.

759
01:02:17,630 --> 01:02:21,670
Значи можеме да го користиме брои.

760
01:02:34,270 --> 01:02:44,920
Значи num_of_item = точки [i].

761
01:02:44,920 --> 01:02:52,540
И така, ако num_of_item е 2, што значи ние сакаме да вметнете 2 на бројот i

762
01:02:52,540 --> 01:02:55,290
во нашата подредени низа.

763
01:02:55,290 --> 01:03:02,000
Значи ние треба да ги пратите на тоа колку ние сме во низа.

764
01:03:02,000 --> 01:03:05,470
Значи индекс = 0.

765
01:03:05,470 --> 01:03:09,910
Низа - јас само ќе го пишувам.

766
01:03:16,660 --> 01:03:18,020
Точки -

767
01:03:19,990 --> 01:03:28,580
низа [индекс + +] = i;

768
01:03:28,580 --> 01:03:32,490
Е она што го сакам? Мислам дека тоа е она што сакам.

769
01:03:35,100 --> 01:03:38,290
Да, ова изгледа добро. Во ред.

770
01:03:38,290 --> 01:03:43,050
Значи не сите се разбере она што целта на мојот точки низа е?

771
01:03:43,050 --> 01:03:48,140
Тоа е пребројување на бројот на појавувања на секоја од овие броеви.

772
01:03:48,140 --> 01:03:51,780
Тогаш јас сум процесирањето над кој е важен низа,

773
01:03:51,780 --> 01:03:57,190
и о позиција во точки низа

774
01:03:57,190 --> 01:04:01,930
е бројот на i е дека треба да се појави во мојот подредени низа.

775
01:04:01,930 --> 01:04:06,840
Тоа е зошто точки од обвинението за 4 ќе биде 1

776
01:04:06,840 --> 01:04:11,840
и точки од 8 ќе биде 1, точки од обвинението за 23 ќе биде 2.

777
01:04:11,840 --> 01:04:16,900
Значи тоа е колку од нив сакам да вметнете во мојот подредени низа.

778
01:04:16,900 --> 01:04:19,200
Тогаш јас само го прават тоа.

779
01:04:19,200 --> 01:04:28,960
Јас сум вметнување num_of_item јас е во моите подредени низа.

780
01:04:28,960 --> 01:04:31,670
>> Прашања?

781
01:04:32,460 --> 01:04:43,100
И така, повторно, ова е линеарна време, бидејќи ние сме само процесирањето над ова уште еднаш,

782
01:04:43,100 --> 01:04:47,470
но тоа е, исто така, линеарна во она што овој број се случува да биде,

783
01:04:47,470 --> 01:04:50,730
и така тоа во голема мера зависи од тоа што вашиот врзани е.

784
01:04:50,730 --> 01:04:53,290
Со врзани на 200, тоа не е толку лош.

785
01:04:53,290 --> 01:04:58,330
Ако вашиот врзани ќе биде 10.000, тогаш тоа е малку полошо,

786
01:04:58,330 --> 01:05:01,360
но ако вашиот врзани ќе биде 4 милијарди долари, што е сосема нереално

787
01:05:01,360 --> 01:05:07,720
и оваа низа се случува да мора да биде со големина од 4 милијарди долари, што е нереално.

788
01:05:07,720 --> 01:05:10,860
Значи тоа е тоа. Прашања?

789
01:05:10,860 --> 01:05:13,270
[Нечујни студент одговор] >> Океј.

790
01:05:13,270 --> 01:05:15,710
Сфатив една работа кога се случува преку.

791
01:05:17,980 --> 01:05:23,720
Мислам дека проблемот беше во Лукас и веројатно секој еден што сум го видел.

792
01:05:23,720 --> 01:05:26,330
Јас сосема заборавивме.

793
01:05:26,330 --> 01:05:31,040
Единственото нешто што сакав да коментира за е дека кога си имаш работа со нешта како индекси,

794
01:05:31,040 --> 01:05:38,320
никогаш не навистина да се види ова кога сте пишување за телефонска линија,

795
01:05:38,320 --> 01:05:41,120
но технички, секогаш кога си имаш работа со овие индекси,

796
01:05:41,120 --> 01:05:45,950
сте доста секогаш треба да се справи со непотпишана цели броеви.

797
01:05:45,950 --> 01:05:53,850
Причината за ова е кога си имаш работа со потпишан цели броеви,

798
01:05:53,850 --> 01:05:56,090
па ако имаш 2 потпишан цели броеви и ќе им додадете заедно

799
01:05:56,090 --> 01:06:00,640
и тие завршуваат премногу голем, тогаш ќе заврши со негативен број.

800
01:06:00,640 --> 01:06:03,410
Значи тоа е она број overflow е.

801
01:06:03,410 --> 01:06:10,500
>> Ако додадам 2 милијарди и 1 милијарда, јас се заокружи со негативни 1 милијарда долари.

802
01:06:10,500 --> 01:06:15,480
Тоа е како цели броеви работат на компјутери.

803
01:06:15,480 --> 01:06:17,510
Значи проблемот со користење на -

804
01:06:17,510 --> 01:06:23,500
Тоа е во ред, освен ако е ниска се случува да биде 2 милијарди и до случува да биде 1 милијарда евра,

805
01:06:23,500 --> 01:06:27,120
тогаш ова ќе биде негативен 1 милијарда, а потоа ние ќе делиме дека од 2

806
01:06:27,120 --> 01:06:29,730
и завршуваат со негативни 500 милиони.

807
01:06:29,730 --> 01:06:33,760
Значи ова е само прашање ако се случи да биде во потрага преку низа

808
01:06:33,760 --> 01:06:38,070
милијарди нешта.

809
01:06:38,070 --> 01:06:44,050
Но ако ниска + нагоре случува да преливник, тогаш тоа е проблем.

810
01:06:44,050 --> 01:06:47,750
Веднаш штом ќе ги направи непотпишана, а потоа 2 милијарди плус 1 милијарда е 3 милијарди долари.

811
01:06:47,750 --> 01:06:51,960
3 милијарди поделено со 2 е 1,5 милијарди евра.

812
01:06:51,960 --> 01:06:55,670
Па штом тие се непотпишана, сè е совршено.

813
01:06:55,670 --> 01:06:59,900
И така тоа е исто така прашање кога сте пишување вашиот за петелки,

814
01:06:59,900 --> 01:07:03,940
а всушност, тоа веројатно го прави тоа автоматски.

815
01:07:09,130 --> 01:07:12,330
Тоа ќе всушност само се развикам.

816
01:07:12,330 --> 01:07:21,610
Значи, ако овој број е премногу голема за да биде во само еден број, но тоа ќе се вклопуваат во една непотпишана цел број,

817
01:07:21,610 --> 01:07:24,970
тоа ќе се развикам, па затоа никогаш навистина работи во прашање.

818
01:07:29,150 --> 01:07:34,820
Можете да видите дека индексот никогаш нема да биде негативен,

819
01:07:34,820 --> 01:07:39,220
и така кога сте процесирањето преку низа,

820
01:07:39,220 --> 01:07:43,970
скоро секогаш може да се каже непотпишана int i, но навистина не треба.

821
01:07:43,970 --> 01:07:47,110
Се одвиваат работите да работат доста само како добро.

822
01:07:48,740 --> 01:07:50,090
Во ред. [Шепоти] Колку е часот?

823
01:07:50,090 --> 01:07:54,020
На последната работа што сакав да покаже - и јас само ќе го направи тоа навистина брзо.

824
01:07:54,020 --> 01:08:03,190
Знаеш како сме # define па ние # можат да се дефинираат MAX како 5 или нешто?

825
01:08:03,190 --> 01:08:05,940
Да не MAX. # Define ОБВРЗАНИ како 200. Тоа е она што беше порано.

826
01:08:05,940 --> 01:08:10,380
Што ги дефинира константа, која е само ќе бидат копирани и атипичен

827
01:08:10,380 --> 01:08:13,010
каде и да се случи да се напише врзани.

828
01:08:13,010 --> 01:08:18,189
>> Значи ние всушност може да направи повеќе со # дефинира.

829
01:08:18,189 --> 01:08:21,170
Ние # можат да се дефинираат функции.

830
01:08:21,170 --> 01:08:23,410
Тие не се навистина функции, но ние ќе ги наречеме функции.

831
01:08:23,410 --> 01:08:36,000
Еден пример би бил нешто како MAX (x, y) е дефиниран како (x <y y: x). Во ред.

832
01:08:36,000 --> 01:08:40,660
Значи треба да се навикнеш на тројната оператор синтакса,

833
01:08:40,660 --> 01:08:49,029
но е x помалку од y? Врати y, друго се вратат х.

834
01:08:49,029 --> 01:08:54,390
Така можете да видите што може да направи овој посебна функција,

835
01:08:54,390 --> 01:09:01,399
и функцијата може да биде како bool MAX зема 2 аргументи, да се вратите ова.

836
01:09:01,399 --> 01:09:08,340
Ова е еден од оние кои најчесто гледам направи вака. Ги нарекуваме макроа.

837
01:09:08,340 --> 01:09:11,790
Ова е макро.

838
01:09:11,790 --> 01:09:15,859
Ова е само синтакса за тоа.

839
01:09:15,859 --> 01:09:18,740
Можете да напишете макро да правите што сакате.

840
01:09:18,740 --> 01:09:22,649
Вие често видите макроа за дебагирање printfs и работи.

841
01:09:22,649 --> 01:09:29,410
Така еден вид на printf, постојат специјални константи во C како црта линија црта,

842
01:09:29,410 --> 01:09:31,710
2 подвлекува линија црта,

843
01:09:31,710 --> 01:09:37,550
и таму е исто така мислам 2 подвлекува функции. Тоа може да биде тоа. Нешто слично.

844
01:09:37,550 --> 01:09:40,880
Тие работи ќе биде заменет со името на функцијата

845
01:09:40,880 --> 01:09:42,930
или бројот на линијата која сте.

846
01:09:42,930 --> 01:09:48,630
Најчесто, ти пишувам дебагирање printfs дека овде би можел потоа само напиши

847
01:09:48,630 --> 01:09:54,260
Debug и тоа ќе печати бројот на линијата и функција што се случи да биде во

848
01:09:54,260 --> 01:09:57,020
дека се сретнал дека DEBUG изјава.

849
01:09:57,020 --> 01:09:59,550
И ти исто така може да печати други работи.

850
01:09:59,550 --> 01:10:05,990
Значи едно нешто што треба да внимаваш за е ако се случи да # define DOUBLE_MAX

851
01:10:05,990 --> 01:10:11,380
како нешто како 2 * y и 2 * x.

852
01:10:11,380 --> 01:10:14,310
Така и за која било причина, ви се случи да се направи тоа многу.

853
01:10:14,310 --> 01:10:16,650
Така го прават тоа макро.

854
01:10:16,650 --> 01:10:18,680
Ова е всушност скршена.

855
01:10:18,680 --> 01:10:23,050
Јас би го нарекол тоа со нешто како DOUBLE_MAX (3, 6).

856
01:10:23,050 --> 01:10:27,530
Значи она што треба да се вратат?

857
01:10:28,840 --> 01:10:30,580
[Студент] 12.

858
01:10:30,580 --> 01:10:34,800
Да, 12 треба да се вратат, а 12 се враќа.

859
01:10:34,800 --> 01:10:43,350
3 добива заменува за x, 6 добива заменува за y и се враќаме 2 * 6, кој е 12.

860
01:10:43,350 --> 01:10:47,710
Сега, она што за ова? Што треба да се вратат?

861
01:10:47,710 --> 01:10:50,330
[Студент] 14. >> Идеално, 14.

862
01:10:50,330 --> 01:10:55,290
Прашањето е во тоа како хаш дефинира работата, се сеќавам тоа е буквално Copy и Paste

863
01:10:55,290 --> 01:11:00,160
на доста сè, така што тоа се случува да се толкува како

864
01:11:00,160 --> 01:11:11,270
е 3 помалку од 1 плус 6, 2 плус пати 1 6, 2 пати 3.

865
01:11:11,270 --> 01:11:19,780
>> Значи за оваа причина што речиси секогаш заврши што е во загради.

866
01:11:22,180 --> 01:11:25,050
Секоја променлива скоро секогаш заврши во загради.

867
01:11:25,050 --> 01:11:29,570
Има случаи каде што не треба, како знам дека не треба да го направите тоа тука

868
01:11:29,570 --> 01:11:32,110
бидејќи помалку отколку што е доста секогаш само оди на работа,

869
01:11:32,110 --> 01:11:34,330
иако тоа дури и не може да биде вистина.

870
01:11:34,330 --> 01:11:41,870
Ако има нешто смешно како DOUBLE_MAX (1 == 2),

871
01:11:41,870 --> 01:11:49,760
тогаш тоа се случува да се заменува со 3 помалку од 1 еднаква изнесува 2,

872
01:11:49,760 --> 01:11:53,460
и така, тогаш тоа ќе направи 3 помалку од 1, не дека еднаквото 2,

873
01:11:53,460 --> 01:11:55,620
која не е она што го сакаме.

874
01:11:55,620 --> 01:12:00,730
Значи, со цел да се спречи било кој оператор предност проблеми,

875
01:12:00,730 --> 01:12:02,870
секогаш заврши во загради.

876
01:12:03,290 --> 01:12:07,700
Во ред. И тоа е тоа, 5:30.

877
01:12:08,140 --> 01:12:12,470
Ако имате било какви прашања во врска со pset, ги споделите со нас.

878
01:12:12,470 --> 01:12:18,010
Тоа треба да биде забавно, како и хакер издание исто така е многу пореалистичен

879
01:12:18,010 --> 01:12:22,980
од хакер издание на минатата година, па се надеваме дека многу од вас го испробаш.

880
01:12:22,980 --> 01:12:26,460
Минатата година беше многу големо.

881
01:12:28,370 --> 01:12:30,000
>> [CS50.TV]