1
00:00:07,260 --> 00:00:10,050
[Powered by Google Translate] 在編程中，我們經常需要代表值列表，

2
00:00:10,050 --> 00:00:12,840
如學生的名字，在一節

3
00:00:12,840 --> 00:00:15,100
或最新的測驗分數。

4
00:00:15,100 --> 00:00:17,430
>> 在C語言中，宣布陣列可以使用

5
00:00:17,430 --> 00:00:19,160
存儲列表。

6
00:00:19,160 --> 00:00:21,200
這很容易列舉的元素的列表

7
00:00:21,200 --> 00:00:23,390
存儲在數組中，如果你需要訪問

8
00:00:23,390 --> 00:00:25,050
或修改第i個列表元素

9
00:00:25,050 --> 00:00:27,570
一些任意的索引，我，

10
00:00:27,570 --> 00:00:29,910
在固定時間內，可以做

11
00:00:29,910 --> 00:00:31,660
但數組，也有缺點。

12
00:00:31,660 --> 00:00:33,850
>> 當我們聲明，我們需要說

13
00:00:33,850 --> 00:00:35,900
前面他們有多大，

14
00:00:35,900 --> 00:00:38,160
那就是，它們可以存儲多少個元素

15
00:00:38,160 --> 00:00:40,780
有多大，這些元素是，這是由它們的類型。

16
00:00:40,780 --> 00:00:45,450
例如int ARR（10）

17
00:00:45,450 --> 00:00:48,220
可存儲10個項目

18
00:00:48,220 --> 00:00:50,200
是一個int的大小。

19
00:00:50,200 --> 00:00:52,590
>> 我們不能改變數組的大小後聲明。

20
00:00:52,590 --> 00:00:55,290
我們有一個新的數組，如果我們要存儲更多的元素。

21
00:00:55,290 --> 00:00:57,410
存在這種限制的原因是，我們的

22
00:00:57,410 --> 00:00:59,040
程序存儲整個陣列

23
00:00:59,040 --> 00:01:02,310
作為一個連續的內存塊。

24
00:01:02,310 --> 00:01:04,500
之所以這樣說，是我們的緩衝區，存儲在數組中。

25
00:01:04,500 --> 00:01:06,910
可能還有其他變數

26
00:01:06,910 --> 00:01:08,310
位於旁邊的陣列

27
00:01:08,310 --> 00:01:10,060
在內存中，所以我們不能

28
00:01:10,060 --> 00:01:12,060
只要大的陣列。

29
00:01:12,060 --> 00:01:15,700
>> 有時，我們希望貿易陣列的快速數據存取速度

30
00:01:15,700 --> 00:01:17,650
多一點靈活性。

31
00:01:17,650 --> 00:01:20,380
輸入的鏈接列表，另一個基本的數據結構

32
00:01:20,380 --> 00:01:22,360
你可能不熟悉。

33
00:01:22,360 --> 00:01:24,200
在較高的水平，

34
00:01:24,200 --> 00:01:26,840
一個鍊錶，將數據存儲在一個節點序列

35
00:01:26,840 --> 00:01:29,280
彼此連接的鏈接，

36
00:01:29,280 --> 00:01:31,760
故名鍊錶。

37
00:01:31,760 --> 00:01:33,840
正如我們將要看到的，這兩種不同的設計

38
00:01:33,840 --> 00:01:35,500
導致不同的優點和缺點

39
00:01:35,500 --> 00:01:37,000
不是一個數組。

40
00:01:37,000 --> 00:01:39,840
>> 這裡有一個非常簡單的整數鍊錶的C代碼。

41
00:01:39,840 --> 00:01:42,190
你可以看到，我們代表每一個節點

42
00:01:42,190 --> 00:01:45,520
列表中的一個結構，其中包含兩件事情，

43
00:01:45,520 --> 00:01:47,280
一個整數來存儲被稱為“值”

44
00:01:47,280 --> 00:01:50,460
和一個鏈接到列表中的下一個節點

45
00:01:50,460 --> 00:01:52,990
我們所代表的被稱為“下一個指針。

46
00:01:54,120 --> 00:01:56,780
這樣一來，我們就可以跟踪整個列表

47
00:01:56,780 --> 00:01:58,790
只是一個單一的指針的第一個節點，

48
00:01:58,790 --> 00:02:01,270
那麼我們可以按照下面的指針

