1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [第6條] [舒適]

2
00:00:01,000 --> 00:00:04,000
羅布·鮑登] [哈佛大學]

3
00:00:04,000 --> 00:00:09,000
這是CS50。[CS50.TV]

4
00:00:09,000 --> 00:00:11,000
>> 我們可以前往我們的部分問題。

5
00:00:11,000 --> 00:00:17,000
我的空間，然後再發送URL。

6
00:00:17,000 --> 00:00:22,000
開始部分的問題說

7
00:00:22,000 --> 00:00:26,000
顯然，我並不完全unsick是一個很簡單的問題

8
00:00:26,000 --> 00:00:28,000
究竟什麼是Valgrind的？

9
00:00:28,000 --> 00:00:30,000
Valgrind的是什麼辦？

10
00:00:30,000 --> 00:00:34,000
任何人想要說什麼Valgrind的嗎？

11
00:00:34,000 --> 00:00:36,000
[學生]：檢查內存洩漏。

12
00:00:36,000 --> 00:00:41,000
是啊，Valgrind是一個一般的內存檢查。

13
00:00:41,000 --> 00:00:44,000
，最終，它會告訴你，如果你有任何內存洩漏，

14
00:00:44,000 --> 00:00:49,000
這主要是我們正在使用它，因為如果你想

15
00:00:49,000 --> 00:00:54,000
問題集，或如果你想

16
00:00:54,000 --> 00:00:59,000
大板，你需要有任何沒有內存洩漏，

17
00:00:59,000 --> 00:01:01,000
如果你有內存洩漏，你不能找到，

18
00:01:01,000 --> 00:01:04,000
也請記住，每當你打開一個文件時，

19
00:01:04,000 --> 00:01:07,000
，如果你不關閉它，這是一個內存洩漏。

20
00:01:07,000 --> 00:01:10,000
>> 很多人都在尋找一些節點，他們不釋放

21
00:01:10,000 --> 00:01:15,000
真的，他們沒有關閉字典中的第一步。

22
00:01:15,000 --> 00:01:19,000
它也告訴你，如果你有任何無效的讀取或寫入，

23
00:01:19,000 --> 00:01:22,000
這意味著，如果你嘗試設置一個值

24
00:01:22,000 --> 00:01:26,000
這超出堆的結束，它不會發生段故障

25
00:01:26,000 --> 00:01:30,000
但Valgrind的捕獲它，你不應該寫在那裡，

26
00:01:30,000 --> 00:01:33,000
，所以你絕對不應該有任何的那些要么。

27
00:01:33,000 --> 00:01:38,000
你如何使用Valgrind的嗎？

28
00:01:38,000 --> 00:01:42,000
你如何使用Valgrind的嗎？

29
00:01:42,000 --> 00:01:45,000
>> 這是一個普遍的問題

30
00:01:45,000 --> 00:01:49,000
種運行它，並期待在輸出端。

31
00:01:49,000 --> 00:01:51,000
輸出壓倒了很多次。

32
00:01:51,000 --> 00:01:54,000
也很有趣，如果你有一些非常錯誤的事情的錯誤

33
00:01:54,000 --> 00:01:59,000
發生在一個循環中，那麼它最終會說，“太多的錯誤。

34
00:01:59,000 --> 00:02:03,000
我要現在停止計數。“

35
00:02:03,000 --> 00:02:08,000
它基本上是你要解析的文本輸出。

36
00:02:08,000 --> 00:02:13,000
最後，它會告訴你，你有任何內存洩漏，

37
00:02:13,000 --> 00:02:16,000
有多少塊，它可以是有用的，因為

38
00:02:16,000 --> 00:02:20,000
如果是1塊未釋放，那麼它通常更容易找到

39
00:02:20,000 --> 00:02:23,000
超過1000塊未釋放。

40
00:02:23,000 --> 00:02:26,000
千的塊未釋放可能意味著你不釋放

41
00:02:26,000 --> 00:02:30,000
您的鍊錶是否恰當一些。

42
00:02:30,000 --> 00:02:32,000
這是Valgrind的。

43
00:02:32,000 --> 00:02:35,000
>> 現在，我們有我們的部分問題，

44
00:02:35,000 --> 00:02:38,000
您不需要下載。

45
00:02:38,000 --> 00:02:41,000
您可以點擊我的名字和他們的空間。

46
00:02:41,000 --> 00:02:44,000
現在點擊我。

47
00:02:44,000 --> 00:02:46,000
第1次修訂將堆棧，這是我們正在做的第一個。

48
00:02:46,000 --> 00:02:55,000
修訂2將隊列中，第三次修訂版將是單向鍊錶。

49
00:02:55,000 --> 00:02:58,000
開始我們的堆棧。

50
00:02:58,000 --> 00:03:02,000
因為它說，在這裡，一個堆棧是一個最基本的，

51
00:03:02,000 --> 00:03:07,000
計算機科學的基本數據結構。

52
00:03:07,000 --> 00:03:11,000
很典型的例子是

53
00:03:11,000 --> 00:03:13,000
在食堂的托盤堆。

54
00:03:13,000 --> 00:03:16,000
它基本上是只要你被介紹到堆棧，

55
00:03:16,000 --> 00:03:20,000
有人會說，“哦，就像一個堆棧的托盤。”

56
00:03:20,000 --> 00:03:22,000
您堆疊紙盤。

57
00:03:22,000 --> 00:03:24,000
然後，當你去拉一個托盤，

58
00:03:24,000 --> 00:03:31,000
第一盤，但最近拉的是放在堆棧中的最後一個。

59
00:03:31,000 --> 00:03:34,000
該協議棧也喜歡在這裡說

60
00:03:34,000 --> 00:03:37,000
我們有內存段稱為堆疊。

61
00:03:37,000 --> 00:03:40,000
為什麼它被稱為堆棧？

62
00:03:40,000 --> 00:03:42,000
>> 因為像一個堆棧的數據結構，

63
00:03:42,000 --> 00:03:46,000
它壓入和彈出堆棧幀在堆棧上，

64
00:03:46,000 --> 00:03:53,000
堆棧幀像一個特定的呼叫的功能。

65
00:03:53,000 --> 00:03:57,000
就像一個堆棧，你將永遠有返回

66
00:03:57,000 --> 00:04:03,000
從一個函數調用之前，你可以下降到較低的堆棧幀。

67
00:04:03,000 --> 00:04:08,000
您可以沒有main調用foo調用酒吧和酒吧返回到主直接。

68
00:04:08,000 --> 00:04:14,000
它總是遵循了正確的堆棧入棧和出棧。

69
00:04:14,000 --> 00:04:18,000
就像我說的，這兩個操作，push和pop。

70
00:04:18,000 --> 00:04:20,000
這些都是普及條款。

71
00:04:20,000 --> 00:04:26,000
你應該知道，在棧不管是什麼方面的push和pop。

72
00:04:26,000 --> 00:04:28,000
我們會看到隊列是一種不同的。

73
00:04:28,000 --> 00:04:32,000
它並沒有真正有一個通用的術語，但是普遍的堆棧push和pop。

74
00:04:32,000 --> 00:04:34,000
只是在棧上推。

75
00:04:34,000 --> 00:04:37,000
流行是從堆棧中。

76
00:04:37,000 --> 00:04:43,000
我們在這裡看到的，我們有我們的typedef結構棧，

77
00:04:43,000 --> 00:04:46,000
所以，我們的char *字符串。

78
00:04:46,000 --> 00:04:51,000
不要害怕任何**。

79
00:04:51,000 --> 00:04:54,000
這將是一個字符串數組

80
00:04:54,000 --> 00:04:58,000
或字符數組的指針，其中

81
00:04:58,000 --> 00:05:00,000
指向字符的指針往往是字符串。

82
00:05:00,000 --> 00:05:05,000
它沒有為字符串，但在這裡，他們將是字符串。

83
00:05:05,000 --> 00:05:08,000
>> 我們有一個字符串數組。

84
00:05:08,000 --> 00:05:14,000
我們有一個大小，表示目前有多少元素在棧上，

85
00:05:14,000 --> 00:05:19,000
然後我們有能力，這是可以在棧上有多少個元素。

86
00:05:19,000 --> 00:05:22,000
容量應開始大於1，

87
00:05:22,000 --> 00:05:27,000
但規模要開始為0。

88
00:05:27,000 --> 00:05:36,000
現在，基本上有三種不同的方式，你能想到的堆棧。

89
00:05:36,000 --> 00:05:39,000
嗯，有可能更多，但兩種主要方式

90
00:05:39,000 --> 00:05:43,000
你可以實現使用一個數組，也可以實現使用鍊錶。

91
00:05:43,000 --> 00:05:48,000
鍊錶是一種微不足道的棧。

92
00:05:48,000 --> 00:05:51,000
這是很容易使一個堆棧使用鍊錶，

93
00:05:51,000 --> 00:05:55,000
所以在這裡，我們要製作堆棧使用數組，

94
00:05:55,000 --> 00:05:59,000
，然後使用數組，有兩種方式，你可以考慮一下。

95
00:05:59,000 --> 00:06:01,000
在此之前，當我說我們有能力為堆棧，

96
00:06:01,000 --> 00:06:04,000
因此，我們可以容納一個元素在堆棧中。

97
00:06:04,000 --> 00:06:09,000
>> 它可能發生的一種方式是，一旦你打10個元素，那麼你就大功告成了。

