1
00:00:00,000 --> 00:00:05,204

2
00:00:05,204 --> 00:00:07,370
Даг LLOYD: Значи, ако сте
гледав видеото на магацинот,

3
00:00:07,370 --> 00:00:09,870
Ова е веројатно нема да се чувствуваат
како малку на дежа ву.

4
00:00:09,870 --> 00:00:13,850
Тоа се случува да биде многу сличен концепт,
само со мала пресврт на неа.

5
00:00:13,850 --> 00:00:15,530
Ние се случува да се зборува сега за редици.

6
00:00:15,530 --> 00:00:19,350
Па редица, сличен на магацинот,
е друг вид на податоци структура

7
00:00:19,350 --> 00:00:22,412
кои може да се користат да се одржи
податоци на организиран начин.

8
00:00:22,412 --> 00:00:24,120
Сличен на магацинот,
тоа може да се спроведе

9
00:00:24,120 --> 00:00:27,000
како низа или поврзано листа.

10
00:00:27,000 --> 00:00:30,320
За разлика од магацинот, правилата
дека ние ги користиме за да се утврди

11
00:00:30,320 --> 00:00:34,210
кога работите ќе се додаде и отстранети од
редица се малку различни.

12
00:00:34,210 --> 00:00:36,590
>> За разлика од магацинот, кој
е структура LIFO,

13
00:00:36,590 --> 00:00:45,610
трае, а прв, редот е правилото FIFO
структура, FIFO, прво, а прв.

14
00:00:45,610 --> 00:00:49,320
Сега редици, најверојатно
имаат аналогија редици.

15
00:00:49,320 --> 00:00:52,820
Ако некогаш сте биле во ред на
забавен парк или во банка,

16
00:00:52,820 --> 00:00:56,430
таму е вид на правичност
спроведување структура.

17
00:00:56,430 --> 00:00:59,160
Првиот човек во ред на
банката е првата личност

18
00:00:59,160 --> 00:01:00,760
кој добива да разговарам со судбината.

19
00:01:00,760 --> 00:01:03,522
>> Тоа ќе биде еден вид на трка
до дното, ако единствениот начин

20
00:01:03,522 --> 00:01:06,730
ќе морате да разговарам со судбината на
банката треба да биде последниот човек во линија.

21
00:01:06,730 --> 00:01:09,146
Сите секогаш би сакал
да биде последниот човек во линија,

22
00:01:09,146 --> 00:01:12,580
и лицето кое го имаше првиот
кој е на чекање за некое време,

23
00:01:12,580 --> 00:01:14,715
може да има со часови,
и часови и часови

24
00:01:14,715 --> 00:01:17,590
пред тие да имаат шанса да се, всушност,
повлече пари во банка.

25
00:01:17,590 --> 00:01:22,510
И така редици се вид на
правичност спроведување структура.

26
00:01:22,510 --> 00:01:25,780
Но, тоа не мора да значи
дека Купишта се лоша работа, само

27
00:01:25,780 --> 00:01:28,160
дека редици се уште еден начин да го направи тоа.

28
00:01:28,160 --> 00:01:32,420
Па повторно на ред е прв дојден, прв
надвор, наспроти магацинот кој трае во,

29
00:01:32,420 --> 00:01:34,440
Првиот надвор.

30
00:01:34,440 --> 00:01:36,190
Сличен на магацинот,
имаме две операции

31
00:01:36,190 --> 00:01:38,470
дека ние може да се изврши на редици.

32
00:01:38,470 --> 00:01:43,910
Имињата се Стави во ред, што е за да додадете
нов елемент до крајот на дното,

33
00:01:43,910 --> 00:01:47,330
и dequeue, што е
да се отстрани од најстарите

34
00:01:47,330 --> 00:01:49,670
елемент од предниот дел на дното.

35
00:01:49,670 --> 00:01:53,600
Значи ние се случува да додадете елементи
кон крајот на дното,

36
00:01:53,600 --> 00:01:57,220
и ние ќе треба да се отстранат елементите
од предниот дел на дното.

37
00:01:57,220 --> 00:02:00,790
Повторно, со стек, бевме додавање
елементи на врвот на магацинот

38
00:02:00,790 --> 00:02:03,380
и отстранување на елементи
од врвот на магацинот.

39
00:02:03,380 --> 00:02:07,570
Така е и со Стави во ред, тоа е додавање на
На крајот, отстранување од напред.