49
00:02:01,270 --> 00:02:03,130
到的第2節點，

50
00:02:03,130 --> 00:02:05,280
到第3節點，

51
00:02:05,280 --> 00:02:07,000
到第四節點，

52
00:02:07,000 --> 00:02:09,889
依此類推，直到我們得到到年底的列表。

53
00:02:10,520 --> 00:02:12,210
>> 您可能能夠看到1的優勢有

54
00:02:12,210 --> 00:02:14,490
在靜態數組結構 - 一個鍊錶，

55
00:02:14,490 --> 00:02:16,450
我們完全不需要一個大的內存塊。

56
00:02:17,400 --> 00:02:20,530
列表中的第一個節點，可以住在這個地方在內存中，

57
00:02:20,530 --> 00:02:23,160
和第二個節點可能是所有來這裡的路上。

58
00:02:23,160 --> 00:02:25,780
我們可以得到的所有節點，不管他們是在內存中，

59
00:02:25,780 --> 00:02:28,890
因為開始的第一個節點，每個節點的next指針

60
00:02:28,890 --> 00:02:31,700
告訴我們到底去哪裡下。

61
00:02:31,700 --> 00:02:33,670
>> 此外，我們並沒有說前

62
00:02:33,670 --> 00:02:36,740
多大的鏈接列表將是我們做事的方式與靜態數組，

63
00:02:36,740 --> 00:02:39,060
因為我們可以將節點添加到列表

64
00:02:39,060 --> 00:02:42,600
只要存在的空間，在內存中的新節點的某個地方。

65
00:02:42,600 --> 00:02:45,370
因此，鍊錶是很容易的動態調整大小。

66
00:02:45,370 --> 00:02:47,950
再說了，在後面的程序中，我們需要添加更多的節點

67
00:02:47,950 --> 00:02:49,350
進入我們的名單。

68
00:02:49,350 --> 00:02:51,480
要插入一個新的節點，進入我們的名單上的蒼蠅，

69
00:02:51,480 --> 00:02:53,740
所有我們需要做的是該節點分配內存，

70
00:02:53,740 --> 00:02:55,630
撲通中的數據值，

71
00:02:55,630 --> 00:02:59,070
然後將其放置在這裡我們要通過調整相應的指針。

72
00:02:59,070 --> 00:03:02,310
>> 例如，如果我們想在兩者之間放置一個節點

73
00:03:02,310 --> 00:03:04,020
第二和第三個節點的列表，

74
00:03:04,020 --> 00:03:06,800
 我們將不會有第二或第三個節點。

75
00:03:06,800 --> 00:03:09,190
假設我們將這個紅色節點。

76
00:03:09,190 --> 00:03:12,890
我們必須做的是設置新節點的next指針

77
00:03:12,890 --> 00:03:14,870
指向到第三節點的

78
00:03:14,870 --> 00:03:18,580
然後重新連接第二個節點的next指針

79
00:03:18,580 --> 00:03:20,980
以指向我們的新節點。

80
00:03:22,340 --> 00:03:24,370
因此，我們可以調整我們的名單上飛

81
00:03:24,370 --> 00:03:26,090
因為我們的計算機不依賴於索引，

82
00:03:26,090 --> 00:03:28,990
而是在連接使用指針來存儲它們。

83
00:03:29,120 --> 00:03:31,600
>> 然而，一個缺點鍊錶

84
00:03:31,600 --> 00:03:33,370
是，不同於靜態數組，

85
00:03:33,370 --> 00:03:36,690
計算機不能就直接跳到中間的列表中。

86
00:03:38,040 --> 00:03:40,780
由於電腦已訪問鏈接列表中的每個節點

87
00:03:40,780 --> 00:03:42,330
去下一個，

88
00:03:42,330 --> 00:03:44,770
這將需要更長的時間才能找到一個特定的節點

89
00:03:44,770 --> 00:03:46,400
會比在一個數組中。

90
00:03:46,400 --> 00:03:48,660
要遍歷整個列表，需要一定的時間成正比

91
00:03:48,660 --> 00:03:50,580
的列表的長度，

92
00:03:50,580 --> 00:03:54,630
或O（n）的漸近符號。

93
00:03:54,630 --> 00:03:56,510
平均而言，達成任何節點

94
00:03:56,510 --> 00:03:58,800
還需要一定的時間正比於n。