98
00:06:09,000 --> 00:06:13,000
你可能知道，有一個上限的10件事情在世界上

99
00:06:13,000 --> 00:06:16,000
你永遠也不會在棧上有10個以上的東西，

100
00:06:16,000 --> 00:06:20,000
在這種情況下，你可以有你的堆棧的大小的上限。

101
00:06:20,000 --> 00:06:23,000
或者你可以有你的堆棧是無界的，

102
00:06:23,000 --> 00:06:27,000
但如果你正在做一個陣列，這意味著每一次你打10個元素，

103
00:06:27,000 --> 00:06:29,000
那麼你會增長到20個元素，當你打20個元素，

104
00:06:29,000 --> 00:06:33,000
你將有增長數組的30個元素或40個元素。

105
00:06:33,000 --> 00:06:37,000
你會需要增加的能力，這是我們要在這裡做什麼。

106
00:06:37,000 --> 00:06:40,000
每一次我們達到我們的堆棧的最大大小，

107
00:06:40,000 --> 00:06:46,000
當我們把別的事情上，我們將需要增加的能力。

108
00:06:46,000 --> 00:06:50,000
在這裡，我們推聲明為布爾推（字符*海峽）。

109
00:06:50,000 --> 00:06:54,000
的char * str是字符串，我們推入堆棧，

110
00:06:54,000 --> 00:06:58,000
和bool只是說我們是否成功或失敗。

111
00:06:58,000 --> 00:07:00,000
>> 我們怎能不呢？

112
00:07:00,000 --> 00:07:04,000
什麼是唯一的情況下，你能想到的

113
00:07:04,000 --> 00:07:07,000
在這裡，我們需要返回false？

114
00:07:07,000 --> 00:07:09,000
是啊。

115
00:07:09,000 --> 00:07:12,000
[學生]：如果它是完整的，我們使用的是有界的實現。

116
00:07:12,000 --> 00:07:17,000
是啊，所以我們定義，他說：

117
00:07:17,000 --> 00:07:23,000
如果是完整的，和我們使用的是有界的實現。

118
00:07:23,000 --> 00:07:26,000
然後，我們肯定會返回false。

119
00:07:26,000 --> 00:07:31,000
只要我們打的10件事情在數組中，我們可以不適合11，所以我們返回false。

120
00:07:31,000 --> 00:07:32,000
如果它是無界的，該怎麼辦？是啊。

121
00:07:32,000 --> 00:07:38,000
如果出於某種原因，你不能擴展磁盤陣列。

122
00:07:38,000 --> 00:07:43,000
是啊，所以內存是一種有限的資源，

123
00:07:43,000 --> 00:07:51,000
最終，如果我們繼續推動入堆棧的事情一遍又一遍，

124
00:07:51,000 --> 00:07:54,000
我們要嘗試分配一個更大的數組，以適應

125
00:07:54,000 --> 00:07:59,000
產能較大，我們正在使用的malloc或任何會返回false。

126
00:07:59,000 --> 00:08:02,000
好了，malloc將返回null。

127
00:08:02,000 --> 00:08:05,000
>> 請記住，你曾經每一次調用malloc，你應該檢查，看它是否

128
00:08:05,000 --> 00:08:12,000
返回null，否則這是一個正確的扣除。

129
00:08:12,000 --> 00:08:17,000
因為我們希望有一個無限的堆棧，

130
00:08:17,000 --> 00:08:21,000
唯一的情況下，我們將要返回false，如果我們試圖

131
00:08:21,000 --> 00:08:26,000
增加的容量和malloc或任何返回false。

132
00:08:26,000 --> 00:08:30,000
這時彈出不帶任何參數，

133
00:08:30,000 --> 00:08:37,000
並且它返回字符串，該字符串是在堆棧的頂部。

134
00:08:37,000 --> 00:08:41,000
無論是最近被壓入堆棧彈出返回，

135
00:08:41,000 --> 00:08:44,000
它也把它從棧中刪除。

136
00:08:44,000 --> 00:08:50,000
發現，它返回null，如果在棧上有什麼。

137
00:08:50,000 --> 00:08:53,000
它始終是可能的堆棧是空的。

138
00:08:53,000 --> 00:08:55,000
在Java中，如果你使用，或其他語言，

139
00:08:55,000 --> 00:09:01,000
試圖從一個空棧中彈出，可能會導致異常或什麼的。

140
00:09:01,000 --> 00:09:09,000
>> 但在C，空是種了很多的情況下，我們如何處理這些問題。

141
00:09:09,000 --> 00:09:13,000
返回null是我們要如何表示的堆棧是空的。

142
00:09:13,000 --> 00:09:16,000
我們提供的代碼，將測試協議棧的功能，

143
00:09:16,000 --> 00:09:19,000
實現push和pop。

144
00:09:19,000 --> 00:09:23,000
這會不會是大量的代碼。

145
00:09:23,000 --> 00:09:40,000
我會實際上，在我們這樣做之前，提示，提示

146
00:09:40,000 --> 00:09:44,000
如果你還沒有看到它時，malloc是不是唯一的功能

147
00:09:44,000 --> 00:09:47,000
為您的堆分配內存。

148
00:09:47,000 --> 00:09:51,000
有一個家庭的alloc函數。

149
00:09:51,000 --> 00:09:53,000
首先是malloc的，你已經習慣了。

150
00:09:53,000 --> 00:09:56,000
然後釋放calloc，做同樣的事情的malloc，

151
00:09:56,000 --> 00:09:59,000
但它會為零，一切為你。

152
00:09:59,000 --> 00:10:04,000
如果你曾經想將一切設置為null後mallocing的東西

153
00:10:04,000 --> 00:10:06,000
你應該只是用來釋放calloc，而不是寫在首位

154
00:10:06,000 --> 00:10:09,000
一個循環零出整個內存塊。

155
00:10:09,000 --> 00:10:15,000
>> 如malloc和realloc是有很多的特殊情況下，

156
00:10:15,000 --> 00:10:19,000
但基本上什麼realloc的是

157
00:10:19,000 --> 00:10:24,000
它需要一個已經分配的指針，該指針。

158
00:10:24,000 --> 00:10:27,000
realloc是你想要的功能，關注這裡。

159
00:10:27,000 --> 00:10:31,000
它需要一個已經從malloc返回的指針。

160
00:10:31,000 --> 00:10:35,000
比方說，你從malloc要求10個字節​​的指針。

161
00:10:35,000 --> 00:10:38,000
後來你意識到你需要20個字節，

162
00:10:38,000 --> 00:10:42,000
所以你調用realloc的，20個字節的指針，

163
00:10:42,000 --> 00:10:47,000
和realloc會自動複製過來的一切都是為了你。

164
00:10:47,000 --> 00:10:51,000
如果你只是叫的malloc再次，像我有塊10個字節​​。

165
00:10:51,000 --> 00:10:53,000
現在我需要一個20字節的塊，

166
00:10:53,000 --> 00:10:58,000
因此，如果我malloc的20個字節，那麼我必須手動複製10個字節​​的第一件事

167
00:10:58,000 --> 00:11:01,000
進入第二件事情，然後自由的第一件事。

168
00:11:01,000 --> 00:11:04,000
realloc的會為你處理。

169
00:11:04,000 --> 00:11:11,000
>> 請注意，簽名會是void *，

170
00:11:11,000 --> 00:11:15,000
這是只返回一個指針，指向的內存塊，

171
00:11:15,000 --> 00:11:17,000
void *的指針。

172
00:11:17,000 --> 00:11:22,000
作為一個通用的指針，你可以認為是void *。

173
00:11:22,000 --> 00:11:27,000
一般情況下，你永遠不處理用void *，

174
00:11:27,000 --> 00:11:30,000
但malloc（）並返回一個void *，然後它只是用來像

175
00:11:30,000 --> 00:11:34,000
這實際上是將是一個char *。

176
00:11:34,000 --> 00:11:37,000
，以前的void * malloc返回的

177
00:11:37,000 --> 00:11:41,000
現在要通過向realloc，然後大小

178
00:11:41,000 --> 00:11:49,000
是你要分配的字節數，因此新的能力。

179
00:11:49,000 --> 00:11:57,000
我給你一兩分鐘，這樣做在我們的空間。

180
00:11:57,000 --> 00:12:02,000
開始第1次修訂。

181
00:12:16,000 --> 00:12:21,000
我會停下來後，希望能有足夠的時間執行推入，

182
00:12:21,000 --> 00:12:24,000
然後，我給你做流行音樂的另一種突破。

183
00:12:24,000 --> 00:12:27,000
但它確實是沒有那麼多的代碼在所有。

184
00:12:27,000 --> 00:12:35,000
大多數的代碼可能擴大的東西，擴充產能。

185
00:12:35,000 --> 00:12:39,000
好了，沒有壓力，完全做到，

186
00:12:39,000 --> 00:12:47,000
但只要你覺得你是在正確的道路，這是很好的。

187
00:12:47,000 --> 00:12:53,000
>> 沒有人有任何的代碼，他們與我拉起來感覺很舒服嗎？

188
00:12:53,000 --> 00:12:59,000
是的，我會的，但沒有人有任何的代碼，我可以拉起來嗎？

189
00:12:59,000 --> 00:13:05,000
好了，你可以啟動，保存它，不管它是什麼？

190
00:13:05,000 --> 00:13:09,000
我總是忘了這一步。