40
00:02:07,570 --> 00:02:10,639
Па најстара работа таму
секогаш е следното нешто

41
00:02:10,639 --> 00:02:13,620
да излезе ако се обидеме
и dequeue нешто.

42
00:02:13,620 --> 00:02:18,330
>> Значи, повторно, со редици, можеме да
низа базирани имплементации

43
00:02:18,330 --> 00:02:20,110
и врзан-листа врз имплементации.

44
00:02:20,110 --> 00:02:24,620
Ние ќе започнеме повторно со
низа базирани имплементации.

45
00:02:24,620 --> 00:02:27,070
Дефинирање на структурата
изгледа прилично слични.

46
00:02:27,070 --> 00:02:30,720
Имаме уште една низа
има вредност од типот податоци,

47
00:02:30,720 --> 00:02:32,690
па тоа може да се одржи произволни типови на податоци.

48
00:02:32,690 --> 00:02:35,570
Ние сме повторно ќе се користи
цели броеви во овој пример.

49
00:02:35,570 --> 00:02:39,830
>> И исто како и со нашите
низа-базирана имплементација магацинот,

50
00:02:39,830 --> 00:02:42,340
затоа што ние сме со користење на
низа, ние мора да се

51
00:02:42,340 --> 00:02:46,850
имаат тоа ограничување дека С вид
на наметнува врз нас, што ние

52
00:02:46,850 --> 00:02:51,670
немаат никаква динамика во нашата
способност да расте и да се намали на низата.

53
00:02:51,670 --> 00:02:55,710
Ние треба да одлучат на почетокот
она што е максималниот број на работите

54
00:02:55,710 --> 00:02:59,300
дека ние може да се стави во овој
редот, а во овој случај,

55
00:02:59,300 --> 00:03:02,070
капацитет ќе биде некои фунти
дефинирана константа во нашиот код.

56
00:03:02,070 --> 00:03:05,430
И за целите на оваа
видео, капацитетот ќе биде 10.

57
00:03:05,430 --> 00:03:07,690
>> Ние треба да ги пратите на
на предниот дел на дното

58
00:03:07,690 --> 00:03:11,160
па знаеме кој елемент
сакаме да dequeue,

59
00:03:11,160 --> 00:03:15,070
и ние исто така треба да ги пратите на
нешто else-- бројот на елементи

60
00:03:15,070 --> 00:03:16,690
кои ги имаме во нашата задача.

61
00:03:16,690 --> 00:03:19,360
Известување ние не сме следење
на крајот од редот, само

62
00:03:19,360 --> 00:03:21,150
големината на задачата.

63
00:03:21,150 --> 00:03:24,310
А причината за тоа се надевам дека ќе
стане малку појасно, во еден миг.

64
00:03:24,310 --> 00:03:26,143
Откако ќе се заврши
оваа дефиниција за тип,

65
00:03:26,143 --> 00:03:29,080
имаме нов тип на податок
повика на дното, што можеме сега

66
00:03:29,080 --> 00:03:30,630
декларираат променливи од тој тип на податок.

67
00:03:30,630 --> 00:03:35,350
И малку збунувачки, решив
да се јавите на оваа задача q, буквата

68
00:03:35,350 --> 00:03:38,090
q, наместо на податочен тип q.

69
00:03:38,090 --> 00:03:39,600
>> Значи тука е нашата задача.

70
00:03:39,600 --> 00:03:40,700
Тоа е структура.

71
00:03:40,700 --> 00:03:45,730
Таа содржи три члена или три
полиња, низа на капацитет големина.

72
00:03:45,730 --> 00:03:47,340
Во овој случај, капацитет е 10.

73
00:03:47,340 --> 00:03:49,580
И оваа низа е
ќе се одржи цели броеви.

74
00:03:49,580 --> 00:03:55,240
Во зелени е пред нашите дното,
Следниот елемент што треба да се отстранат, а со црвена боја

75
00:03:55,240 --> 00:03:58,610
ќе биде со големина на задачата,
колку елементи се во моментов

76
00:03:58,610 --> 00:04:01,190
постоечките во редот.

77
00:04:01,190 --> 00:04:05,300
Па ако се каже q.front еднаквите
0, а големината q.size еднаква 0--

78
00:04:05,300 --> 00:04:07,120
ние сме поставување на 0-ти во тие области.