95
00:03:58,800 --> 00:04:00,700
>> 現在，讓我們寫一些代碼

96
00:04:00,700 --> 00:04:02,000
與鍊錶。

97
00:04:02,000 --> 00:04:04,220
比方說，我們希望有一個鍊錶的整數。

98
00:04:04,220 --> 00:04:06,140
我們可以在我們的名單再次表示節點

99
00:04:06,140 --> 00:04:08,340
作為一個結構與2個字段，

100
00:04:08,340 --> 00:04:10,750
一個整數值，被稱為“值”

101
00:04:10,750 --> 00:04:13,490
和下一個列表中的下一個節點的指針。

102
00:04:13,490 --> 00:04:15,660
好了，似乎很簡單。

103
00:04:15,660 --> 00:04:17,220
>> 比方說，我們要編寫一個函數，

104
00:04:17,220 --> 00:04:19,329
遍歷列表，並打印出

105
00:04:19,329 --> 00:04:22,150
的列表中的最後一個節點中存儲的值。

106
00:04:22,150 --> 00:04:24,850
好了，這意味著我們需要遍歷所有的節點列表中的

107
00:04:24,850 --> 00:04:27,310
找到最後一個，但因為我們沒有加入

108
00:04:27,310 --> 00:04:29,250
或刪除任何東西，我們不希望改變

109
00:04:29,250 --> 00:04:32,210
的內部結構的列表中的下一個指針。

110
00:04:32,210 --> 00:04:34,790
>> 所以，我們需要一個指針，專門為穿越

111
00:04:34,790 --> 00:04:36,940
我們稱之為“履帶”。

112
00:04:36,940 --> 00:04:38,870
將抓取的所有元素的列表

113
00:04:38,870 --> 00:04:41,190
通過鏈中的下一個指針。

114
00:04:41,190 --> 00:04:43,750
我們所儲存的第一個節點是一個指針，

115
00:04:43,750 --> 00:04:45,730
或'頭'之列。

116
00:04:45,730 --> 00:04:47,370
頭部穴位的第一個節點。

117
00:04:47,370 --> 00:04:49,120
這類型的指針節點。

118
00:04:49,120 --> 00:04:51,280
>> 為了獲得實際的列表中的第一個節點，

119
00:04:51,280 --> 00:04:53,250
我們必須取消引用此指針，

120
00:04:53,250 --> 00:04:55,100
但在此之前，我們可以取消對它的引用，我們需要檢查

121
00:04:55,100 --> 00:04:57,180
如果指針為空第一。

122
00:04:57,180 --> 00:04:59,190
如果它是空的，該列表是空的，

123
00:04:59,190 --> 00:05:01,320
我們應該打印出的信息，因為列表是空的，

124
00:05:01,320 --> 00:05:03,250
有沒有最後一個節點。

125
00:05:03,250 --> 00:05:05,190
但是，讓我們說，名單是不是空的。

126
00:05:05,190 --> 00:05:08,340
如果不是的話，那麼我們就應該抓取整個列表

127
00:05:08,340 --> 00:05:10,440
直到我們得到的最後一個節點的列表，

128
00:05:10,440 --> 00:05:13,030
以及如何，我們可以說，如果我們正在尋找在列表中的最後一個節點？

129
00:05:13,670 --> 00:05:16,660
>> 那麼，如果一個節點的next指針為null，

130
00:05:16,660 --> 00:05:18,320
我們知道我們在年底

131
00:05:18,320 --> 00:05:22,390
自上頁下頁指針沒有指向列表中的下一個節點。

132
00:05:22,390 --> 00:05:26,590
這是很好的做法，要始終保持最後一個節點的next指針初始化為null

133
00:05:26,590 --> 00:05:30,800
擁有一個標準化的屬性，它提醒我們，當我們的名單已經走到了盡頭。

134
00:05:30,800 --> 00:05:33,510
>> 所以，如果履帶式→下是空的，

135
00:05:34,120 --> 00:05:38,270
請記住，箭頭語法的快捷方式提領

136
00:05:38,270 --> 00:05:40,010
一個指向結構的指針，然後訪問

137
00:05:40,010 --> 00:05:42,510
它的下一個字段的尷尬：

138
00:05:42,510 --> 00:05:48,750
（履帶式）。下。

139
00:05:49,820 --> 00:05:51,260
一旦我們找到的最後一個節點，