191
00:13:09,000 --> 00:13:15,000
好吧，看在推，

192
00:13:15,000 --> 00:13:18,000
你要解釋你的代碼嗎？

193
00:13:18,000 --> 00:13:24,000
[學生]：首先，我增加的大小。

194
00:13:24,000 --> 00:13:28,000
我想，也許我應該有，反正，我增加的大小，

195
00:13:28,000 --> 00:13:31,000
我看看它的容量不足。

196
00:13:31,000 --> 00:13:36,000
如果是容量不足，我添加到數組中，我們已經有了。

197
00:13:36,000 --> 00:13:42,000
而且，如果不是的話，我的能力乘以2，

198
00:13:42,000 --> 00:13:50,000
我和重新分配的字符串數組的東西，現在更大的容量大小。

199
00:13:50,000 --> 00:13:55,000
然後如果失敗了，我告訴用戶並返回false，

200
00:13:55,000 --> 00:14:04,000
如果它的罰款，然後我把字符串在新的位置。

201
00:14:04,000 --> 00:14:07,000
>> [羅布B.還要注意，我們這裡用一個漂亮的位運算符

202
00:14:07,000 --> 00:14:09,000
乘以2。

203
00:14:09,000 --> 00:14:11,000
請記住，左移總是要乘以2。

204
00:14:11,000 --> 00:14:15,000
除以2，只要你記住，它意味著右移

205
00:14:15,000 --> 00:14:18,000
除以2除以2的整數。

206
00:14:18,000 --> 00:14:20,000
它可能會截斷在這裡或那裡。

207
00:14:20,000 --> 00:14:26,000
但左移1總是要被乘以2，

208
00:14:26,000 --> 00:14:32,000
除非你的整數溢出邊界，那麼就不會是。

209
00:14:32,000 --> 00:14:34,000
A面註釋。

210
00:14:34,000 --> 00:14:39,000
我喜歡做，這是不會改變的編碼任何方式，

211
00:14:39,000 --> 00:14:48,000
但我喜歡做這樣的事情。

212
00:14:48,000 --> 00:14:51,000
它實際上是要使其稍長。

213
00:15:04,000 --> 00:15:08,000
這也許是不完美的情況下顯示，

214
00:15:08,000 --> 00:15:14,000
但我喜歡分割成塊，

215
00:15:14,000 --> 00:15:17,000
好吧，如果這一點，如果發生了，那麼我要做的事情，

216
00:15:17,000 --> 00:15:19,000
，然後函數完成的。

217
00:15:19,000 --> 00:15:22,000
我不需要，然後一路向下滾動我的眼睛的功能

218
00:15:22,000 --> 00:15:25,000
看看會發生什麼後，其他。

219
00:15:25,000 --> 00:15:27,000
如果這如果發生的話，我就回來。

220
00:15:27,000 --> 00:15:30,000
它也有額外的好處，一切都超出了這個漂亮的

221
00:15:30,000 --> 00:15:33,000
現在左移一次。

222
00:15:33,000 --> 00:15:40,000
我不再需要，如果你曾經冗長得可笑的近線，

223
00:15:40,000 --> 00:15:45,000
然後這4個字節可以提供幫助，也更左的東西，

224
00:15:45,000 --> 00:15:48,000
少不堪重負，你覺得如果想好了，我一定要記住

225
00:15:48,000 --> 00:15:53,000
我目前在一個while循環內的其他內的循環。

226
00:15:53,000 --> 00:15:58,000
任何地方，你可以馬上做到這一點回報，我倒是很喜歡。

227
00:15:58,000 --> 00:16:05,000
這是完全可選的，並且預期不會以任何方式。

228
00:16:05,000 --> 00:16:12,000
>> [學生]：應該有一個大小 - 在故障條件？

229
00:16:12,000 --> 00:16:19,000
故障條件在這裡，我們向realloc失敗，所以，是的。

230
00:16:19,000 --> 00:16:22,000
請注意，在故障條件下，據推測，

231
00:16:22,000 --> 00:16:26,000
除非我們免費的東西，我們總是要失敗

232
00:16:26,000 --> 00:16:29,000
無論多少次，我們試推的東西。

233
00:16:29,000 --> 00:16:32,000
如果我們繼續推動我們不斷遞增，規模，

234
00:16:32,000 --> 00:16:36,000
即使我們不把任何東西壓入堆棧。

235
00:16:36,000 --> 00:16:39,000
通常，我們不會增加的大小，直到

236
00:16:39,000 --> 00:16:43,000
之後，我們已經成功地把它放在堆棧中。

237
00:16:43,000 --> 00:16:50,000
我們將做到這一點，說，無論是在這裡和這裡。

238
00:16:50,000 --> 00:16:56,000
然後，不要說s.size≤能力，它的容量小於，

239
00:16:56,000 --> 00:17:01,000
只是因為我們搬到這裡的一切。

240
00:17:01,000 --> 00:17:07,000
>> 請記住，唯一的地方，我們可能會返回false

241
00:17:07,000 --> 00:17:14,000
在這裡，這裡的realloc返回null，

242
00:17:14,000 --> 00:17:19,000
如果你碰巧要記住標準錯誤，

243
00:17:19,000 --> 00:17:22,000
也許你會認為這是一個情況下，你要打印一個標準的錯誤，

244
00:17:22,000 --> 00:17:26,000
fprintf STDERR，而不是直接打印到標準輸出。

245
00:17:26,000 --> 00:17:31,000
再次，這是不是一種期望，但如果它是一個錯誤，

246
00:17:31,000 --> 00:17:41,000
輸入輸出，那麼你可能希望將它打印到標準錯誤，而不是標準輸出。

247
00:17:41,000 --> 00:17:44,000
>> 任何人還有什麼要注意的嗎？是。

248
00:17:44,000 --> 00:17:47,000
[學生]：你去[聽不清]？

249
00:17:47,000 --> 00:17:55,000
[羅布B.]是的，或實際binariness，只是它是什麼呢？

250
00:17:55,000 --> 00:17:57,000
[學生]：所以你將它乘以2？

251
00:17:57,000 --> 00:17:59,000
[羅布B.]是啊，基本上是這樣。

252
00:17:59,000 --> 00:18:11,000
在二進制的土地，我們總是有一組數字。

253
00:18:11,000 --> 00:18:22,000
移此由1左側基本上將它插入這裡在右側。

254
00:18:22,000 --> 00:18:25,000
返回到這一點，只是記住，一切以二進制

255
00:18:25,000 --> 00:18:28,000
是2的冪，所以這表示2到0，

256
00:18:28,000 --> 00:18:30,000
這2到1，這2到2。

257
00:18:30,000 --> 00:18:33,000
右側插入一個0到現在，我們只是改變一切。

258
00:18:33,000 --> 00:18:38,000
曾經被認為是2 0現在是2到1，2 2。

259
00:18:38,000 --> 00:18:41,000
我們插入右側，

260
00:18:41,000 --> 00:18:44,000
一定是0，

261
00:18:44,000 --> 00:18:46,000
這是有道理的。

262
00:18:46,000 --> 00:18:49,000
如果你曾經一個數字乘以2，這不是要結束了奇數，

263
00:18:49,000 --> 00:18:54,000
所以2〜0的地方應為0，

264
00:18:54,000 --> 00:18:59,000
這是什麼我一半警告說，如果你之前是發生轉移

265
00:18:59,000 --> 00:19:01,000
以外的一個整數中的比特數，

266
00:19:01,000 --> 00:19:04,000
那麼這個1是要最終會關閉。

267
00:19:04,000 --> 00:19:10,000
這是唯一的擔心，如果你碰巧要處理的非常大的能力。

268
00:19:10,000 --> 00:19:15,000
但在這一點，那麼你正在處理的數組數十億美元的東西，

269
00:19:15,000 --> 00:19:25,000
可能不適合到內存中了。

270
00:19:25,000 --> 00:19:31,000
>> 現在，我們可以得到流行，這是更容易。

271
00:19:31,000 --> 00:19:36,000
你可以不喜歡，如果你碰巧彈出一大堆，

272
00:19:36,000 --> 00:19:38,000
現在你的一半容量。

273
00:19:38,000 --> 00:19:42,000
你可以realloc的縮小的內存量，

274
00:19:42,000 --> 00:19:47,000
但你不必擔心，所以只有realloc的情況下，將是

275
00:19:47,000 --> 00:19:50,000
日益增長的記憶，永遠不會萎縮的內存，

276
00:19:50,000 --> 00:19:59,000
這是會彈出超級簡單的。

277
00:19:59,000 --> 00:20:02,000
現在要像棧，隊列，

278
00:20:02,000 --> 00:20:06,000
但順序是相反的，你拿東西出來。

279
00:20:06,000 --> 00:20:10,000
隊列中的典型例子是一條線，

280
00:20:10,000 --> 00:20:12,000
所以我想，如果你是英語，我會說

281
00:20:12,000 --> 00:20:17,000
一個典型的例子是一個隊列的隊列。

282
00:20:17,000 --> 00:20:22,000
因此，像一條線，如果你是行的第一人，

283
00:20:22,000 --> 00:20:24,000
您期望成為第一個出列的人。

284
00:20:24,000 --> 00:20:31,000
如果你是行的最後一個人，你會是最後一個人服務。

285
00:20:31,000 --> 00:20:35,000
我們稱之為FIFO模式，而堆棧是後進先出法的模式。

286
00:20:35,000 --> 00:20:40,000
這些話是非常普遍的。

287
00:20:40,000 --> 00:20:46,000
>> 就像棧和，不像數組，隊列通常不允許在中間的元素。

288
00:20:46,000 --> 00:20:50,000
在這裡，我們有一個堆棧，push和pop。

289
00:20:50,000 --> 00:20:54,000
在這裡，我們碰巧召他們入隊和出隊。

290
00:20:54,000 --> 00:20:58,000
我也聽到他們叫shift和unshift。

291
00:20:58,000 --> 00:21:02,000
我已經聽到有人說push和pop也適用於隊列。

292
00:21:02,000 --> 00:21:05,000
我聽說插入，刪除，

293
00:21:05,000 --> 00:21:11,000
所以push和pop，如果你正在談論有關棧，入棧和出棧。

294
00:21:11,000 --> 00:21:16,000
如果你說的隊列，你可以選擇你要使用的話

295
00:21:16,000 --> 00:21:23,000
插入和刪除，是應該叫什麼沒有達成共識。

296
00:21:23,000 --> 00:21:27,000
但在這裡，我們有入隊和出隊。

297
00:21:27,000 --> 00:21:37,000
現在，該結構看起來幾乎相同的堆棧結構。

298
00:21:37,000 --> 00:21:40,000
但是，我們必須跟踪頭。

299
00:21:40,000 --> 00:21:44,000
我想在這裡說的，但為什麼我們需要的頭嗎？

300
00:21:53,000 --> 00:21:57,000
的原型基本上是相同的push和pop。

301
00:21:57,000 --> 00:21:59,000
你可以把它看成push和pop。

302
00:21:59,000 --> 00:22:08,000
唯一的區別是彈出的返回，而不是最後的，它的第一個返回。

303
00:22:08,000 --> 00:22:12,000
2，1，3，4，或東西。

304
00:22:12,000 --> 00:22:14,000
這裡的開始。

305
00:22:14,000 --> 00:22:17,000
我們的隊列已經完全滿了，所以有四個元素在裡面。

306
00:22:17,000 --> 00:22:21,000
結束我們的隊列當前為2，

307
00:22:21,000 --> 00:22:24,000
現在我們去插入別的東西。

308
00:22:24,000 --> 00:22:29,000
>> 當我們要插入其他的東西，我們所做的堆棧版本

309
00:22:29,000 --> 00:22:36,000
是我們擴大了我們的內存塊。

310
00:22:36,000 --> 00:22:40,000
這個是什麼問題呢？

311
00:22:40,000 --> 00:22:45,000
[學生]：你提出的2。

312
00:22:45,000 --> 00:22:51,000
我說的隊列結束前，

313
00:22:51,000 --> 00:22:57,000
這沒有任何意義，我們開始為1，

314
00:22:57,000 --> 00:23:01,000
然後，我們要出列1，然後出隊，出隊4

315
00:23:01,000 --> 00:23:05,000
然後出列，然後出列，這一個。

316
00:23:05,000 --> 00:23:08,000
我們現在不能使用realloc，

317
00:23:08,000 --> 00:23:11,000
最起碼，你有，使用realloc以不同的方式。

318
00:23:11,000 --> 00:23:15,000
但你可能不應該只是使用realloc。

319
00:23:15,000 --> 00:23:18,000
你將必須手動複製你的記憶。

320
00:23:18,000 --> 00:23:21,000
>> 有兩個函數複製內存。

321
00:23:21,000 --> 00:23:25,000
有存儲器複製和memmove。

322
00:23:25,000 --> 00:23:29,000
我目前正在讀，看看哪一個你將要使用的手冊頁。

323
00:23:29,000 --> 00:23:35,000
好了，存儲器複製，不同的是

324
00:23:35,000 --> 00:23:38,000
存儲器複製和memmove，而正確處理的情況下

325
00:23:38,000 --> 00:23:41,000
您在何處複製到一個區域發生重疊的區域

326
00:23:41,000 --> 00:23:46,000
你複製。

327
00:23:46,000 --> 00:23:50,000
存儲器複製不處理。 Memmove。

328
00:23:50,000 --> 00:23:59,000
你能想到的問題，

329
00:23:59,000 --> 00:24:09,000
比方說，我要複製這個傢伙，

330
00:24:09,000 --> 00:24:13,000
這四個這傢伙過來。

331
00:24:13,000 --> 00:24:16,000
最後，該數組應該像

332
00:24:16,000 --> 00:24:26,000
後的副本是2，1，2，1，3，4，然後在最後的一些東西。

333
00:24:26,000 --> 00:24:29,000
但是，這是依賴於複製的順序，

334
00:24:29,000 --> 00:24:32,000
因為如果我們不考慮該地區的事實，我們複製到

335
00:24:32,000 --> 00:24:35,000
我們複製重疊，

336
00:24:35,000 --> 00:24:46,000
然後，我們可能不喜歡開始，在這裡，我們想要去的地方複製2，

337
00:24:46,000 --> 00:24:52,000
然後將指針向前發展。

338
00:24:52,000 --> 00:24:56,000
>> 現在，我們要在這裡和這裡，現在我們要複製

339
00:24:56,000 --> 00:25:04,000
這傢伙在這個傢伙的指針向前移動。

340
00:25:04,000 --> 00:25:07,000
我們將最終得到的是2，1，2，1，2，1

341
00:25:07,000 --> 00:25:10,000
而不是在適當的2，1，2，1，3，4，因為

342
00:25:10,000 --> 00:25:15,000
2，推翻了原來的3，4。

343
00:25:15,000 --> 00:25:19,000
Memmove處理是正確的。

344
00:25:19,000 --> 00:25:23,000
在這種情況下，基本上只是使用memmove

345
00:25:23,000 --> 00:25:26,000
因為它處理是正確的。

346
00:25:26,000 --> 00:25:29,000
它一般不執行任何惡化。

347
00:25:29,000 --> 00:25:32,000
我們的想法是開始，而不是從一開始就複製這種方式

348
00:25:32,000 --> 00:25:35,000
就像我們剛剛在這裡做的，從去年底開始和複製，

349
00:25:35,000 --> 00:25:38,000
在這種情況下，你可以永遠不會有問題。

350
00:25:38,000 --> 00:25:40,000
有沒有性能上的丟失。

351
00:25:40,000 --> 00:25:47,000
請務必使用memmove。再也不用擔心存儲器複製。

352
00:25:47,000 --> 00:25:51,000
這就是你要去的地方有單獨memmove

353
00:25:51,000 --> 00:26:01,000
包裹的部分，您的隊列。

354
00:26:01,000 --> 00:26:04,000
不用擔心，如果沒有完全做到。

355
00:26:04,000 --> 00:26:10,000
這是更加困難比棧，推，和流行。

356
00:26:10,000 --> 00:26:15,000
>> 任何人有任何的代碼，我們可以使用？

357
00:26:15,000 --> 00:26:21,000
即使完全不完整？

358
00:26:21,000 --> 00:26:23,000
[學生]：是的，這是完全不完整的，雖然。

359
00:26:23,000 --> 00:26:27,000
完全不完全是罰款，只要我們能為您節省修訂？

360
00:26:27,000 --> 00:26:32,000
我忘了，每一次。

361
00:26:32,000 --> 00:26:39,000
好了，忽略了會發生什麼，當我們需要調整的東西。

362
00:26:39,000 --> 00:26:42,000
完全忽略調整大小。

363
00:26:42,000 --> 00:26:49,000
解釋一下這段代碼。

364
00:26:49,000 --> 00:26:54,000
我首先檢查如果尺寸小於首先複印

365
00:26:54,000 --> 00:27:01,000
，然後在那之後，我將我頭+大小，

366
00:27:01,000 --> 00:27:05,000
我要確保它環繞的數組的容量，

367
00:27:05,000 --> 00:27:08,000
我在該位置插入新的字符串。

368
00:27:08,000 --> 00:27:12,000
然後我增加的大小，並返回true。

369
00:27:12,000 --> 00:27:22,000
>> 羅布B.]這是肯定的情況下，你會希望使用的模之一。