79
00:04:07,120 --> 00:04:11,070
И во овој момент, ние сме доста
подготвени да почнат да работат со нашите редот.

80
00:04:11,070 --> 00:04:14,140
>> Па првата работа што можеме
Стави во ред е да се изврши нешто,

81
00:04:14,140 --> 00:04:16,860
за да додадете нов елемент
на крајот од редот.

82
00:04:16,860 --> 00:04:19,089
Па, она што ние треба да се
направи во општиот случај?

83
00:04:19,089 --> 00:04:23,690
И оваа функција Стави во ред потреби
да го прифати покажувач на нашата листа на чекање.

84
00:04:23,690 --> 00:04:26,370
Повторно, ако се декларирале
нашите дното на глобално ниво,

85
00:04:26,370 --> 00:04:29,490
ние не би требало да се направи ова
задолжително, но во принцип, ние

86
00:04:29,490 --> 00:04:32,330
Треба да го прифатите покажувачи
да структури на податоци

87
00:04:32,330 --> 00:04:35,040
како овој, бидејќи во спротивно,
ние сме поминувале value-- сме

88
00:04:35,040 --> 00:04:38,140
поминува во примероци од дното,
и така ние не сме, всушност, се менува

89
00:04:38,140 --> 00:04:41,050
на листа на чекање дека имаме намера да се промени.

90
00:04:41,050 --> 00:04:44,860
>> Од друга работа што треба да направите е да се прифати
еден елемент на податок на соодветниот тип.

91
00:04:44,860 --> 00:04:46,818
Повторно, во овој случај, тоа е
ќе биде цели броеви,

92
00:04:46,818 --> 00:04:49,330
но може да се произволно
декларираат податочен тип како вредност

93
00:04:49,330 --> 00:04:51,160
и користете го овој поопшто.

94
00:04:51,160 --> 00:04:56,030
Тоа е елементот што сакаме да Стави во ред,
сакаме да го додадете на крајот на редот.

95
00:04:56,030 --> 00:04:58,573
Тогаш ние всушност сакаме да
поставите дека податоците во редот.

96
00:04:58,573 --> 00:05:01,490
Во овој случај, ставајќи го во
точната локација на нашата низа,

97
00:05:01,490 --> 00:05:05,040
а потоа ние сакаме да ја смените големината
на листа на чекање, колку елементи ние

98
00:05:05,040 --> 00:05:07,050
во моментов имаат.

99
00:05:07,050 --> 00:05:07,990
>> Па ајде да започнете.

100
00:05:07,990 --> 00:05:10,890
Еве, повторно, дека општо
декларација форма функција

101
00:05:10,890 --> 00:05:13,980
Стави во ред за она што може да изгледа.

102
00:05:13,980 --> 00:05:14,910
И тука ќе одиме.

103
00:05:14,910 --> 00:05:18,335
Ајде Стави во ред на бројот
28 во редот.

104
00:05:18,335 --> 00:05:19,460
Па што ќе правиме?

105
00:05:19,460 --> 00:05:23,390
Па, пред нашата задача е
на 0, а големината на нашата листа на чекање

106
00:05:23,390 --> 00:05:29,680
е на 0, и така ние веројатно ќе сакате да се стави
бројот 28 во број низа елементи

107
00:05:29,680 --> 00:05:31,124
0, нели?

108
00:05:31,124 --> 00:05:32,540
Па ние сега дека сте сместени во таму.

109
00:05:32,540 --> 00:05:34,820
Па сега се што ни е потребно да се промени?

110
00:05:34,820 --> 00:05:37,090
Ние не сакаме да се промени
на предниот дел на дното,

111
00:05:37,090 --> 00:05:40,850
затоа што сакаме да знаеме што елемент
ние би можеле да треба да dequeue подоцна.

112
00:05:40,850 --> 00:05:44,020
Така причина имаме пред таму
е вид на показател за тоа што е

113
00:05:44,020 --> 00:05:46,439
најстара работа на низата.

114
00:05:46,439 --> 00:05:49,730
И најстара работа на array-- во
Всушност, единственото нешто во низа во право

115
00:05:49,730 --> 00:05:53,540
now-- е 28, што е
во низа локација 0.

116
00:05:53,540 --> 00:05:56,160
Значи, ние не сакаме да
промени тоа зелени број,

117
00:05:56,160 --> 00:05:57,910
затоа што тоа е најстарата елемент.