140
00:05:51,260 --> 00:05:53,830
我們要打印的履帶式→值，

141
00:05:53,830 --> 00:05:55,000
當前節點的值中的

142
00:05:55,000 --> 00:05:57,130
我們知道這是最後一次。

143
00:05:57,130 --> 00:05:59,740
否則，如果我們還沒有在列表中的最後一個節點，

144
00:05:59,740 --> 00:06:02,340
我們必須移動到列表中的下一個節點

145
00:06:02,340 --> 00:06:04,750
和檢查，如果這是最後一個。

146
00:06:04,750 --> 00:06:07,010
要做到這一點，我們剛剛成立我們的抓取工具指針

147
00:06:07,010 --> 00:06:09,840
指向當前節點的下一個值，

148
00:06:09,840 --> 00:06:11,680
即，在列表中的下一個節點。

149
00:06:11,680 --> 00:06:13,030
這是通過設置

150
00:06:13,030 --> 00:06:15,280
履帶式履帶式→下。

151
00:06:16,050 --> 00:06:18,960
然後，我們重複這個過程，例如循環，

152
00:06:18,960 --> 00:06:20,960
直到我們找到的最後一個節點。

153
00:06:20,960 --> 00:06:23,150
所以，舉例來說，如果履帶指著頭，

154
00:06:24,050 --> 00:06:27,710
我們設置履帶式履帶式→下，

155
00:06:27,710 --> 00:06:30,960
這是相同的第1節點的下一個字段。

156
00:06:30,960 --> 00:06:33,620
所以，現在我們的抓取工具是指向第二個節點，

157
00:06:33,620 --> 00:06:35,480
，並再次重複這個循環，

158
00:06:37,220 --> 00:06:40,610
直到我們發現的最後一個節點，那就是，

159
00:06:40,610 --> 00:06:43,640
節點的next指針指向空。

160
00:06:43,640 --> 00:06:45,070
在那裡我們擁有它，

161
00:06:45,070 --> 00:06:47,620
我們發現在列表中的最後一個節點，打印其值，

162
00:06:47,620 --> 00:06:50,800
我們只是使用履帶→VAL。

163
00:06:50,800 --> 00:06:53,130
>> 穿越並沒有那麼糟糕，但插入呢？

164
00:06:53,130 --> 00:06:56,290
比方說，我們要到第4個位置插入一個整

165
00:06:56,290 --> 00:06:58,040
在一個整數列表。

166
00:06:58,040 --> 00:07:01,280
這是當前的第3次和第4節點之間。

167
00:07:01,280 --> 00:07:03,760
同樣，我們要遍歷列表

168
00:07:03,760 --> 00:07:06,520
到第三個元素，我們要插入後。

169
00:07:06,520 --> 00:07:09,300
所以，我們創建了一個履帶式指針，再次遍歷列表，

170
00:07:09,300 --> 00:07:11,400
檢查我們的頭指針為空，

171
00:07:11,400 --> 00:07:14,810
如果不是的話，我們的抓取工具在頭節點的指針指向。

172
00:07:16,880 --> 00:07:18,060
因此，我們的第一個元素。

173
00:07:18,060 --> 00:07:21,020
我們必須前進之前，我們可以將更多的元素，

174
00:07:21,020 --> 00:07:23,390
所以我們可以使用一個for循環

175
00:07:23,390 --> 00:07:26,430
i = 1; i <3的我+ +

176
00:07:26,430 --> 00:07:28,590
以及在每個循環迭代中，

177
00:07:28,590 --> 00:07:31,540
1個節點的指針向前推進我們的抓取工具

178
00:07:31,540 --> 00:07:34,570
通過檢查，如果當前節點的下一個字段是空的，

179
00:07:34,570 --> 00:07:37,550
，如果不是的話，我們的抓取工具指針移動到下一個節點

180
00:07:37,550 --> 00:07:41,810
通過設置它等於當前節點的next指針。

181
00:07:41,810 --> 00:07:45,210
所以，既然我們的for循環中說，要做到這一點

182
00:07:45,210 --> 00:07:47,550
兩次，

183
00:07:49,610 --> 00:07:51,190
我們已經達到了第三個節點，

184
00:07:51,190 --> 00:07:53,110
一旦我們的抓取工具指針到達節點後，

185
00:07:53,110 --> 00:07:55,270
我們要插入新的整數，