370
00:27:22,000 --> 00:27:25,000
任何一種情況下，你已經環繞著，如果你認為周圍包裹，

371
00:27:25,000 --> 00:27:29,000
馬上想到的應該是MOD。

372
00:27:29,000 --> 00:27:36,000
作為一個快速優化/較短的一行代碼，

373
00:27:36,000 --> 00:27:42,000
您發現該行緊隨

374
00:27:42,000 --> 00:27:53,000
只是大小+ +，所以你合併入這行，大小+ +。

375
00:27:53,000 --> 00:27:58,000
在這裡，我們的情況下，

376
00:27:58,000 --> 00:28:01,000
我們沒有足夠的內存，

377
00:28:01,000 --> 00:28:05,000
所以我們提高我們的能力，2。

378
00:28:05,000 --> 00:28:09,000
我想你可以在這裡有同樣的問題，但現在我們可以忽略它，

379
00:28:09,000 --> 00:28:13,000
其中，如果你沒有提高你的能力，

380
00:28:13,000 --> 00:28:18,000
然後，你會想，以減少你的能力，2。

381
00:28:18,000 --> 00:28:24,000
另一個短值得注意的是，就像你可以做+ =，

382
00:28:24,000 --> 00:28:30,000
你也可以做<< =。

383
00:28:30,000 --> 00:28:43,000
前平等，幾乎什麼都可以去，+ =，| =，＆=，<< =。