118
00:05:57,910 --> 00:06:00,510
Наместо тоа, ние сакаме да ја смените големината.

119
00:06:00,510 --> 00:06:04,110
Значи во овој случај, ние ќе
прираст големината на 1.

120
00:06:04,110 --> 00:06:08,430
>> Сега општ вид на идеја за тоа каде
Следниот елемент се случува да одам во редица

121
00:06:08,430 --> 00:06:12,310
е да додадете оние два броја
заедно, пред и големина,

122
00:06:12,310 --> 00:06:16,390
и тоа ќе ви кажам каде што следната
елемент на листа на чекање се случува да одам.

123
00:06:16,390 --> 00:06:18,130
Па сега ајде Стави во ред друг број.

124
00:06:18,130 --> 00:06:20,250
Ајде Стави во ред 33.

125
00:06:20,250 --> 00:06:24,480
33 па се случува да одат во
Низа локација 0 плус 1.

126
00:06:24,480 --> 00:06:26,840
Значи во овој случај, тоа се случува
да се оди во локација низата 1,

127
00:06:26,840 --> 00:06:29,500
и сега на големината на нашата задача е 2.

128
00:06:29,500 --> 00:06:31,840
>> Повторно, ние не се менува
на предната страна од нашата листа на чекање,

129
00:06:31,840 --> 00:06:34,730
бидејќи 28 се уште е
Најстариот елемент, а ние

130
00:06:34,730 --> 00:06:38,220
сакате to-- кога на крајот се
да dequeuing, отстранувања на елементи

131
00:06:38,220 --> 00:06:43,300
од оваа редица, сакаме да знаеме
каде најстарата елемент е.

132
00:06:43,300 --> 00:06:48,620
И така ние секогаш треба да се одржи
некои показател за каде што е.

133
00:06:48,620 --> 00:06:50,410
Значи тоа е она што на 0 е за таму.

134
00:06:50,410 --> 00:06:52,910
Тоа е она што е таму за пред.

135
00:06:52,910 --> 00:06:55,022
>> Ајде во Стави во ред уште еден елемент, 19.

136
00:06:55,022 --> 00:06:56,980
Сигурен сум дека може да се погоди
19 каде се случува да одам.

137
00:06:56,980 --> 00:06:59,860
Тоа се случува да одат во
Низа локација број 2.

138
00:06:59,860 --> 00:07:01,570
Тоа е 0, плус 2.

139
00:07:01,570 --> 00:07:03,199
И сега на големината на нашата задача е 3.

140
00:07:03,199 --> 00:07:04,240
Имаме 3 елементи во неа.

141
00:07:04,240 --> 00:07:08,490
Значи, ако веќе треба да се, и ние нема
до сега, Стави во ред уште еден елемент,

142
00:07:08,490 --> 00:07:11,370
тоа ќе оди во локација низа
број 3, а големината на нашата листа на чекање

143
00:07:11,370 --> 00:07:13,160
ќе биде 4.

144
00:07:13,160 --> 00:07:15,279
Значи ние сме enqueued неколку елементи сега.

145
00:07:15,279 --> 00:07:16,570
Сега ајде да почнеме да ги отстрани.

146
00:07:16,570 --> 00:07:19,450
Ајде да ги dequeue од задачата.

147
00:07:19,450 --> 00:07:23,340
>> Толку слична на поп, кој е вид
на аналогот од тоа за Купишта,

148
00:07:23,340 --> 00:07:26,180
dequeue треба да се прифати
покажувачот на queue-- повторно,

149
00:07:26,180 --> 00:07:28,140
освен ако тоа е глобално декларирана.

150
00:07:28,140 --> 00:07:31,610
Сега сакаме да ја промените локацијата
на предниот дел на дното.

151
00:07:31,610 --> 00:07:35,050
Ова е местото каде што вид на збор
стапува на сцената, тој фронт променлива,

152
00:07:35,050 --> 00:07:37,310
затоа што еднаш ги отстраниме
елемент, сакаме

153
00:07:37,310 --> 00:07:40,720
да се движи кон следниот најстарата елемент.

154
00:07:40,720 --> 00:07:44,180
>> Тогаш сакаме да се намали
големината на листа на чекање,

155
00:07:44,180 --> 00:07:47,130
и тогаш сакаат да се вратат на вредноста
која беше отстранета од задачата.