186
00:07:55,270 --> 00:07:57,050
我們如何真正插入呢？

187
00:07:57,050 --> 00:07:59,440
>> 那麼，我們的新的整數被插入到列表中

188
00:07:59,440 --> 00:08:01,250
作為其自身節點結構的一部分，

189
00:08:01,250 --> 00:08:03,140
因為這是真正的節點序列。

190
00:08:03,140 --> 00:08:05,690
所以，讓我們做一個新的指針節點

191
00:08:05,690 --> 00:08:08,910
被稱為“new_node，”

192
00:08:08,910 --> 00:08:11,800
並將其設置為指向的內存，我們現在分配

193
00:08:11,800 --> 00:08:14,270
在堆中的節點，

194
00:08:14,270 --> 00:08:16,000
我們需要分配多少內存？

195
00:08:16,000 --> 00:08:18,250
那麼，一個節點的大小，

196
00:08:20,450 --> 00:08:23,410
我們要設置其VAL領域，我們要插入的整數。

197
00:08:23,410 --> 00:08:25,590
比方說，6。

198
00:08:25,590 --> 00:08:27,710
現在，節點中包含的整數值。

199
00:08:27,710 --> 00:08:30,650
這是很好的做法，初始化新節點的下一個字段

200
00:08:30,650 --> 00:08:33,690
指向NULL，

201
00:08:33,690 --> 00:08:35,080
但現在該怎麼辦呢？

202
00:08:35,080 --> 00:08:37,179
>> 我們必須改變列表的內部結構的

203
00:08:37,179 --> 00:08:40,409
和包含在列表的現有的下一個指針

204
00:08:40,409 --> 00:08:42,950
第3和第4個節點。

205
00:08:42,950 --> 00:08:46,560
由於下一個指針確定的名單順序，

206
00:08:46,560 --> 00:08:48,650
而且因為我們要插入的新節點

207
00:08:48,650 --> 00:08:50,510
到中間的列表中，

208
00:08:50,510 --> 00:08:52,010
它可以是一個有點棘手。

209
00:08:52,010 --> 00:08:54,250
這是因為，記住，我們的電腦

210
00:08:54,250 --> 00:08:56,250
只知道在列表中的位置的節點

211
00:08:56,250 --> 00:09:00,400
因為存儲在以前的節點的下一個指針。

212
00:09:00,400 --> 00:09:03,940
所以，如果我們失去了這些位置的跟踪，

213
00:09:03,940 --> 00:09:06,860
說通過改變在列表中的下一個指針之一，

214
00:09:06,860 --> 00:09:09,880
例如，假設我們改變

215
00:09:09,880 --> 00:09:12,920
第三個節點的下一個字段

216
00:09:12,920 --> 00:09:15,610
指向某些節點在這裡。

217
00:09:15,610 --> 00:09:17,920
我們很運氣，因為我們不會

218
00:09:17,920 --> 00:09:20,940
有任何想法在哪裡可以找到，其餘的名單，

219
00:09:20,940 --> 00:09:23,070
這顯然非常糟糕。

220
00:09:23,070 --> 00:09:25,080
因此，我們必須非常小心的順序

221
00:09:25,080 --> 00:09:28,360
在我們操作插入時，我們的下一個指針。

222
00:09:28,360 --> 00:09:30,540
>> 因此，為了簡化這一點，讓我們說，

223
00:09:30,540 --> 00:09:32,220
我們的第一個節點

224
00:09:32,220 --> 00:09:36,200
被稱為A，B，C，和D，用箭頭表示的指針的鏈

225
00:09:36,200 --> 00:09:38,070
連接節點。

226
00:09:38,070 --> 00:09:40,050
因此，我們需要將我們的新節點

227
00:09:40,050 --> 00:09:42,070
在節點C和D之間的

228
00:09:42,070 --> 00:09:45,060
它的關鍵在正確的順序做了，我會告訴你為什麼。

229
00:09:45,060 --> 00:09:47,500
>> 讓我們來看看在錯誤的方式來做到這一點。

230
00:09:47,500 --> 00:09:49,490
嘿，我們知道新的節點來右後C，

231
00:09:49,490 --> 00:09:51,910
所以，讓我們來設置C的指針

232
00:09:51,910 --> 00:09:54,700
指向new_node。

233
00:09:56,530 --> 00:09:59,180
好吧，看起來沒問題，我們就必須完成現在