384
00:28:43,000 --> 00:28:52,000
新的char *是我們的新的內存塊。

385
00:28:52,000 --> 00:28:55,000
哦，在這裡。

386
00:28:55,000 --> 00:29:02,000
>> 人怎麼看我們的新的內存塊的類型嗎？

387
00:29:02,000 --> 00:29:06,000
[學生]：應該是char **。

388
00:29:06,000 --> 00:29:12,000
回想我們的結構在這裡，

389
00:29:12,000 --> 00:29:14,000
字符串是什麼，我們重新分配。

390
00:29:14,000 --> 00:29:21,000
我們正在一個全新的動態存儲在隊列中的元素。

391
00:29:21,000 --> 00:29:25,000
我們要分配給你的字符串就是我們mallocing的，現在，

392
00:29:25,000 --> 00:29:30,000
等新的將是一個char **。

393
00:29:30,000 --> 00:29:34,000
這將是一個字符串數組。

394
00:29:34,000 --> 00:29:38,000
那麼，是什麼的情況下，我們要返回false？

395
00:29:38,000 --> 00:29:41,000
[學生]：我們應該做的char *？

396
00:29:41,000 --> 00:29:44,000
羅布B.]是的，良好的通話。

397
00:29:44,000 --> 00:29:46,000
[學生]：那是什麼？

398
00:29:46,000 --> 00:29:49,000
[羅布B.我們想要做的char *的大小，因為我們不再是

399
00:29:49,000 --> 00:29:53,000
這實際上是一個很大的問題，因為大小（字符）將是1。

400
00:29:53,000 --> 00:29:55,000
SIZEOF的char * 4，

401
00:29:55,000 --> 00:29:58,000
所以很多時候，你正在處理int類型，

402
00:29:58,000 --> 00:30:01,000
你會得到它，因為尺寸大小的int * int和

403
00:30:01,000 --> 00:30:04,000
在32位的系統將是同樣的事情。

404
00:30:04,000 --> 00:30:09,000
但在這裡，大小（字符）和sizeof（CHAR *）現在將是同樣的事情。

405
00:30:09,000 --> 00:30:15,000
>> 在我們返回false是什麼情況？

406
00:30:15,000 --> 00:30:17,000
[學生]是空的。

407
00:30:17,000 --> 00:30:23,000
是的，如果新為空，則返回FALSE，

408
00:30:23,000 --> 00:30:34,000
我要在這裡摔倒

409
00:30:34,000 --> 00:30:37,000
[學生] [聽不清]

410
00:30:37,000 --> 00:30:39,000
羅布B.]是啊，這是好的。

411
00:30:39,000 --> 00:30:46,000
你既可以做2次，容量或容量移1，然後將其設置或任何。

412
00:30:46,000 --> 00:30:52,000
我們會做到這一點，因為我們有它。

413
00:30:52,000 --> 00:30:56,000
容量>> = 1。

414
00:30:56,000 --> 00:31:08,000
你永遠不會有擔心失去的地方

415
00:31:08,000 --> 00:31:12,000
因為你左移1，所以1的地方必然是一個0，

416
00:31:12,000 --> 00:31:16,000
所以右移1，你仍然會好起來的。

417
00:31:16,000 --> 00:31:19,000
[學生]：你需要做的是在返回之前？

418
00:31:19,000 --> 00:31:29,000
羅布B.是的，這使得完全沒有意義。

419
00:31:29,000 --> 00:31:36,000
>> 現在假設我們要最終結束返回true。

420
00:31:36,000 --> 00:31:39,000
方式我們要做這些memmoves的，

421
00:31:39,000 --> 00:31:45,000
我們必須要小心我們如何做。

422
00:31:45,000 --> 00:31:50,000
沒有任何人有任何建議，我們如何做？

423
00:32:17,000 --> 00:32:21,000
下面是我們的開始。

424
00:32:21,000 --> 00:32:28,000
不可避免的是，我們要再次從頭開始

425
00:32:28,000 --> 00:32:35,000
和從那裡複製的東西，1，3，4，2。

426
00:32:35,000 --> 00:32:41,000
你是怎麼做到的呢？

427
00:32:41,000 --> 00:32:52,000
首先，我必須看的手冊頁memmove。

428
00:32:52,000 --> 00:32:57,000
memmove，而參數的順序是非常重要的。

429
00:32:57,000 --> 00:33:01,000
我們希望我們的目標首先，源第二，規模第三。

430
00:33:01,000 --> 00:33:06,000
有很多扭轉源和目標的功能。

431
00:33:06,000 --> 00:33:11,000
目標，源往往有些是一致的。

432
00:33:17,000 --> 00:33:21,000
移動，它返回的是什麼？

433
00:33:21,000 --> 00:33:27,000
它返回一個指針到目的地，不管是什麼原因，你可能想。

434
00:33:27,000 --> 00:33:32,000
我能想像讀它，但我們要進入我們的目的地。

435
00:33:32,000 --> 00:33:35,000
>> 什麼是我們的目標又如何呢？

436
00:33:35,000 --> 00:33:37,000
[學生]。

437
00:33:37,000 --> 00:33:39,000
羅布B.是的，和我們複製的呢？

438
00:33:39,000 --> 00:33:43,000
我們要複印的第一件事情是這樣的1，3，4。

439
00:33:43,000 --> 00:33:50,000
這是-1，3，4。

440
00:33:50,000 --> 00:33:55,000
這地址是什麼？

441
00:33:55,000 --> 00:33:58,000
這1的地址是什麼？

442
00:33:58,000 --> 00:34:01,000
[學生] [聽不清]

443
00:34:01,000 --> 00:34:03,000
[羅布B.]頭+的第一個元素的地址。

444
00:34:03,000 --> 00:34:05,000
我們怎樣才能在數組的第一個元素？

445
00:34:05,000 --> 00:34:10,000
[學生]：隊列中。

446
00:34:10,000 --> 00:34:15,000
羅布B.]是的，q.strings。

447
00:34:15,000 --> 00:34:20,000
請記住，在這裡，我們的頭是1。

448
00:34:20,000 --> 00:34:24,000
織補它。我只是覺得這是奇蹟般地

449
00:34:24,000 --> 00:34:29,000
在這裡，我們的頭是1。我要改變我的顏色。

450
00:34:29,000 --> 00:34:36,000
這裡是字符串。

451
00:34:36,000 --> 00:34:41,000
這一點，我們可以把它寫在這裡我們做了

452
00:34:41,000 --> 00:34:43,000
用頭+ q.strings。

453
00:34:43,000 --> 00:34:51,000
很多人也寫它與q.strings的頭。

454
00:34:51,000 --> 00:34:55,000
這是不是真的任何效率不高。

455
00:34:55,000 --> 00:34:58,000
你可能會認為它為您提領，然後得到的地址，

456
00:34:58,000 --> 00:35:04,000
但編譯器將它翻譯成我們以前的事，反正，q.strings +頭。

457
00:35:04,000 --> 00:35:06,000
無論哪種方式，你要考慮它。

458
00:35:06,000 --> 00:35:11,000
>> 我們要複製多少字節？

459
00:35:11,000 --> 00:35:15,000
[學生]：能力 - 頭。

460
00:35:15,000 --> 00:35:18,000
能力 - 頭。

461
00:35:18,000 --> 00:35:21,000
然後你就可以一直寫的一個例子

462
00:35:21,000 --> 00:35:23,000
搞清楚，如果這是正確的。

463
00:35:23,000 --> 00:35:26,000
[學生]：它需要除以2，然後。

464
00:35:26,000 --> 00:35:30,000
是啊，所以我想我們可以使用大小。

465
00:35:30,000 --> 00:35:35,000
我們仍然有大小，

466
00:35:35,000 --> 00:35:39,000
使用大小，我們有大小等於4。

467
00:35:39,000 --> 00:35:42,000
我們的規模是4。我們的頭是1。

468
00:35:42,000 --> 00:35:46,000
我們要複製這3個元素。

469
00:35:46,000 --> 00:35:54,000
這就是合理性檢查，尺寸 - 是正確的3頭。

470
00:35:54,000 --> 00:35:58,000
回來這裡，就像我們之前說的，

471
00:35:58,000 --> 00:36:00,000
如果我們使用的能力，那麼我們就必須除以2

472
00:36:00,000 --> 00:36:04,000
因為我們已經長大了我們的能力，所以不是，我們會使用大小。

473
00:36:11,000 --> 00:36:13,000
副本的那部分。

474
00:36:13,000 --> 00:36:18,000
現在，我們需要複製的其他部分，剩下的部分開始。

475
00:36:18,000 --> 00:36:28,000
>> 這是怎麼回事memmove到什麼位置？

476
00:36:28,000 --> 00:36:32,000
[學生]：加上大小 - 頭。

477
00:36:32,000 --> 00:36:38,000
是的，所以我們已經複製的大小 - 頭字節，

478
00:36:38,000 --> 00:36:43,000
，所以在這裡我們要複製剩餘的字節是新的

479
00:36:43,000 --> 00:36:48,000
然後大小負好，我們的字節數已經複製英寸

480
00:36:48,000 --> 00:36:52,000
然後我們複製的呢？

481
00:36:52,000 --> 00:36:54,000
[學生]：Q.strings [0]。