156
00:07:47,130 --> 00:07:48,921
Повторно, ние не сакаме да само да го исфрли.

157
00:07:48,921 --> 00:07:51,170
Ние се претпоставува дека се вадат
тоа од queue-- сме

158
00:07:51,170 --> 00:07:54,170
тоа dequeuing бидејќи ние сме загрижени за тоа.

159
00:07:54,170 --> 00:08:01,080
Затоа сакаме оваа функција за да се вратат
еден елемент на податок од типот вредност.

160
00:08:01,080 --> 00:08:04,360
Повторно, во овој случај, вредност не е цел број.

161
00:08:04,360 --> 00:08:05,670
>> Па сега ајде dequeue нешто.

162
00:08:05,670 --> 00:08:09,310
Ајде да се отстрани елементот од задачата.

163
00:08:09,310 --> 00:08:15,970
Ако речеме int x е еднаква & П, симболот q--
повторно тоа е покажувач кон ова н податоци

164
00:08:15,970 --> 00:08:20,177
structure-- она ​​елемент
ќе се dequeued?

165
00:08:20,177 --> 00:08:23,840

166
00:08:23,840 --> 00:08:29,480
Во овој случај, затоа што тоа е прв
, а прв податочна структура, FIFO,

167
00:08:29,480 --> 00:08:33,690
првото нешто што го стави во овој
редот беше 28, и така во овој случај,

168
00:08:33,690 --> 00:08:37,245
ние ќе треба да се земе 28 од
на листа на чекање, а не 19, што е она што

169
00:08:37,245 --> 00:08:38,870
ние би го направиле ако ова беше оџак.

170
00:08:38,870 --> 00:08:42,220
Ние ќе треба да се земе 28 од редот.

171
00:08:42,220 --> 00:08:44,960
>> Слично на она што го правевме со
магацинот, ние не сме, всушност,

172
00:08:44,960 --> 00:08:47,345
случува да ги избришете 28
од самата листа на чекање,

173
00:08:47,345 --> 00:08:49,470
ние сме само ќе вид
на преправаме дека не е таму.

174
00:08:49,470 --> 00:08:51,678
Па затоа се случува да остане таму
во меморија, но ние сме само

175
00:08:51,678 --> 00:08:57,820
случува да се вид на го игнорираат со поместување
другите две полиња на нашите податоци Q

176
00:08:57,820 --> 00:08:58,830
структура.

177
00:08:58,830 --> 00:09:00,230
Ние ќе треба да се промени на предниот дел.

178
00:09:00,230 --> 00:09:04,290
Q.front е сега се случува
биде 1, затоа што тоа е сега

179
00:09:04,290 --> 00:09:07,740
најстарата елемент што ја имаме во нашата
на дното, бидејќи ние сме веќе елиминирани 28,

180
00:09:07,740 --> 00:09:10,460
кој беше поранешен најстарата елемент.

181
00:09:10,460 --> 00:09:13,540
>> И сега, ние сакаме да се промени
на големината на дното

182
00:09:13,540 --> 00:09:15,780
до два елементи, наместо три.

183
00:09:15,780 --> 00:09:20,450
Сега се сеќавам порано кажав, кога ние
сакате да го додадете елементи за да се на листа на чекање,

184
00:09:20,450 --> 00:09:26,000
ние го стави во една локација низа
која е збир на предните и големина.

185
00:09:26,000 --> 00:09:29,050
Значи во овој случај, ние сме уште ставање
тоа, следниот елемент во редот,

186
00:09:29,050 --> 00:09:33,360
во локација низа 3, и
ќе видиме дека во една секунда.

187
00:09:33,360 --> 00:09:35,730
>> Па ние сега сме dequeued нашите
Првиот елемент од задачата.

188
00:09:35,730 --> 00:09:36,480
Да го направиме тоа повторно.

189
00:09:36,480 --> 00:09:38,696
Ајде да се отстранат на друг
елемент од задачата.

190
00:09:38,696 --> 00:09:42,400
Во случај, сегашниот најстарите
елемент е локација низа 1.

191
00:09:42,400 --> 00:09:44,220
Тоа е она што q.front ни кажува.

192
00:09:44,220 --> 00:09:46,980
Дека зелено поле, ни кажува дека
тоа е најстарата елемент.

193
00:09:46,980 --> 00:09:49,310
И така, ќе стане 33 х.