234
00:09:59,180 --> 00:10:01,580
新節點的next指針指向D，

235
00:10:01,580 --> 00:10:03,250
但等待，我們能做到這一點嗎？

236
00:10:03,250 --> 00:10:05,170
唯一能告訴我們其中D，

237
00:10:05,170 --> 00:10:07,630
以前是下一個指針存儲在C，

238
00:10:07,630 --> 00:10:09,870
但我們只是重寫了該指針

239
00:10:09,870 --> 00:10:11,170
以指向新的節點，

240
00:10:11,170 --> 00:10:14,230
因此，我們不再有任何線索，其中D是在內存中，

241
00:10:14,230 --> 00:10:17,020
我們已經失去了休息的列表。

242
00:10:17,020 --> 00:10:19,000
都不好。

243
00:10:19,000 --> 00:10:21,090
>> 那麼，我們該怎麼做是正確的？

244
00:10:22,360 --> 00:10:25,090
首先，指向新節點的next指針D.

245
00:10:26,170 --> 00:10:28,990
現在，新的節點和C的next指針

246
00:10:28,990 --> 00:10:30,660
都指向同一個節點上，D，

247
00:10:30,660 --> 00:10:32,290
但罰款。

248
00:10:32,290 --> 00:10:35,680
現在，我們可以在新的節點C的下一個指針指向。

249
00:10:37,450 --> 00:10:39,670
因此，我們已經做到了這一點，而不會丟失任何數據。

250
00:10:39,670 --> 00:10:42,280
在代碼中，C是當前節點

251
00:10:42,280 --> 00:10:45,540
遍歷指針履帶式指向，

252
00:10:45,540 --> 00:10:50,400
和D表示的由當前節點的下一個字段指向的節點，

253
00:10:50,400 --> 00:10:52,600
或履帶→下一步。

254
00:10:52,600 --> 00:10:55,460
因此，我們首先設置新節點的next指針

255
00:10:55,460 --> 00:10:57,370
履帶式→下，

256
00:10:57,370 --> 00:11:00,880
我們說，new_node的下一個指針應該以同樣的方式

257
00:11:00,880 --> 00:11:02,780
在圖中，指向D。

258
00:11:02,780 --> 00:11:04,540
然後，我們可以設置當前節點的next指針

259
00:11:04,540 --> 00:11:06,330
我們的新節點，

260
00:11:06,330 --> 00:11:10,980
就像我們不得不，等待到C點在繪圖new_node。

261
00:11:10,980 --> 00:11:12,250
現在一切都在秩序，我們並沒有失去

262
00:11:12,250 --> 00:11:14,490
跟踪的任何數據，我們能夠公正

263
00:11:14,490 --> 00:11:16,200
堅持我們的在中間的列表中的新的節點

264
00:11:16,200 --> 00:11:19,330
不重建整個事情的情況下，甚至轉移的任何元素

265
00:11:19,330 --> 00:11:22,490
的方式，我們將不得不與一個固定長度的陣列。

266
00:11:22,490 --> 00:11:26,020
>> 因此，鍊錶是一個基本的，但重要的是，動態​​的數據結構

267
00:11:26,020 --> 00:11:29,080
有優點也有缺點

268
00:11:29,080 --> 00:11:31,260
陣列和其他數據結構相比，

269
00:11:31,260 --> 00:11:33,350
和通常情況下在計算機科學，

270
00:11:33,350 --> 00:11:35,640
重要的是要知道何時使用每個工具，

271
00:11:35,640 --> 00:11:37,960
所以你可以選擇合適的工具，合適的工作。

272
00:11:37,960 --> 00:11:40,060
>> 更多的練習，嘗試寫功能

273
00:11:40,060 --> 00:11:42,080
從鍊錶中刪除節點 - 

274
00:11:42,080 --> 00:11:44,050
記得要小心的順序重新排列

275
00:11:44,050 --> 00:11:47,430
你的下一個指針，以確保您不會失去一大塊您的列表 - 

276
00:11:47,430 --> 00:11:50,200
或一個函數來計算一個鍊錶中的節點，

277
00:11:50,200 --> 00:11:53,280
一個有趣的，以扭轉在一個鍊錶中的所有節點的順序。

278
00:11:53,280 --> 00:11:56,090
>> 我的名字是傑克遜施泰因坎普，這是CS50。