482
00:36:54,000 --> 00:36:56,000
羅布B.]是的，q.strings。

483
00:36:56,000 --> 00:37:02,000
我們可以做和的q.strings [0]。

484
00:37:02,000 --> 00:37:05,000
這是比這明顯不太常見。

485
00:37:05,000 --> 00:37:14,000
如果它只是為0，然後你會傾向於看q.strings。

486
00:37:14,000 --> 00:37:16,000
這就是我們正在複製。

487
00:37:16,000 --> 00:37:18,000
多少個字節我們還剩下複製？>> [學生]：10。

488
00:37:18,000 --> 00:37:20,000
右。

489
00:37:20,000 --> 00:37:25,000
[學生]：我們要乘5  -  10倍的大小的字節或什麼的？

490
00:37:25,000 --> 00:37:30,000
是啊，所以這是究竟是什麼，我們複製嗎？

491
00:37:30,000 --> 00:37:32,000
[學生] [聽不清]

492
00:37:32,000 --> 00:37:34,000
我們在複製的東西的類型是什麼呢？

493
00:37:34,000 --> 00:37:36,000
[學生] [聽不清]

494
00:37:36,000 --> 00:37:41,000
是啊，這樣的char *，我們複製，我們不知道那些來自。

495
00:37:41,000 --> 00:37:47,000
好了，他們指著，像琴弦，我們最終將其推到隊列中

496
00:37:47,000 --> 00:37:49,000
或到隊列中進行排隊。

497
00:37:49,000 --> 00:37:51,000
如果這些都來自我們不知道。

498
00:37:51,000 --> 00:37:56,000
我們只需要跟踪的char *自己。

499
00:37:56,000 --> 00:38:00,000
我們不希望複製的大小 - 頭字節。

500
00:38:00,000 --> 00:38:03,000
我們要複製的大小 - 頭的char *，

501
00:38:03,000 --> 00:38:11,000
所以，我們要乘這個大小（char *）的。

502
00:38:11,000 --> 00:38:17,000
在這裡，頭*大小（CHAR *）。

503
00:38:17,000 --> 00:38:24,000
>> [學生]：怎麼樣[聽不見的？

504
00:38:24,000 --> 00:38:26,000
這項權利在這裡嗎？

505
00:38:26,000 --> 00:38:28,000
[學生]，下面的大小 - 頭。

506
00:38:28,000 --> 00:38:30,000
羅布B.這項權利在這裡嗎？

507
00:38:30,000 --> 00:38:32,000
指針的算術運算。

508
00:38:32,000 --> 00:38:35,000
指針運算是如何去上班

509
00:38:35,000 --> 00:38:40,000
它會自動將的類型，我們正在處理的大小。

510
00:38:40,000 --> 00:38:46,000
就像在這裡，新+（大小 - 頭）

511
00:38:46,000 --> 00:38:56,000
是完全等同於和新的大小 - 頭]

512
00:38:56,000 --> 00:39:00,000
直到我們預計正常工作，

513
00:39:00,000 --> 00:39:04,000
因為如果我們要處理的一個int數組，然後我們不要索引的INT-

514
00:39:04,000 --> 00:39:07,000
如果它的大小為5，和你想的第4個元素，然後我們索引

515
00:39:07,000 --> 00:39:10,000
int數組[4]。

516
00:39:10,000 --> 00:39:14,000
你不 -  [4] *大小的int。

517
00:39:14,000 --> 00:39:21,000
來處理它，這種情況下自動

518
00:39:21,000 --> 00:39:29,000
簡直是等同的，所以括號的語法

519
00:39:29,000 --> 00:39:34,000
只是要轉換為只要你編譯。

520
00:39:34,000 --> 00:39:38,000
這件事情你需要小心

521
00:39:38,000 --> 00:39:42,000
當你加入的大小 - 頭

522
00:39:42,000 --> 00:39:45,000
你是不是一個字節。

523
00:39:45,000 --> 00:39:53,000
您要添加一個char *，它可以是一個字節或什麼的。

524
00:39:53,000 --> 00:39:56,000
>> 其他問題嗎？

525
00:39:56,000 --> 00:40:04,000
好了，出隊會更容易。

526
00:40:04,000 --> 00:40:11,000
我給你一分鐘的時間來實現。

527
00:40:11,000 --> 00:40:18,000
哦，我想這也是同樣的情況

528
00:40:18,000 --> 00:40:21,000
排隊的情況下，如果我們入隊空，

529
00:40:21,000 --> 00:40:24,000
也許我們要處理它，也許我們不這樣做。

530
00:40:24,000 --> 00:40:27,000
我們不會再在這裡，但我們的堆棧情況下相同。

531
00:40:27,000 --> 00:40:34,000
如果我們加入隊列為空，我們可能要忽略它。

532
00:40:34,000 --> 00:40:40,000
任何人有一些代碼，我可以拉起來嗎？

533
00:40:40,000 --> 00:40:45,000
[學生]：我只是出隊。

534
00:40:45,000 --> 00:40:56,000
第2版​​是沒事。

535
00:40:56,000 --> 00:40:59,000
你想說明什麼？

536
00:40:59,000 --> 00:41:01,000
[學生]：首先，你要確定有什麼東西在隊列中

537
00:41:01,000 --> 00:41:07,000
而且其大小是由1。

538
00:41:07,000 --> 00:41:11,000
你需要做的，然後返回頭

539
00:41:11,000 --> 00:41:13,000
然後將頭1。

540
00:41:13,000 --> 00:41:19,000
好了，所以我們必須考慮的一個角落的情況。是啊。

541
00:41:19,000 --> 00:41:24,000
[學生]：如果你的頭是在最後一個元素，

542
00:41:24,000 --> 00:41:26,000
然後，你不想頭指向陣列外。

543
00:41:26,000 --> 00:41:29,000
>> 是啊，所以只要頭打我們的陣列，

544
00:41:29,000 --> 00:41:35,000
我們出列的時候，我們的頭被改裝為0。

545
00:41:35,000 --> 00:41:40,000
不幸的是，我們不能做到這一點的一個步驟。

546
00:41:40,000 --> 00:41:44,000
我想我可能會解決它是

547
00:41:44,000 --> 00:41:52,000
這是怎麼回事，我們正在返回，是一個char *

548
00:41:52,000 --> 00:41:55,000
無論你的變量名要。

549
00:41:55,000 --> 00:42:02,000
然後，我們希望我們的能力，國防部頭

550
00:42:02,000 --> 00:42:10,000
然後返回漚。

551
00:42:10,000 --> 00:42:14,000
很多人在這裡，他們可能會做

552
00:42:14,000 --> 00:42:19,000
這種情況下，您看人家做頭

553
00:42:19,000 --> 00:42:29,000
大於產能，做頭 - 能力。

554
00:42:29,000 --> 00:42:36,000
而這僅僅是解決mod是什麼。

555
00:42:36,000 --> 00:42:41,000
頭模能力是乾淨多了

556
00:42:41,000 --> 00:42:51,000
一個周圍環繞的比大於容量頭 - 能力，如果頭。

557
00:42:51,000 --> 00:42:56,000
>> 有問題嗎？

558
00:42:56,000 --> 00:43:02,000
好了，我們剩下的最後一件事是我們的鍊錶。

559
00:43:02,000 --> 00:43:07,000
你可能會使用一些鍊錶行為，如果你沒有

560
00:43:07,000 --> 00:43:11,000
在哈希表，鍊錶，如果你做了一個哈希表。

561
00:43:11,000 --> 00:43:15,000
我強烈建議做一個哈希表。

562
00:43:15,000 --> 00:43:17,000
您可能已經做了特里，

563
00:43:17,000 --> 00:43:23,000
但嘗試都比較困難。

564
00:43:23,000 --> 00:43:27,000
從理論上講，他們是漸近更好。

565
00:43:27,000 --> 00:43:30,000
但就在大板，

566
00:43:30,000 --> 00:43:35,000
並嘗試從來沒有做的更好，，他們佔用更多的內存。

567
00:43:35,000 --> 00:43:43,000
一切有關嘗試最終被更多的工作差。

568
00:43:43,000 --> 00:43:49,000
這是大衛·馬蘭的解決方案始終是

569
00:43:49,000 --> 00:43:56,000
是他的帖子他的特里的解決方案，讓我們來看看他目前是。

570
00:43:56,000 --> 00:44:00,000
他是幹什麼的“，DAVID J？

571
00:44:00,000 --> 00:44:06,000
他是第18，所以這不是差得要命，

572
00:44:06,000 --> 00:44:09,000
，這將是一個最好的嘗試，你能想到的

573
00:44:09,000 --> 00:44:17,000
或一個最好的嘗試的線索。

574
00:44:17,000 --> 00:44:23,000
這難道不是他原來的解決方案嗎？

575
00:44:23,000 --> 00:44:29,000
我覺得，像特里解決方案更傾向於在此範圍內的內存使用。

576
00:44:29,000 --> 00:44:33,000
>> 你下到最高層，和RAM的使用是在個位數。

577
00:44:33,000 --> 00:44:36,000
向下朝下方，然後你開始看到試圖

578
00:44:36,000 --> 00:44:41,000
你在哪裡得到絕對使用大量的RAM，

579
00:44:41,000 --> 00:44:45,000
嘗試都比較困難。

580
00:44:45,000 --> 00:44:53,000
不完全是值得的，但教育經驗，如果你沒有一個。