194
00:09:49,310 --> 00:09:52,130
Ние само ќе вид заборавајте
дека 33 постои во низа,

195
00:09:52,130 --> 00:09:55,100
и ние ќе се каже дека сега,
нови најстарата елемент во редот

196
00:09:55,100 --> 00:09:58,900
е на локација низа 2, а големината
на дното, бројот на елементи

197
00:09:58,900 --> 00:10:02,152
ние сме во ред, е 1.

198
00:10:02,152 --> 00:10:05,110
Сега ајде да Стави во ред нешто, и јас
вид даде оваа далеку пред една секунда,

199
00:10:05,110 --> 00:10:10,340
но ако сакаме да се стави 40 во
на дното, каде што имаат 40 случува да се оди?

200
00:10:10,340 --> 00:10:12,880

201
00:10:12,880 --> 00:10:17,730
И ние сме биле тоа ставање
во q.front плус редица големина,

202
00:10:17,730 --> 00:10:20,850
и така има смисла да се
всушност, да се стави 40 тука.

203
00:10:20,850 --> 00:10:22,840
Сега се забележи дека во
одреден момент, ние ќе

204
00:10:22,840 --> 00:10:27,980
да се дојде до крајот на
нашата низа во внатрешноста на q,

205
00:10:27,980 --> 00:10:32,010
но дека избледени од 28 и 33--
тие се, всушност, технички

206
00:10:32,010 --> 00:10:33,300
отворени простори, нели?

207
00:10:33,300 --> 00:10:36,040
И така, ние можеби eventually--
тоа правило за додавање

208
00:10:36,040 --> 00:10:40,390
тие две together-- ние на крајот може да
треба да МО по големината на капацитетот

209
00:10:40,390 --> 00:10:41,410
за да можеме да се заврши околу.

210
00:10:41,410 --> 00:10:43,620
>> Значи, ако ние се дојде до елемент
број 10, ако ние сме

211
00:10:43,620 --> 00:10:48,790
го заменува во елемент бројот 10, би
всушност, го стави во низа локација 0.

212
00:10:48,790 --> 00:10:50,997
И ако ние се случува да се
Низа location-- извинете,

213
00:10:50,997 --> 00:10:53,080
ако им се собираат заедно,
и стигнавме до бројот

214
00:10:53,080 --> 00:10:56,330
11 ќе биде каде што ќе треба да се стави
тоа што не постои во овој array--

215
00:10:56,330 --> 00:10:58,200
тоа ќе се случува надвор од границите.

216
00:10:58,200 --> 00:11:03,367
Ние би можеле да се современи за 10 и го стави
тоа во низа локација 1.

217
00:11:03,367 --> 00:11:04,450
Па тоа е како редици работат.

218
00:11:04,450 --> 00:11:08,540
Тие секогаш се случува да се оди од лево
да се во право, а можеби и се обвиткуваат околу.

219
00:11:08,540 --> 00:11:11,280
А ти знаеш дека тие се
целосна ако големината, дека црвено поле,

220
00:11:11,280 --> 00:11:13,710
станува еднаква на капацитет.

221
00:11:13,710 --> 00:11:16,720
И така, по додадовме 40 до
на дното, и она што ние треба да направите?

222
00:11:16,720 --> 00:11:19,890
Па, најстарата елемент
на листа на чекање се уште 19,

223
00:11:19,890 --> 00:11:21,990
па ние не сакаме да се промени
на предниот дел на дното,

224
00:11:21,990 --> 00:11:23,820
но сега имаме два
елементи на листа на чекање,

225
00:11:23,820 --> 00:11:28,710
и така сакаме да се зголеми
нашата големина од 1 до 2.

226
00:11:28,710 --> 00:11:31,820
>> Тоа е доста тоа со
работат со низа базирани редици,

227
00:11:31,820 --> 00:11:33,630
и слични на магацинот,
таму е исто така начин

228
00:11:33,630 --> 00:11:36,450
за спроведување на редот како поврзани листа.

229
00:11:36,450 --> 00:11:40,150
Сега, ако оваа податочна структура тип
изгледа познато за вас, тоа е.

230
00:11:40,150 --> 00:11:43,780
Тоа не е поединечно поврзани листа,
тоа е двојно поврзана листата.

231
00:11:43,780 --> 00:11:46,790
И сега, како настрана, тоа е
всушност, е можно да се спроведе