581
00:44:53,000 --> 00:44:56,000
最後一點是我們的鏈接列表，

582
00:44:56,000 --> 00:45:04,000
，這三個東西，棧，隊列，鍊錶，

583
00:45:04,000 --> 00:45:09,000
你做的任何未來的事情在計算機科學

584
00:45:09,000 --> 00:45:12,000
假設你熟悉這些東西。

585
00:45:12,000 --> 00:45:19,000
他們只不過是一切的根本。

586
00:45:19,000 --> 00:45:25,000
>> 鏈接列表，在這裡我們有一個單鍊錶，將是我們實現。

587
00:45:25,000 --> 00:45:34,000
什麼是單鍊錶，雙向鍊錶的意思，而不是？是。

588
00:45:34,000 --> 00:45:37,000
[學生]：只點到下一個指針，而不是指針，

589
00:45:37,000 --> 00:45:39,000
像一個前它和它的一前一後。

590
00:45:39,000 --> 00:45:44,000
是啊，所以在圖片格式上，我只是做嗎？

591
00:45:44,000 --> 00:45:48,000
我有兩件事。我有圖片，圖片。

592
00:45:48,000 --> 00:45:51,000
在圖片格式上，我們的單鍊錶，

593
00:45:51,000 --> 00:45:57,000
不可避免地，我們有我們的列表的頭指針種，

594
00:45:57,000 --> 00:46:02,000
然後在我們的名單，我們只是有三分球，

595
00:46:02,000 --> 00:46:05,000
也許這點為空。

596
00:46:05,000 --> 00:46:08,000
這將是一個單向鍊錶的典型示意圖。

597
00:46:08,000 --> 00:46:14,000
一個雙向鍊錶，你可以倒著走。

598
00:46:14,000 --> 00:46:19,000
如果我給你列表中的任何一個節點，那麼你就一定能獲得

599
00:46:19,000 --> 00:46:23,000
列表中的任何其他節點，如果它是一個雙向鍊錶。

600
00:46:23,000 --> 00:46:27,000
但是，如果我讓你在列表中的第三個節點，這是一個單向鍊錶，

601
00:46:27,000 --> 00:46:30,000
沒有辦法，你對你將要得到的第一個和第二個節點。

602
00:46:30,000 --> 00:46:34,000
有利弊，一個明顯的例子

603
00:46:34,000 --> 00:46:42,000
是你採取了更多的大小，和你有這些東西現在都指向跟踪。

604
00:46:42,000 --> 00:46:49,000
但是，我們只關心單鍊錶的。

605
00:46:49,000 --> 00:46:53,000
>> 有幾件事情，我們將不得不實行。

606
00:46:53,000 --> 00:47:00,000
你的typedef結構節點，INT I：結構節點下;節點。

607
00:47:00,000 --> 00:47:09,000
該typedef應燒入你的心。

608
00:47:09,000 --> 00:47:14,000
測驗1應該是這樣的一個typedef一個鍊錶節點，

609
00:47:14,000 --> 00:47:18,000
你應該能夠立即潦草下來

610
00:47:18,000 --> 00:47:22,000
甚至沒有考慮它。

611
00:47:22,000 --> 00:47:27,000
我猜一對夫婦的問題，為什麼我們需要結構的嗎？

612
00:47:27,000 --> 00:47:32,000
我們為什麼不能說的節點*？

613
00:47:32,000 --> 00:47:35,000
[學生] [聽不清]

614
00:47:35,000 --> 00:47:38,000
是啊。

615
00:47:38,000 --> 00:47:44,000
定義了一個節點的唯一的事情

616
00:47:44,000 --> 00:47:47,000
是typedef本身。

617
00:47:47,000 --> 00:47:55,000
但是這一點，當我們種的解析通過這個結構節點定義，

618
00:47:55,000 --> 00:48:01,000
我們還沒有完成我們的typedef，因為typedef還沒有完成，

619
00:48:01,000 --> 00:48:05,000
節點不存在。

620
00:48:05,000 --> 00:48:12,000
但結構節點呢，這個節點在這裡，

621
00:48:12,000 --> 00:48:14,000
這也可以被稱為什麼都重要。

622
00:48:14,000 --> 00:48:16,000
這可以被稱為n。

623
00:48:16,000 --> 00:48:19,000
它可以被稱為鍊錶的節點。

624
00:48:19,000 --> 00:48:21,000
它可以被稱為什麼。

625
00:48:21,000 --> 00:48:26,000
但是，這需要調用同樣的事情，這個結構節點結構節點。

626
00:48:26,000 --> 00:48:29,000
你也可以在這裡，

627
00:48:29,000 --> 00:48:32,000
等還回答了第二點的問題

628
00:48:32,000 --> 00:48:37,000
這就是為什麼有很多的時候，你看到的結構和類型定義的結構體，

629
00:48:37,000 --> 00:48:42,000
你會看到匿名結構的話，你會看到typedef結構，

630
00:48:42,000 --> 00:48:47,000
實施結構，字典，或其他。

631
00:48:47,000 --> 00:48:51,000
>> 為什麼我們在這裡需要說的節點？

632
00:48:51,000 --> 00:48:54,000
為什麼不能是一個匿名的結構？

633
00:48:54,000 --> 00:48:56,000
這幾乎是同樣的回答。

634
00:48:56,000 --> 00:48:58,000
[學生]：您需要在struct來引用它。

635
00:48:58,000 --> 00:49:04,000
是啊，在結構，你需要參考的結構本身。

636
00:49:04,000 --> 00:49:10,000
如果你不給結構體的名稱，如果它是一個匿名的結構，你可以不引用它。

637
00:49:10,000 --> 00:49:17,000
最後，但並非最不重要的，這些都應該是有些簡單的，

638
00:49:17,000 --> 00:49:20,000
他們應該幫助你實現，如果你寫下來

639
00:49:20,000 --> 00:49:24,000
你做錯了什麼，如果這些事情是沒有意義的。

640
00:49:24,000 --> 00:49:28,000
最後但並非最不重要的一點是，為什麼會發生這種結構節點*？

641
00:49:28,000 --> 00:49:34,000
為什麼它不能只是結構的節點嗎？

642
00:49:34,000 --> 00:49:37,000
[學生]：到下一個結構體的指針。

643
00:49:37,000 --> 00:49:39,000
這是不可避免的，我們想要的東西。

644
00:49:39,000 --> 00:49:42,000
為什麼它永遠不會是結構節點下？

645
00:49:42,000 --> 00:49:50,000
為什麼有是結構節點下的嗎？是啊。

646
00:49:50,000 --> 00:49:53,000
[學生]：這是一個無限循環。

647
00:49:53,000 --> 00:49:55,000
是啊。

648
00:49:55,000 --> 00:49:57,000
[學生]：這將是中的一個。

649
00:49:57,000 --> 00:50:02,000
是啊，就認為我們將如何做大小或東西。

650
00:50:02,000 --> 00:50:08,000
一個結構的大小基本上是+或 - 在這裡或那裡一些模式。

651
00:50:08,000 --> 00:50:15,000
它基本上是要的事情，在結構尺寸的總和。

652
00:50:15,000 --> 00:50:18,000
不改變任何東西，在這裡，大小是一件容易的事。

653
00:50:18,000 --> 00:50:24,000
結構節點的大小將是大小的i +尺寸的未來。

654
00:50:24,000 --> 00:50:27,000
的i的大小將是4。下次的大小將是4。

655
00:50:27,000 --> 00:50:30,000
結構節點的大小將是8。

656
00:50:30,000 --> 00:50:34,000
如果我們不*，思維的sizeof

657
00:50:34,000 --> 00:50:37,000
然後大小（ⅰ）將是4。

658
00:50:37,000 --> 00:50:43,000
結構節點的大小未來將是結構節點下的大小為I +大小

659
00:50:43,000 --> 00:50:46,000
+我+尺寸的結構節點下的大小。

660
00:50:46,000 --> 00:50:55,000
這將是一個無限遞歸的節點。

661
00:50:55,000 --> 00:51:00,000
這就是為什麼這是怎麼會事必須的。

662
00:51:00,000 --> 00:51:03,000
>> 再次，一定記住，

663
00:51:03,000 --> 00:51:06,000
或至少​​理解不夠，你可以可以

664
00:51:06,000 --> 00:51:12,000
通過它看起來應該像什麼原因。

665
00:51:12,000 --> 00:51:14,000
我們將要實現的事情。

666
00:51:14,000 --> 00:51:18,000
如果列表長度

667
00:51:18,000 --> 00:51:21,000
你可以欺騙，並保持周圍

668
00:51:21,000 --> 00:51:24,000
全球的長度或東西，但我們不打算這樣做。

669
00:51:24,000 --> 00:51:28,000
我們要算列表的長度。

670
00:51:28,000 --> 00:51:34,000
我們已經包含，所以這基本上是一樣的搜索，

671
00:51:34,000 --> 00:51:41,000
所以我們有一個鍊錶的整數，如果這個整數鍊錶中。

672
00:51:41,000 --> 00:51:44,000
前面加上要插入在列表的開頭。

673
00:51:44,000 --> 00:51:46,000
附加將要插入的結束。

674
00:51:46,000 --> 00:51:53,000
Insert_sorted要插入排序列表中的位置。

675
00:51:53,000 --> 00:52:01,000
Insert_sorted種假設你從來沒有使用前置或附加在惡劣的方式。

676
00:52:01,000 --> 00:52:09,000
>> 當你實施Insert_sorted insert_sorted  - 

677
00:52:09,000 --> 00:52:13,000
比方說，我們有我們的鍊錶。

678
00:52:13,000 --> 00:52:18,000
這是它目前看起來，2，4，5。

679
00:52:18,000 --> 00:52:24,000
我想插入3個，所以只要已排序的列表本身，

680
00:52:24,000 --> 00:52:27,000
可以很容易地發現其中3屬於。

681
00:52:27,000 --> 00:52:29,000
我從2開始。

682
00:52:29,000 --> 00:52:32,000
好了，3是大於2的，所以我想繼續下去。

683
00:52:32,000 --> 00:52:35,000
哦，是太大了，所以我知道要在2至4，

684
00:52:35,000 --> 00:52:39,000
我有固定的指針和所有的東西。

685
00:52:39,000 --> 00:52:43,000
但是，如果我們沒有嚴格使用insert_sorted，

686
00:52:43,000 --> 00:52:50,000
喜歡讓我們只想說，我在前面加上6，

687
00:52:50,000 --> 00:52:55,000
我的鏈接列表將成為這個。

688
00:52:55,000 --> 00:53:01,000
現在，它沒有任何意義，所以的insert_sorted，你可以假設

689
00:53:01,000 --> 00:53:04,000
是對列表進行排序，即使操作

690
00:53:04,000 --> 00:53:09,000
這可能會導致不進行排序，就是這樣。

691
00:53:09,000 --> 00:53:20,000
找到一個有用的插件，所以這些都是主要的事情，你將不得不實行。

692
00:53:20,000 --> 00:53:24,000
>> 現在，花一分鐘的長度和包含，

693
00:53:24,000 --> 00:53:30,000
這些應該是比較快的。

694
00:53:41,000 --> 00:53:48,000
接近關門時間，所以任何人有任何長度或包含？

695
00:53:48,000 --> 00:53:50,000
他們將是幾乎相同的。

696
00:53:50,000 --> 00:53:57,000
[學生]：長度。

697
00:53:57,000 --> 00:54:01,000
讓我們來看看，修訂工作。

698
00:54:01,000 --> 00:54:04,000
好吧。

699
00:54:12,000 --> 00:54:15,000
你想說明什麼？

700
00:54:15,000 --> 00:54:21,000
[學生]：我只是創建一個的指針節點，並把它初始化為第一，這是我們的全局變量，

701
00:54:21,000 --> 00:54:27,000
然後我檢查，看它是否為null，所以我沒有得到段故障，並返回0，如果是這樣的話。

702
00:54:27,000 --> 00:54:34,000
否則，我遍歷，跟踪的內的整數

703
00:54:34,000 --> 00:54:38,000
多少次，我已經訪問列表中的下一個元素

704
00:54:38,000 --> 00:54:43,000
和在相同的增量操作也訪問該實際元素，

705
00:54:43,000 --> 00:54:47,000
然後我不斷地檢查，看它是否為NULL，

706
00:54:47,000 --> 00:54:56,000
，如果它是空的，那麼它中止，只是返回我訪問過的元素。

707
00:54:56,000 --> 00:55:01,000
>> [羅布B.]有沒有人有任何意見什麼？

708
00:55:01,000 --> 00:55:06,000
這看起來精細的正確性明智的。

709
00:55:06,000 --> 00:55:10,000
[學生]：我不認為你需要的節點== NULL。

710
00:55:10,000 --> 00:55:13,000
是啊，所以如果節點== null返回0。

711
00:55:13,000 --> 00:55:18,000
但如果節點== NULL，那麼這個，哦，有一個正確的問題。

712
00:55:18,000 --> 00:55:23,000
這只是你回到我的，但它現在不在範圍之內。

713
00:55:23,000 --> 00:55:30,000
你只需要我，所以我= 0。

714
00:55:30,000 --> 00:55:34,000
但是，如果節點是空的，那麼我仍然為0，

715
00:55:34,000 --> 00:55:39,000
我們將返回0，所以這種情況是相同的。

716
00:55:39,000 --> 00:55:48,000
另一種常見的是要保持的聲明

717
00:55:48,000 --> 00:55:51,000
節點內的for循環。

718
00:55:51,000 --> 00:55:54,000
你可能會說，哦，不。

719
00:55:54,000 --> 00:55:56,000
讓我們保持它，因為這。

720
00:55:56,000 --> 00:55:59,000
我可能會放INT I = 0在這裡，

721
00:55:59,000 --> 00:56:05,000
然後節點節點第一次在這裡。

722
00:56:05,000 --> 00:56:11,000
這可能是如何擺脫現在的這種。

723
00:56:11,000 --> 00:56:14,000
這可能是我會怎麼寫。

724
00:56:14,000 --> 00:56:21,000
你也可以看它是這樣的。

725
00:56:21,000 --> 00:56:25,000
在這裡循環結構，這

726
00:56:25,000 --> 00:56:30,000
應該是幾乎一樣自然地為int i = 0

727
00:56:30,000 --> 00:56:33,000
i是小於數組的長度一+ +。

728
00:56:33,000 --> 00:56:38,000
如果這就是你如何遍歷一個數組，你這是怎麼遍歷一個鍊錶。

729
00:56:38,000 --> 00:56:45,000
>> 在某些時候，這應該是第二自然。

730
00:56:45,000 --> 00:56:50,000
考慮到這一點，這將是幾乎同樣的事情。

731
00:56:50,000 --> 00:56:57,000
你將要遍歷一個鍊錶。

732
00:56:57,000 --> 00:57:02,000
如果節點的價值是什麼，我不知道。

733
00:57:02,000 --> 00:57:04,000
節點i。

734
00:57:04,000 --> 00:57:15,000
如果該節點的值=返回true，這就是它。

735
00:57:15,000 --> 00:57:18,000
請注意，只有這樣，我們永遠返回false

736
00:57:18,000 --> 00:57:23,000
的是，如果我們遍歷整個鍊錶，永不返回true，

737
00:57:23,000 --> 00:57:29,000
所以，這是什麼做的。

738
00:57:29,000 --> 00:57:36,000
作為一個方面說明，我們可能不會得到要前插或追加。

739
00:57:36,000 --> 00:57:39,000
>> 快速最後一個音符。

740
00:57:39,000 --> 00:57:52,000
如果你看到了static關鍵字，所以讓我們說靜態詮釋計數= 0，

741
00:57:52,000 --> 00:57:56,000
然後我們做數+ +中，你可以基本上認為它作為一個全局變量，

742
00:57:56,000 --> 00:58:00,000
即使我只是說，這不是我們要如何落實長度。

743
00:58:00,000 --> 00:58:06,000
我這樣做是在這裡，再算上+ +。

744
00:58:06,000 --> 00:58:11,000
任何方式，我們就可以進入到我們的鏈接列表，我們正在增加我們的計算節點。

745
00:58:11,000 --> 00:58:15,000
這點是static關鍵字意味著什麼。

746
00:58:15,000 --> 00:58:20,000
如果我剛做了詮釋計數= 0，這將是一個普通的老全局變量。

747
00:58:20,000 --> 00:58:25,000
靜態詮釋計數裝置是什麼，它是一個全局變量，這個文件。

748
00:58:25,000 --> 00:58:28,000
這是不可能的其他一些文件，

749
00:58:28,000 --> 00:58:34,000
想到的pset 5，如果你已經開始。

750
00:58:34,000 --> 00:58:39,000
你有都speller.c，和你有dictionary.c，

751
00:58:39,000 --> 00:58:42,000
和，如果你只是全球申報的事情，那麼在speller.c

752
00:58:42,000 --> 00:58:45,000
可以訪問在dictionary.c，反之亦然。

753
00:58:45,000 --> 00:58:48,000
全局變量。c文件的任何訪問，

754
00:58:48,000 --> 00:58:54,000
但靜態變量只能在文件本身，

755
00:58:54,000 --> 00:59:01,000
所以裡面的法術檢查或內部dictionary.c的，

756
00:59:01,000 --> 00:59:06,000
這是我的數組的大小如何，我會宣布我的變量

757
00:59:06,000 --> 00:59:10,000
我在字典中的單詞數的大小。

758
00:59:10,000 --> 00:59:15,000
因為我不希望聲明一個全局變量，任何人都可以訪問，

759
00:59:15,000 --> 00:59:18,000
我真的只關心我自己的目的。

760
00:59:18,000 --> 00:59:21,000
>> 好的事情也整個名稱衝突的東西。

761
00:59:21,000 --> 00:59:27,000
如果有其他文件試圖使用一個全局變量數，事情會變得非常，非常錯誤的，

762
00:59:27,000 --> 00:59:33,000
所以這很好地保持安全起見，只有你可以訪問它，

763
00:59:33,000 --> 00:59:38,000
並沒有其他人就可以了，如果有人聲明了一個全局變量數，

764
00:59:38,000 --> 00:59:43,000
然後，它不會干擾您的靜態變量數。

765
00:59:43,000 --> 00:59:47,000
這是靜態的。它是一個文件的全局變量。

766
00:59:47,000 --> 00:59:52,000
>> 問題什麼呢？

767
00:59:52,000 --> 00:59:59,000
所有的設置。再見。

768
00:59:59,000 --> 01:00:03,000
[CS50.TV]