232
00:11:46,790 --> 00:11:50,160
редица како одделно поврзани листа, но
Мислам дека во однос на визуелизација,

233
00:11:50,160 --> 00:11:53,350
тоа всушност би можеле да помогнат за да ја видите
ова како двојно поврзана листата.

234
00:11:53,350 --> 00:11:56,850
Но тоа дефинитивно е можно да се
сторам тоа, како одделно поврзани листа.

235
00:11:56,850 --> 00:12:00,110
>> Па ајде да го погледне во
она што ова може да изгледа.

236
00:12:00,110 --> 00:12:02,750
Ако сакаме да enquue--
па сега, повторно сме

237
00:12:02,750 --> 00:12:05,360
менувањето на врзан-листа
базирани модел тука.

238
00:12:05,360 --> 00:12:08,420
Ако сакаме да се Стави во ред, ние сакаме
за да додадете нов елемент, и

239
00:12:08,420 --> 00:12:09,730
она што ние треба да направите?

240
00:12:09,730 --> 00:12:12,770
Па, прв од сите, бидејќи
ние сме додавање на крајот

241
00:12:12,770 --> 00:12:15,520
и отстранување од
почеток, ние најверојатно

242
00:12:15,520 --> 00:12:20,050
сакаат да го задржат покажувачи за двете
главата и опашката на поврзани листа?

243
00:12:20,050 --> 00:12:22,660
Опашка биде уште еден мандат за
крајот на поврзани листа,

244
00:12:22,660 --> 00:12:24,496
последниот елемент во поврзаните листа.

245
00:12:24,496 --> 00:12:26,620
И тие ќе веројатно,
повторно, да биде од корист за нас

246
00:12:26,620 --> 00:12:28,477
ако тие се глобални променливи.

247
00:12:28,477 --> 00:12:31,060
Но, сега, ако сакаме да додадете нова
елемент на она што го имаме да се направи?

248
00:12:31,060 --> 00:12:35,262
Она што ние само [? Malak?] или динамично
распредели нашиот нов јазол за нас самите.

249
00:12:35,262 --> 00:12:38,220
А потоа, исто како кога ќе се додаде кој било
елемент на двојно поврзана листа ние,

250
00:12:38,220 --> 00:12:40,410
само треба да се најде решение за of--
оние последните три чекори тука

251
00:12:40,410 --> 00:12:43,330
се само сите за поместување на
покажувачи на правилен начин

252
00:12:43,330 --> 00:12:46,710
така што елементот добива додадена на
синџирот без кршење на синџир

253
00:12:46,710 --> 00:12:49,580
или да се направат некој вид на грешка
или да се има некој вид на несреќа

254
00:12:49,580 --> 00:12:54,505
случи со кое би можеле случајно
сираче некои елементи на нашата листа на чекање.

255
00:12:54,505 --> 00:12:55,880
Тука е она што ова може да изгледа.

256
00:12:55,880 --> 00:13:00,980
Ние сакаме да додадете елемент
10 до крајот на оваа задача.

257
00:13:00,980 --> 00:13:03,380
Па најстарата елемент тука
е претставена од страна на главата.

258
00:13:03,380 --> 00:13:06,800
Тоа е првото нешто што го стави
во овој хипотетички ред тука.

259
00:13:06,800 --> 00:13:10,430
И опашката, 13, е најстариот
неодамна додаде елемент.

260
00:13:10,430 --> 00:13:17,030
И така, ако сакаме да Стави во ред 10 во
оваа задача, ние сакаме да го стави во 13.

261
00:13:17,030 --> 00:13:19,860
И така ние си оди за да се динамички
одвои простор за нов јазол

262
00:13:19,860 --> 00:13:23,280
и да се провери за ништовни да бидете сигурни
немаме неуспех сеќавање.

263
00:13:23,280 --> 00:13:27,040
Тогаш ние ќе треба да
место 10 во тој јазол,

264
00:13:27,040 --> 00:13:30,030
и сега ние треба да бидат внимателни
за тоа како ние го организира покажувачи

265
00:13:30,030 --> 00:13:32,180
па ние не се скрши синџирот.

266
00:13:32,180 --> 00:13:38,910
>> Може да се постави 10 претходното поле
до точка назад кон стариот опашка,

267
00:13:38,910 --> 00:13:41,620
а од '10 ќе биде
нови задни во одреден момент

268
00:13:41,620 --> 00:13:44,459
од страна на време на сите овие
синџири се поврзани,

269
00:13:44,459 --> 00:13:46,250
ништо не се случува да дојде
по 10 моментов.

270
00:13:46,250 --> 00:13:49,880
И така 10 следната покажувачот
ќе укаже на нула,

271
00:13:49,880 --> 00:13:53,580
а потоа откако ќе го направите тоа, откако ќе ја
10 поврзани наназад во синџирот,

272
00:13:53,580 --> 00:13:57,780
можеме да се земе стариот шеф, или, изговор
ми, старата опашката на задачата.

273
00:13:57,780 --> 00:14:02,980
Стариот крај на редот,
13, и да ја направат укажуваат на 10.

274
00:14:02,980 --> 00:14:08,220
И сега, во овој момент, имаме
enqueued бројот 10 во оваа задача.

275
00:14:08,220 --> 00:14:14,740
Сите ние треба да направите сега е само се движат
опашка да се укаже на 10, наместо до 13.

276
00:14:14,740 --> 00:14:17,630
>> Dequeuing е, всушност,
многу сличен на пукање

277
00:14:17,630 --> 00:14:21,710
од магацинот, кој е
спроведува како поврзани листа

278
00:14:21,710 --> 00:14:24,040
ако сте виделе видео Купишта.

279
00:14:24,040 --> 00:14:27,280
Сите ние треба да направите е да се започне во
почеток, се најде на вториот елемент,

280
00:14:27,280 --> 00:14:30,480
ослободување на првиот елемент,
а потоа се пресели на главата

281
00:14:30,480 --> 00:14:32,930
до точка на вториот елемент.

282
00:14:32,930 --> 00:14:37,920
Веројатно е подобро да се визуелизира
само за да биде екстра јасни околу тоа.

283
00:14:37,920 --> 00:14:39,230
Значи тука е нашата задача повторно.

284
00:14:39,230 --> 00:14:42,600
12 е најстарата елемент
во нашата листа на чекање, на главата.

285
00:14:42,600 --> 00:14:46,210
10 е најновиот елемент
во нашата задача, нашите опашка.

286
00:14:46,210 --> 00:14:49,310
>> И така, кога сакаме
да dequeue елемент,

287
00:14:49,310 --> 00:14:52,202
ние сакаме да се отстрани најстарата елемент.

288
00:14:52,202 --> 00:14:52,910
Значи она што ќе правиме?

289
00:14:52,910 --> 00:14:55,243
Па ние се постави traversal покажувачот
која започнува во главата,

290
00:14:55,243 --> 00:14:57,840
и ние ја преместите, така што тоа
укажува на вториот елемент

291
00:14:57,840 --> 00:15:02,290
на овој queue-- нешто велејќи trav
еднаква trav стрелката до, на пример,

292
00:15:02,290 --> 00:15:07,170
ќе се движи trav таму да се укаже на
15, кои, откако ќе dequeue 12,

293
00:15:07,170 --> 00:15:13,030
или откако ќе се отстранат 12, ќе
стане тогашниот најстарата елемент.

294
00:15:13,030 --> 00:15:16,360
>> Сега ќе го одржи на првиот
елемент преку глава покажувач

295
00:15:16,360 --> 00:15:19,440
и вториот елемент
преку trav покажувачот.

296
00:15:19,440 --> 00:15:25,170
Ние сега можат слободно главата, а потоа можеме
велат дека ништо не доаѓа пред 15 повеќе.

297
00:15:25,170 --> 00:15:29,990
За да можеме да се промени 15 претходното
покажувачот да укаже на нула,

298
00:15:29,990 --> 00:15:31,874
а ние само се движат над главата.

299
00:15:31,874 --> 00:15:32,540
И таму ќе одиме.

300
00:15:32,540 --> 00:15:35,840
Сега имаме успешно
dequeued 12, и сега ние

301
00:15:35,840 --> 00:15:39,180
имаат уште една редица на 4 елементи.

302
00:15:39,180 --> 00:15:41,700
Тоа е доста на сите
таму е да редици,

303
00:15:41,700 --> 00:15:45,810
и низа-базирани и поврзани листа-базирана.

304
00:15:45,810 --> 00:15:46,860
Јас сум Даг Лојд.

305
00:15:46,860 --> 00:15:49,100
Ова е 50 КС.

306
00:15:49,100 --> 00:15:50,763