1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [Phần 6] [thoải mái hơn]

2
00:00:01,000 --> 00:00:04,000
[Rob Bowden] [Đại học Harvard]

3
00:00:04,000 --> 00:00:09,000
[Đây là CS50.] [CS50.TV]

4
00:00:09,000 --> 00:00:11,000
>> Chúng tôi có thể đi đến phần câu hỏi của chúng tôi.

5
00:00:11,000 --> 00:00:17,000
Tôi đã gửi các URL cho không gian trước.

6
00:00:17,000 --> 00:00:22,000
Sự khởi đầu của phần trong những câu hỏi nói-

7
00:00:22,000 --> 00:00:26,000
dường như tôi không hoàn toàn unsick là một câu hỏi rất dễ dàng

8
00:00:26,000 --> 00:00:28,000
chỉ là những gì được valgrind?

9
00:00:28,000 --> 00:00:30,000
Valgrind làm gì?

10
00:00:30,000 --> 00:00:34,000
Bất cứ ai muốn nói những gì valgrind không?

11
00:00:34,000 --> 00:00:36,000
[Sinh viên] Kiểm tra rò rỉ bộ nhớ.

12
00:00:36,000 --> 00:00:41,000
Yeah, valgrind là một kiểm tra bộ nhớ chung.

13
00:00:41,000 --> 00:00:44,000
Nó, cuối cùng, cho bạn biết nếu bạn có bất kỳ rò rỉ bộ nhớ,

14
00:00:44,000 --> 00:00:49,000
mà chủ yếu là những gì chúng ta đang sử dụng nó bởi vì nếu bạn muốn

15
00:00:49,000 --> 00:00:54,000
làm tốt trong các thiết lập vấn đề hoặc nếu bạn muốn

16
00:00:54,000 --> 00:00:59,000
có được trên bảng lớn, bạn cần phải có không có rò rỉ bộ nhớ nào,

17
00:00:59,000 --> 00:01:01,000
và trong trường hợp bạn có một rò rỉ bộ nhớ mà bạn không thể tìm thấy,

18
00:01:01,000 --> 00:01:04,000
cũng ghi nhớ rằng bất cứ khi nào bạn mở một tập tin

19
00:01:04,000 --> 00:01:07,000
và nếu bạn không đóng nó, đó là một rò rỉ bộ nhớ.

20
00:01:07,000 --> 00:01:10,000
>> Rất nhiều người đang tìm kiếm một số nút mà họ không giải phóng

21
00:01:10,000 --> 00:01:15,000
khi thực sự, họ không đóng từ điển trong bước đầu tiên.

22
00:01:15,000 --> 00:01:19,000
Nó cũng cho bạn nếu bạn có bất kỳ không hợp lệ lần đọc hoặc viết,

23
00:01:19,000 --> 00:01:22,000
có nghĩa là nếu bạn cố gắng và đặt một giá trị

24
00:01:22,000 --> 00:01:26,000
đó là vượt ra ngoài cuối của heap và nó không xảy ra lỗi seg

25
00:01:26,000 --> 00:01:30,000
nhưng valgrind bắt nó, như bạn nên không thực sự được viết ở đó,

26
00:01:30,000 --> 00:01:33,000
và như vậy chắc chắn bạn không nên có bất kỳ của những người hoặc.

27
00:01:33,000 --> 00:01:38,000
Làm thế nào để bạn sử dụng Valgrind?

28
00:01:38,000 --> 00:01:42,000
Làm thế nào để bạn sử dụng Valgrind?

29
00:01:42,000 --> 00:01:45,000
>> Đó là một câu hỏi chung của

30
00:01:45,000 --> 00:01:49,000
loại chạy nó và nhìn vào đầu ra.

31
00:01:49,000 --> 00:01:51,000
Sản lượng áp đảo rất nhiều lần.

32
00:01:51,000 --> 00:01:54,000
Ngoài ra còn có lỗi thú vị mà nếu bạn có một số điều khủng khiếp sai

33
00:01:54,000 --> 00:01:59,000
xảy ra trong vòng một, sau đó nó sẽ nói, "Cách quá nhiều lỗi.

34
00:01:59,000 --> 00:02:03,000
Tôi sẽ ngừng đếm. "

35
00:02:03,000 --> 00:02:08,000
Đó là cơ bản văn bản đầu ra mà bạn phải phân tích.

36
00:02:08,000 --> 00:02:13,000
Cuối cùng, nó sẽ cho bạn bất kỳ rò rỉ bộ nhớ mà bạn có,

37
00:02:13,000 --> 00:02:16,000
bao nhiêu khối, mà có thể là hữu ích vì

38
00:02:16,000 --> 00:02:20,000
nếu nó một khối unfreed, sau đó nó thường dễ dàng hơn để tìm

39
00:02:20,000 --> 00:02:23,000
hơn 1.000 khối unfreed.

40
00:02:23,000 --> 00:02:26,000
1.000 khối unfreed có thể có nghĩa là bạn không giải phóng

41
00:02:26,000 --> 00:02:30,000
danh sách của bạn liên kết thích hợp hoặc một cái gì đó.

42
00:02:30,000 --> 00:02:32,000
Đó là valgrind.

43
00:02:32,000 --> 00:02:35,000
>> Bây giờ chúng tôi có phần câu hỏi của chúng tôi,

44
00:02:35,000 --> 00:02:38,000
mà bạn không cần phải tải về.

45
00:02:38,000 --> 00:02:41,000
Bạn có thể bấm vào tên của tôi và kéo chúng lên trong không gian.

46
00:02:41,000 --> 00:02:44,000
Bây giờ bấm vào tôi.

47
00:02:44,000 --> 00:02:46,000
Phiên bản 1 sẽ là chồng, mà chúng tôi đang làm 1.

48
00:02:46,000 --> 00:02:55,000
Phiên bản 2 sẽ là hàng đợi, và sửa đổi 3 sẽ là danh sách liên kết đơn lẻ.

49
00:02:55,000 --> 00:02:58,000
Bắt đầu với stack của chúng tôi.

50
00:02:58,000 --> 00:03:02,000
Như nó nói ở đây, một chồng là một trong những cơ bản nhất,

51
00:03:02,000 --> 00:03:07,000
cấu trúc dữ liệu cơ bản của khoa học máy tính.

52
00:03:07,000 --> 00:03:11,000
Ví dụ rất nguyên mẫu là

53
00:03:11,000 --> 00:03:13,000
ngăn xếp của các khay trong phòng ăn.

54
00:03:13,000 --> 00:03:16,000
Đó là cơ bản bất cứ khi nào bạn đang được giới thiệu với một chồng,

55
00:03:16,000 --> 00:03:20,000
người nào đó sẽ nói: "Ồ, như một chồng các khay."

56
00:03:20,000 --> 00:03:22,000
Bạn sắp xếp các khay.

57
00:03:22,000 --> 00:03:24,000
Sau đó, khi bạn đi để kéo một cái khay,

58
00:03:24,000 --> 00:03:31,000
khay đầu tiên nhận được kéo là một trong những cuối cùng đã được đặt trên stack.

59
00:03:31,000 --> 00:03:34,000
Stack cũng như nó nói ở đây

60
00:03:34,000 --> 00:03:37,000
chúng tôi có các phân đoạn của bộ nhớ được gọi là ngăn xếp.

61
00:03:37,000 --> 00:03:40,000
Và tại sao nó được gọi là ngăn xếp?

62
00:03:40,000 --> 00:03:42,000
>> Bởi vì giống như một cấu trúc dữ liệu ngăn xếp,

63
00:03:42,000 --> 00:03:46,000
nó đẩy bật các khung stack trên stack,

64
00:03:46,000 --> 00:03:53,000
nơi mà các khung stack giống như một cuộc gọi cụ thể của một hàm.

65
00:03:53,000 --> 00:03:57,000
Và như một chồng, bạn sẽ luôn luôn phải quay trở lại

66
00:03:57,000 --> 00:04:03,000
từ một cuộc gọi chức năng trước khi bạn có thể nhận được vào các khung stack thấp hơn một lần nữa.

67
00:04:03,000 --> 00:04:08,000
Bạn không thể có chính thanh cuộc gọi cuộc gọi foo và trở về thanh chính trực tiếp.

68
00:04:08,000 --> 00:04:14,000
Nó luôn luôn có để thực hiện theo các ngăn xếp chính xác và đẩy popping.

69
00:04:14,000 --> 00:04:18,000
Hai hoạt động, như tôi đã nói, là push và pop.

70
00:04:18,000 --> 00:04:20,000
Đó là những thuật ngữ phổ quát.

71
00:04:20,000 --> 00:04:26,000
Bạn nên biết push và pop về các ngăn xếp không có vấn đề gì.

72
00:04:26,000 --> 00:04:28,000
Chúng ta sẽ thấy hàng đợi là loại khác nhau.

73
00:04:28,000 --> 00:04:32,000
Nó không thực sự có một thuật ngữ phổ quát, nhưng push và pop phổ quát cho ngăn xếp.

74
00:04:32,000 --> 00:04:34,000
Đẩy chỉ cần đặt trên stack.

75
00:04:34,000 --> 00:04:37,000
Pop là lấy ra khỏi ngăn xếp.

76
00:04:37,000 --> 00:04:43,000
Và chúng ta thấy ở đây chúng tôi có typedef struct stack của chúng tôi,

77
00:04:43,000 --> 00:04:46,000
vì vậy chúng tôi có chuỗi char **.

78
00:04:46,000 --> 00:04:51,000
Đừng sợ hãi bởi bất kỳ **.

79
00:04:51,000 --> 00:04:54,000
Điều này sẽ là một mảng của chuỗi

80
00:04:54,000 --> 00:04:58,000
hoặc một mảng của các con trỏ ký tự,

81
00:04:58,000 --> 00:05:00,000
con trỏ với các nhân vật có xu hướng được chuỗi.

82
00:05:00,000 --> 00:05:05,000
Nó không có được chuỗi, nhưng ở đây, họ sẽ được chuỗi.

83
00:05:05,000 --> 00:05:08,000
>> Chúng tôi có một mảng của chuỗi.

84
00:05:08,000 --> 00:05:14,000
Chúng tôi có một kích thước, đại diện cho bao nhiêu yếu tố này là trên stack,

85
00:05:14,000 --> 00:05:19,000
và sau đó chúng tôi có khả năng, mà là nhiều yếu tố có thể được trên stack.

86
00:05:19,000 --> 00:05:22,000
Năng lực nên bắt đầu như là một cái gì đó lớn hơn 1,

87
00:05:22,000 --> 00:05:27,000
nhưng kích thước sẽ bắt đầu như là 0.

88
00:05:27,000 --> 00:05:36,000
Bây giờ, về cơ bản có ba cách khác nhau bạn có thể nghĩ một chồng.

89
00:05:36,000 --> 00:05:39,000
Vâng, có lẽ nhiều hơn, nhưng hai cách chính

90
00:05:39,000 --> 00:05:43,000
bạn có thể thực hiện nó bằng cách sử dụng một mảng, hoặc bạn có thể thực hiện nó bằng cách sử dụng một danh sách liên kết.

91
00:05:43,000 --> 00:05:48,000
Danh sách liên kết là loại tầm thường để làm cho ngăn xếp từ.

92
00:05:48,000 --> 00:05:51,000
Nó rất dễ dàng để tạo ra một ngăn xếp bằng cách sử dụng danh sách liên kết,

93
00:05:51,000 --> 00:05:55,000
vì vậy ở đây, chúng tôi sẽ làm cho một chồng sử dụng các mảng,

94
00:05:55,000 --> 00:05:59,000
và sau đó sử dụng các mảng, có cũng có hai cách bạn có thể suy nghĩ về nó.

95
00:05:59,000 --> 00:06:01,000
Trước đây, khi tôi nói rằng chúng ta có một năng lực cho stack,

96
00:06:01,000 --> 00:06:04,000
vì vậy chúng tôi có thể phù hợp với một phần tử trên stack.

97
00:06:04,000 --> 00:06:09,000
>> Là một trong những cách có thể xảy ra ngay sau khi bạn nhấn 10 yếu tố, sau đó bạn đang thực hiện.

98
00:06:09,000 --> 00:06:13,000
Bạn có thể biết rằng có một ràng buộc trên của 10 điều trên thế giới

99
00:06:13,000 --> 00:06:16,000
mà bạn sẽ không bao giờ có hơn 10 điều trên stack của bạn,

100
00:06:16,000 --> 00:06:20,000
trong trường hợp đó, bạn có thể có một trên ràng buộc về kích thước của ngăn xếp của bạn.

101
00:06:20,000 --> 00:06:23,000
Hoặc bạn có thể có ngăn xếp của bạn không bị chặn,

102
00:06:23,000 --> 00:06:27,000
nhưng nếu bạn đang làm một mảng, mà có nghĩa là mỗi lần duy nhất, bạn nhấn 10 yếu tố,

103
00:06:27,000 --> 00:06:29,000
sau đó bạn sẽ phải tăng lên 20 phần tử, và khi bạn nhấn 20 phần tử,

104
00:06:29,000 --> 00:06:33,000
bạn sẽ phải phát triển mảng của bạn 30 yếu tố hoặc 40 yếu tố.

105
00:06:33,000 --> 00:06:37,000
Bạn sẽ cần phải tăng cường năng lực, đó là những gì chúng tôi đang làm ở đây.

106
00:06:37,000 --> 00:06:40,000
Mỗi lần duy nhất chúng tôi đạt đến kích thước tối đa của ngăn xếp của chúng tôi,

107
00:06:40,000 --> 00:06:46,000
khi chúng ta đẩy một cái gì đó khác trên, chúng ta sẽ cần phải tăng cường năng lực.

108
00:06:46,000 --> 00:06:50,000
Ở đây, chúng tôi đã đẩy khai báo là đẩy bool (char * str).

109
00:06:50,000 --> 00:06:54,000
Char * str là chuỗi mà chúng ta đang đẩy vào stack,

110
00:06:54,000 --> 00:06:58,000
và bool chỉ nói rằng cho dù chúng tôi đã thành công hay thất bại.

111
00:06:58,000 --> 00:07:00,000
>> Làm thế nào chúng ta có thể thất bại?

112
00:07:00,000 --> 00:07:04,000
Trường hợp duy nhất mà bạn có thể nghĩ là gì

113
00:07:04,000 --> 00:07:07,000
nơi chúng tôi sẽ cần phải quay trở lại sai?

114
00:07:07,000 --> 00:07:09,000
Yeah.

115
00:07:09,000 --> 00:07:12,000
[Sinh viên] Nếu nó đầy đủ và chúng tôi đang sử dụng một thực hiện giáp.

116
00:07:12,000 --> 00:07:17,000
Yeah, vì vậy làm thế nào để chúng ta xác định anh ta trả lời

117
00:07:17,000 --> 00:07:23,000
nếu nó đầy đủ và chúng tôi đang sử dụng một thực hiện bị chặn.

118
00:07:23,000 --> 00:07:26,000
Sau đó, chúng tôi chắc chắn sẽ trở lại sai.

119
00:07:26,000 --> 00:07:31,000
Ngay khi chúng tôi đạt 10 điều trong mảng, chúng ta không có thể phù hợp với 11, do đó, chúng tôi quay trở lại sai.

120
00:07:31,000 --> 00:07:32,000
Điều gì sẽ xảy ra nếu nó bị chặn? Yeah.

121
00:07:32,000 --> 00:07:38,000
Nếu bạn không thể mở rộng mảng cho một số lý do.

122
00:07:38,000 --> 00:07:43,000
Yeah, vì vậy bộ nhớ là một nguồn lực hạn chế,

123
00:07:43,000 --> 00:07:51,000
và cuối cùng, nếu chúng ta giữ cho mọi thứ đẩy vào stack hơn và hơn nữa,

124
00:07:51,000 --> 00:07:54,000
chúng tôi sẽ cố gắng và cấp phát một mảng lớn hơn để phù hợp với

125
00:07:54,000 --> 00:07:59,000
công suất lớn hơn, và malloc hoặc bất cứ điều gì mà chúng ta đang sử dụng sẽ trả về false.

126
00:07:59,000 --> 00:08:02,000
, Malloc sẽ trả về null.

127
00:08:02,000 --> 00:08:05,000
>> Hãy nhớ rằng, mỗi lần duy nhất bạn đã bao giờ gọi malloc, bạn nên được kiểm tra để xem nếu nó

128
00:08:05,000 --> 00:08:12,000
trả về null hoặc người nào khác đó là một trích đúng đắn.

129
00:08:12,000 --> 00:08:17,000
Vì chúng ta muốn có một ngăn xếp không bị chặn,

130
00:08:17,000 --> 00:08:21,000
trường hợp duy nhất chúng ta sẽ được trở về sai là nếu chúng ta cố gắng

131
00:08:21,000 --> 00:08:26,000
tăng cường năng lực và malloc hoặc bất cứ điều gì trả về false.

132
00:08:26,000 --> 00:08:30,000
Sau đó, cửa sổ pop không có đối số,

133
00:08:30,000 --> 00:08:37,000
và nó trả về chuỗi đó là trên đỉnh của ngăn xếp.

134
00:08:37,000 --> 00:08:41,000
Dù gần đây đã được đẩy vào ngăn xếp là gì pop đang trở lại,

135
00:08:41,000 --> 00:08:44,000
và nó cũng có thể loại bỏ nó khỏi stack.

136
00:08:44,000 --> 00:08:50,000
Và nhận thấy rằng nó trả về null nếu không có gì trên stack.

137
00:08:50,000 --> 00:08:53,000
Nó luôn luôn là có thể ngăn xếp là sản phẩm nào.

138
00:08:53,000 --> 00:08:55,000
Trong Java, nếu bạn đang sử dụng đó, hoặc các ngôn ngữ khác,

139
00:08:55,000 --> 00:09:01,000
cố gắng để bật từ một ngăn xếp rỗng có thể gây ra một ngoại lệ hoặc một cái gì đó.

140
00:09:01,000 --> 00:09:09,000
>> Nhưng trong C, null là loại của rất nhiều các trường hợp làm thế nào chúng ta xử lý những vấn đề này.

141
00:09:09,000 --> 00:09:13,000
Quay trở lại null là làm thế nào chúng ta sẽ biểu rằng ngăn xếp rỗng.

142
00:09:13,000 --> 00:09:16,000
Chúng tôi đã cung cấp mã mà sẽ kiểm tra chức năng ngăn xếp của bạn,

143
00:09:16,000 --> 00:09:19,000
thực hiện đẩy và pop.

144
00:09:19,000 --> 00:09:23,000
Đây không phải là rất nhiều mã.

145
00:09:23,000 --> 00:09:40,000
Tôi sẽ thực sự, trước khi chúng tôi làm điều đó, gợi ý, gợi ý-

146
00:09:40,000 --> 00:09:44,000
nếu bạn không nhìn thấy nó, malloc không phải là chức năng duy nhất

147
00:09:44,000 --> 00:09:47,000
cấp phát bộ nhớ trên heap cho bạn.

148
00:09:47,000 --> 00:09:51,000
Có một gia đình của các chức năng alloc.

149
00:09:51,000 --> 00:09:53,000
Đầu tiên là malloc, mà bạn đang sử dụng để.

150
00:09:53,000 --> 00:09:56,000
Sau đó có calloc, làm điều tương tự như malloc,

151
00:09:56,000 --> 00:09:59,000
nhưng nó sẽ không ra tất cả mọi thứ cho bạn.

152
00:09:59,000 --> 00:10:04,000
Nếu bạn đã bao giờ muốn để thiết lập tất cả mọi thứ để null sau khi mallocing một cái gì đó

153
00:10:04,000 --> 00:10:06,000
bạn cần phải có chỉ được sử dụng calloc ở nơi đầu tiên thay vì viết

154
00:10:06,000 --> 00:10:09,000
một vòng lặp không ra toàn bộ khối bộ nhớ.

155
00:10:09,000 --> 00:10:15,000
>> Realloc như malloc và có rất nhiều trường hợp đặc biệt,

156
00:10:15,000 --> 00:10:19,000
nhưng về cơ bản realloc làm gì

157
00:10:19,000 --> 00:10:24,000
phải mất một con trỏ đã được phân bổ.

158
00:10:24,000 --> 00:10:27,000
Realloc là chức năng bạn muốn được chú ý ở đây.

159
00:10:27,000 --> 00:10:31,000
Phải mất một con trỏ đã được trở về từ malloc.

160
00:10:31,000 --> 00:10:35,000
Hãy nói rằng bạn yêu cầu từ malloc một con trỏ của 10 byte.

161
00:10:35,000 --> 00:10:38,000
Sau đó bạn nhận ra rằng bạn muốn 20 byte,

162
00:10:38,000 --> 00:10:42,000
do đó, bạn gọi realloc trên con trỏ với 20 byte,

163
00:10:42,000 --> 00:10:47,000
và realloc sẽ tự động sao chép trên tất cả mọi thứ cho bạn.

164
00:10:47,000 --> 00:10:51,000
Nếu bạn chỉ cần gọi là malloc một lần nữa, như tôi có một khối 10 byte.

165
00:10:51,000 --> 00:10:53,000
Bây giờ tôi cần một khối 20 byte,

166
00:10:53,000 --> 00:10:58,000
vì vậy nếu tôi malloc 20 byte, sau đó tôi phải tự sao chép 10 byte từ những điều đầu tiên

167
00:10:58,000 --> 00:11:01,000
vào điều thứ hai và sau đó điều đầu tiên.

168
00:11:01,000 --> 00:11:04,000
Realloc sẽ xử lý đó cho bạn.

169
00:11:04,000 --> 00:11:11,000
>> Chú ý chữ ký là có được void *,

170
00:11:11,000 --> 00:11:15,000
mà chỉ là trở về một con trỏ tới các khối của bộ nhớ,

171
00:11:15,000 --> 00:11:17,000
sau đó void * ptr.

172
00:11:17,000 --> 00:11:22,000
Bạn có thể nghĩ void * như một con trỏ chung chung.

173
00:11:22,000 --> 00:11:27,000
Nói chung, bạn không bao giờ đối phó với void *,

174
00:11:27,000 --> 00:11:30,000
nhưng malloc trả về một void *, và sau đó nó chỉ được sử dụng như

175
00:11:30,000 --> 00:11:34,000
điều này thực sự sẽ là một char *.

176
00:11:34,000 --> 00:11:37,000
Void * trước đó đã được trả lại bởi malloc

177
00:11:37,000 --> 00:11:41,000
bây giờ sẽ được thông qua để realloc, và sau đó kích thước

178
00:11:41,000 --> 00:11:49,000
là số điện thoại mới của byte mà bạn muốn phân bổ, do đó, khả năng mới của bạn.

179
00:11:49,000 --> 00:11:57,000
Tôi sẽ cung cấp cho bạn một vài phút, và làm điều đó trong không gian của chúng tôi.

180
00:11:57,000 --> 00:12:02,000
Bắt đầu với phiên bản 1.

181
00:12:16,000 --> 00:12:21,000
Tôi sẽ dừng lại sau khi hy vọng về đủ thời gian để thực hiện push,

182
00:12:21,000 --> 00:12:24,000
và sau đó tôi sẽ cung cấp cho bạn một break để làm pop.

183
00:12:24,000 --> 00:12:27,000
Nhưng nó thực sự là không có mã nhiều ở tất cả.

184
00:12:27,000 --> 00:12:35,000
Mã nhất có lẽ là các công cụ mở rộng, mở rộng công suất.

185
00:12:35,000 --> 00:12:39,000
Được rồi, không có áp lực được hoàn toàn thực hiện,

186
00:12:39,000 --> 00:12:47,000
nhưng miễn là bạn cảm thấy như bạn đang ở trên con đường bên phải, đó là tốt.

187
00:12:47,000 --> 00:12:53,000
>> Có ai có bất kỳ mã mà họ cảm thấy thoải mái với tôi kéo lên?

188
00:12:53,000 --> 00:12:59,000
Vâng, tôi sẽ làm, nhưng không ai có bất kỳ mã tôi có thể kéo lên?

189
00:12:59,000 --> 00:13:05,000
Được rồi, bạn có thể bắt đầu, lưu nó, bất cứ điều gì?

190
00:13:05,000 --> 00:13:09,000
Tôi luôn luôn quên rằng bước.

191
00:13:09,000 --> 00:13:15,000
Được rồi, nhìn push,

192
00:13:15,000 --> 00:13:18,000
nào bạn muốn để giải thích mã của bạn?

193
00:13:18,000 --> 00:13:24,000
[Sinh viên] Trước hết, tôi tăng kích thước.

194
00:13:24,000 --> 00:13:28,000
Tôi đoán có lẽ tôi nên có mà dù sao, tôi tăng kích thước,

195
00:13:28,000 --> 00:13:31,000
và tôi thấy nếu nó ít hơn so với khả năng.

196
00:13:31,000 --> 00:13:36,000
Và nếu nó ít hơn so với khả năng, tôi thêm vào các mảng mà chúng tôi đã có.

197
00:13:36,000 --> 00:13:42,000
Và nếu nó không phải, tôi nhân năng lực cho 2,

198
00:13:42,000 --> 00:13:50,000
và tôi tái phân bổ các mảng chuỗi đến một cái gì đó với một kích thước công suất lớn hơn.

199
00:13:50,000 --> 00:13:55,000
Và sau đó nếu thất bại, tôi nói với người sử dụng và trả về false,

200
00:13:55,000 --> 00:14:04,000
và nếu nó là tốt, sau đó tôi đặt chuỗi trong vị trí mới.

201
00:14:04,000 --> 00:14:07,000
>> [Rob B.] Cũng thông báo rằng chúng tôi đã sử dụng một nhà điều hành Bitwise tốt đẹp ở đây

202
00:14:07,000 --> 00:14:09,000
nhân cho 2.

203
00:14:09,000 --> 00:14:11,000
Hãy nhớ rằng, sự thay đổi trái luôn luôn là sẽ được nhân 2.

204
00:14:11,000 --> 00:14:15,000
Shift phải được chia cho 2 miễn là bạn nhớ rằng nó có nghĩa

205
00:14:15,000 --> 00:14:18,000
chia 2 như trong một số nguyên chia cho 2.

206
00:14:18,000 --> 00:14:20,000
Nó có thể cắt xén một 1 ở đây hoặc có.

207
00:14:20,000 --> 00:14:26,000
Nhưng sự thay đổi để lại 1 luôn luôn là sẽ được nhân 2,

208
00:14:26,000 --> 00:14:32,000
trừ khi bạn tràn giới hạn của các số nguyên, và sau đó nó sẽ không được.

209
00:14:32,000 --> 00:14:34,000
Một nhận xét bên cạnh.

210
00:14:34,000 --> 00:14:39,000
Tôi thích để làm điều này sẽ không thay đổi mã hóa bất kỳ cách nào,

211
00:14:39,000 --> 00:14:48,000
nhưng tôi muốn làm một cái gì đó như thế này.

212
00:14:48,000 --> 00:14:51,000
Nó thực sự là để làm cho nó dài hơn một chút.

213
00:15:04,000 --> 00:15:08,000
Có lẽ đây không phải là trường hợp hoàn hảo để hiển thị này,

214
00:15:08,000 --> 00:15:14,000
nhưng tôi muốn nó vào phân đoạn các khối of-

215
00:15:14,000 --> 00:15:17,000
okay, nếu điều này nếu xảy ra, thì tôi sẽ làm một cái gì đó,

216
00:15:17,000 --> 00:15:19,000
và sau đó chức năng được thực hiện.

217
00:15:19,000 --> 00:15:22,000
Tôi không cần kéo thanh cuộn đôi mắt của tôi tất cả các con đường xuống chức năng

218
00:15:22,000 --> 00:15:25,000
để xem những gì sẽ xảy ra sau khi người nào khác.

219
00:15:25,000 --> 00:15:27,000
Đó là nếu điều này nếu xảy ra, sau đó tôi chỉ trả lại.

220
00:15:27,000 --> 00:15:30,000
Nó cũng có thêm lợi ích tốt đẹp của tất cả mọi thứ ngoài này

221
00:15:30,000 --> 00:15:33,000
bây giờ chuyển trái một lần.

222
00:15:33,000 --> 00:15:40,000
Tôi không còn cần đến nếu bạn đã bao giờ gần ridiculously dài dòng,

223
00:15:40,000 --> 00:15:45,000
sau đó những 4 byte có thể giúp đỡ, và cũng là một cái gì đó trái nhiều hơn là,

224
00:15:45,000 --> 00:15:48,000
ít bị áp đảo bạn cảm thấy nếu như được rồi, tôi phải nhớ

225
00:15:48,000 --> 00:15:53,000
Tôi hiện đang trong một vòng lặp trong khi bên trong khác của một bên trong một vòng lặp for.

226
00:15:53,000 --> 00:15:58,000
Bất cứ nơi nào bạn có thể làm được điều này trở lại ngay lập tức, tôi giống như.

227
00:15:58,000 --> 00:16:05,000
Nó hoàn toàn tùy chọn và sẽ không bất kỳ cách nào.

228
00:16:05,000 --> 00:16:12,000
>> [Sinh viên] Nếu có một kích thước trong điều kiện thất bại?

229
00:16:12,000 --> 00:16:19,000
Điều kiện thất bại ở đây là chúng tôi không realloc, do đó có.

230
00:16:19,000 --> 00:16:22,000
Thông báo như thế nào trong điều kiện thất bại, có lẽ,

231
00:16:22,000 --> 00:16:26,000
trừ khi chúng tôi công cụ miễn phí sau, chúng tôi sẽ luôn luôn thất bại

232
00:16:26,000 --> 00:16:29,000
không có vấn đề bao nhiêu lần chúng ta cố gắng để đẩy một cái gì đó.

233
00:16:29,000 --> 00:16:32,000
Nếu chúng ta tiếp tục đẩy mạnh, chúng tôi giữ kích thước incrementing,

234
00:16:32,000 --> 00:16:36,000
mặc dù chúng tôi không đặt bất cứ điều gì vào stack.

235
00:16:36,000 --> 00:16:39,000
Thông thường chúng ta không tăng kích thước cho đến khi

236
00:16:39,000 --> 00:16:43,000
sau khi chúng tôi đã thành công đặt nó trên stack.

237
00:16:43,000 --> 00:16:50,000
Chúng tôi sẽ làm điều đó, nói rằng, hoặc là ở đây và ở đây.

238
00:16:50,000 --> 00:16:56,000
Và sau đó thay vì nói s.size ≤ công suất, nó ít hơn so với khả năng,

239
00:16:56,000 --> 00:17:01,000
chỉ vì chúng ta chuyển nơi tất cả mọi thứ đã được.

240
00:17:01,000 --> 00:17:07,000
>> Và hãy nhớ, nơi duy nhất mà chúng ta có thể có thể trả về false

241
00:17:07,000 --> 00:17:14,000
là ở đây, nơi realloc trở lại vô giá trị,

242
00:17:14,000 --> 00:17:19,000
và nếu bạn xảy ra để nhớ lỗi tiêu chuẩn,

243
00:17:19,000 --> 00:17:22,000
có thể bạn có thể xem xét trường hợp này là nơi mà bạn muốn in một lỗi tiêu chuẩn,

244
00:17:22,000 --> 00:17:26,000
fprintf stderr thay vì chỉ cần in trực tiếp để ra tiêu chuẩn.

245
00:17:26,000 --> 00:17:31,000
Một lần nữa, đó không phải là một kỳ vọng, nhưng nếu đó là một lỗi,

246
00:17:31,000 --> 00:17:41,000
gõ printf, sau đó bạn có thể muốn để làm cho nó in ra lỗi tiêu chuẩn thay vì ra tiêu chuẩn.

247
00:17:41,000 --> 00:17:44,000
>> Bất cứ ai có bất cứ điều gì khác cần lưu ý? Vâng.

248
00:17:44,000 --> 00:17:47,000
[Sinh viên] Bạn có thể đi qua [] không nghe được?

249
00:17:47,000 --> 00:17:55,000
[Rob B.], binariness thực tế của nó, hoặc chỉ những gì nó được?

250
00:17:55,000 --> 00:17:57,000
[Sinh viên] Vì vậy, bạn nhân nó 2 lần?

251
00:17:57,000 --> 00:17:59,000
[Rob B.] Yeah, về cơ bản.

252
00:17:59,000 --> 00:18:11,000
Trong đất nhị phân, chúng tôi luôn luôn có tập hợp các chữ số.

253
00:18:11,000 --> 00:18:22,000
Chuyển trái này bởi 1 về cơ bản chèn nó ở đây ở phía bên phải.

254
00:18:22,000 --> 00:18:25,000
Trở lại này, chỉ cần nhớ rằng tất cả mọi thứ trong hệ nhị phân

255
00:18:25,000 --> 00:18:28,000
là một sức mạnh của 2, do đó, điều này đại diện cho 2 0 các,

256
00:18:28,000 --> 00:18:30,000
2 đến 1, 2 với 2.

257
00:18:30,000 --> 00:18:33,000
Bằng cách chèn một 0 sang bên phải bây giờ, chúng tôi chỉ thay đổi tất cả mọi thứ trên.

258
00:18:33,000 --> 00:18:38,000
Những gì được sử dụng là 2 0 các bây giờ là 2 đến số 1, 2 với 2.

259
00:18:38,000 --> 00:18:41,000
Phía bên phải mà chúng tôi đưa vào

260
00:18:41,000 --> 00:18:44,000
nhất thiết sẽ là 0,

261
00:18:44,000 --> 00:18:46,000
có ý nghĩa.

262
00:18:46,000 --> 00:18:49,000
Nếu bạn đã bao giờ nhân một số bằng 2, nó sẽ không kết thúc kỳ lạ,

263
00:18:49,000 --> 00:18:54,000
vì vậy 2 đến nơi 0 là 0,

264
00:18:54,000 --> 00:18:59,000
và đây là những gì tôi nửa cảnh báo về trước là nếu bạn xảy ra để thay đổi

265
00:18:59,000 --> 00:19:01,000
vượt quá số bit trong một số nguyên,

266
00:19:01,000 --> 00:19:04,000
sau đó điều này 1 sẽ kết thúc đi ra.

267
00:19:04,000 --> 00:19:10,000
Đó là chỉ lo lắng nếu bạn xảy ra để đối phó với khả năng thực sự lớn.

268
00:19:10,000 --> 00:19:15,000
Tuy nhiên, tại thời điểm đó, sau đó bạn đang làm việc với một mảng tỷ thứ,

269
00:19:15,000 --> 00:19:25,000
mà có thể không phù hợp với bộ nhớ anyway.

270
00:19:25,000 --> 00:19:31,000
>> Bây giờ chúng ta có thể nhận được pop, mà thậm chí còn dễ dàng hơn.

271
00:19:31,000 --> 00:19:36,000
Bạn có thể làm điều đó như nếu bạn xảy ra để bật một bó toàn bộ,

272
00:19:36,000 --> 00:19:38,000
và bây giờ bạn đang nửa công suất một lần nữa.

273
00:19:38,000 --> 00:19:42,000
Bạn có thể realloc để thu nhỏ số lượng bộ nhớ mà bạn có,

274
00:19:42,000 --> 00:19:47,000
nhưng bạn không phải lo lắng về điều đó, vì vậy trường hợp realloc chỉ là có được

275
00:19:47,000 --> 00:19:50,000
phát triển bộ nhớ, không bao giờ thu hẹp lại bộ nhớ,

276
00:19:50,000 --> 00:19:59,000
đó là sẽ làm cho siêu pop dễ dàng.

277
00:19:59,000 --> 00:20:02,000
Bây giờ hàng đợi, mà sẽ được như ngăn xếp,

278
00:20:02,000 --> 00:20:06,000
nhưng thứ tự mà bạn thực hiện những điều trên được đảo ngược.

279
00:20:06,000 --> 00:20:10,000
Ví dụ nguyên mẫu của một hàng đợi là một dòng,

280
00:20:10,000 --> 00:20:12,000
vì vậy tôi đoán nếu bạn là người Anh, tôi sẽ nói

281
00:20:12,000 --> 00:20:17,000
một ví dụ nguyên mẫu của một hàng đợi là một hàng đợi.

282
00:20:17,000 --> 00:20:22,000
Vì vậy, như một dòng, nếu bạn là người đầu tiên trong dòng,

283
00:20:22,000 --> 00:20:24,000
bạn mong đợi để là người đầu tiên ra khỏi đường.

284
00:20:24,000 --> 00:20:31,000
Nếu bạn là người cuối cùng trong dòng, bạn sẽ là người cuối cùng phục vụ.

285
00:20:31,000 --> 00:20:35,000
Chúng tôi gọi đó là mô hình FIFO, trong khi ngăn xếp được LIFO mô hình.

286
00:20:35,000 --> 00:20:40,000
Những lời nói là khá phổ quát.

287
00:20:40,000 --> 00:20:46,000
>> Giống như ngăn xếp và không giống như mảng, hàng đợi thường không cho phép truy cập đến các yếu tố ở giữa.

288
00:20:46,000 --> 00:20:50,000
Ở đây, một chồng, chúng tôi có push và pop.

289
00:20:50,000 --> 00:20:54,000
Ở đây, chúng tôi xảy ra đã gọi họ enqueue và dequeue.

290
00:20:54,000 --> 00:20:58,000
Tôi cũng đã nghe họ gọi là thay đổi và unshift.

291
00:20:58,000 --> 00:21:02,000
Tôi đã nghe người ta nói push và pop cũng được áp dụng cho hàng đợi.

292
00:21:02,000 --> 00:21:05,000
Tôi đã nghe nói chèn, xóa,

293
00:21:05,000 --> 00:21:11,000
để đẩy và bật, nếu bạn đang nói về ngăn xếp, bạn đang đẩy mạnh và popping.

294
00:21:11,000 --> 00:21:16,000
Nếu bạn đang nói về hàng đợi, bạn có thể chọn những từ bạn muốn sử dụng

295
00:21:16,000 --> 00:21:23,000
để chèn và loại bỏ, và không có sự đồng thuận về những gì nó nên được gọi.

296
00:21:23,000 --> 00:21:27,000
Nhưng ở đây, chúng tôi có enqueue và dequeue.

297
00:21:27,000 --> 00:21:37,000
Bây giờ, cấu trúc trông gần giống như các cấu trúc ngăn xếp.

298
00:21:37,000 --> 00:21:40,000
Nhưng chúng ta phải theo dõi của người đứng đầu.

299
00:21:40,000 --> 00:21:44,000
Tôi đoán nó nói ở đây, nhưng tại sao chúng ta cần người đứng đầu?

300
00:21:53,000 --> 00:21:57,000
Các nguyên mẫu về cơ bản giống hệt nhau để đẩy và pop.

301
00:21:57,000 --> 00:21:59,000
Bạn có thể nghĩ về nó như là push và pop.

302
00:21:59,000 --> 00:22:08,000
Sự khác biệt duy nhất là pop đang trở lại-thay vì của người cuối cùng, nó trở về đầu tiên.

303
00:22:08,000 --> 00:22:12,000
2, 1, 3, 4, hoặc một cái gì đó.

304
00:22:12,000 --> 00:22:14,000
Và đây là sự bắt đầu.

305
00:22:14,000 --> 00:22:17,000
Hàng đợi của chúng tôi là hoàn toàn đầy đủ, do đó, có bốn yếu tố trong đó.

306
00:22:17,000 --> 00:22:21,000
Sự kết thúc của hàng đợi của chúng tôi hiện đang là 2,

307
00:22:21,000 --> 00:22:24,000
và bây giờ chúng tôi đi để chèn một cái gì đó khác.

308
00:22:24,000 --> 00:22:29,000
>> Khi chúng ta muốn chèn một điều gì đó khác, những gì chúng tôi đã làm cho phiên bản stack

309
00:22:29,000 --> 00:22:36,000
chúng tôi mở rộng khối bộ nhớ của chúng ta.

310
00:22:36,000 --> 00:22:40,000
Vấn đề này là gì?

311
00:22:40,000 --> 00:22:45,000
[Sinh viên] Bạn di chuyển 2.

312
00:22:45,000 --> 00:22:51,000
Những gì tôi đã nói trước về sự kết thúc của hàng đợi,

313
00:22:51,000 --> 00:22:57,000
điều này không có ý nghĩa mà chúng tôi bắt đầu từ 1,

314
00:22:57,000 --> 00:23:01,000
sau đó chúng tôi muốn để dequeue 1, sau đó dequeue 3, sau đó dequeue 4,

315
00:23:01,000 --> 00:23:05,000
sau đó dequeue 2, sau đó dequeue này.

316
00:23:05,000 --> 00:23:08,000
Chúng tôi không thể sử dụng realloc bây giờ,

317
00:23:08,000 --> 00:23:11,000
hoặc ít nhất, bạn phải sử dụng realloc theo một cách khác.

318
00:23:11,000 --> 00:23:15,000
Nhưng có lẽ bạn không nên chỉ cần sử dụng realloc.

319
00:23:15,000 --> 00:23:18,000
Bạn sẽ phải tự sao chép bộ nhớ của bạn.

320
00:23:18,000 --> 00:23:21,000
>> Có hai chức năng để sao chép bộ nhớ.

321
00:23:21,000 --> 00:23:25,000
Có memcopy và memmove.

322
00:23:25,000 --> 00:23:29,000
Tôi hiện đang đọc các trang người đàn ông xem cái nào bạn sẽ muốn sử dụng.

323
00:23:29,000 --> 00:23:35,000
Được rồi, memcopy, sự khác biệt

324
00:23:35,000 --> 00:23:38,000
memcopy và memmove, xử lý các trường hợp một cách chính xác

325
00:23:38,000 --> 00:23:41,000
nơi mà bạn đang sao chép vào một khu vực xảy ra chồng chéo các khu vực

326
00:23:41,000 --> 00:23:46,000
bạn đang sao chép từ.

327
00:23:46,000 --> 00:23:50,000
Memcopy không xử lý nó. Memmove.

328
00:23:50,000 --> 00:23:59,000
Bạn có thể nghĩ về các vấn đề như

329
00:23:59,000 --> 00:24:09,000
hãy nói rằng tôi muốn sao chép anh chàng này,

330
00:24:09,000 --> 00:24:13,000
bốn anh chàng này hơn.

331
00:24:13,000 --> 00:24:16,000
Cuối cùng, các mảng sẽ giống như

332
00:24:16,000 --> 00:24:26,000
sau khi sao chép là 2, 1, 2, 1, 3, 4, và sau đó một số công cụ ở cuối.

333
00:24:26,000 --> 00:24:29,000
Nhưng điều này phụ thuộc vào thứ tự mà chúng tôi thực sự sao chép,

334
00:24:29,000 --> 00:24:32,000
vì nếu chúng ta không xem xét thực tế rằng khu vực chúng tôi đang sao chép vào

335
00:24:32,000 --> 00:24:35,000
chồng chéo mà chúng ta đang sao chép từ,

336
00:24:35,000 --> 00:24:46,000
sau đó chúng ta có thể làm như bắt đầu ở đây, sao chép 2 vào nơi chúng ta muốn đi,

337
00:24:46,000 --> 00:24:52,000
sau đó di chuyển con trỏ của chúng tôi về phía trước.

338
00:24:52,000 --> 00:24:56,000
>> Bây giờ chúng ta sẽ ở đây và ở đây, và bây giờ chúng tôi muốn sao chép

339
00:24:56,000 --> 00:25:04,000
anh chàng này hơn anh chàng này và di chuyển con trỏ của chúng tôi về phía trước.

340
00:25:04,000 --> 00:25:07,000
Những gì chúng ta sẽ kết thúc nhận được là 2, 1, 2, 1, 2, 1

341
00:25:07,000 --> 00:25:10,000
thay vì thích hợp 2, 1, 2, 1, 3, 4 vì

342
00:25:10,000 --> 00:25:15,000
2, 1 overrode gốc 3, 4.

343
00:25:15,000 --> 00:25:19,000
Memmove xử lý một cách chính xác.

344
00:25:19,000 --> 00:25:23,000
Trong trường hợp này, về cơ bản chỉ cần luôn luôn sử dụng memmove

345
00:25:23,000 --> 00:25:26,000
bởi vì nó xử lý nó một cách chính xác.

346
00:25:26,000 --> 00:25:29,000
Nó thường không thực hiện bất kỳ tồi tệ.

347
00:25:29,000 --> 00:25:32,000
Ý tưởng là thay vì bắt đầu từ đầu và sao chép theo cách này

348
00:25:32,000 --> 00:25:35,000
như chúng ta đã làm ở đây, nó bắt đầu từ kết thúc và bản sao,

349
00:25:35,000 --> 00:25:38,000
và trong trường hợp đó, bạn có thể không bao giờ có một vấn đề.

350
00:25:38,000 --> 00:25:40,000
Không có hiệu suất bị mất.

351
00:25:40,000 --> 00:25:47,000
Luôn luôn sử dụng memmove. Không bao giờ lo lắng về memcopy.

352
00:25:47,000 --> 00:25:51,000
Và đó là nơi bạn sẽ có riêng memmove

353
00:25:51,000 --> 00:26:01,000
phần bao bọc xung quanh hàng đợi của bạn.

354
00:26:01,000 --> 00:26:04,000
Không có lo lắng nếu không hoàn toàn thực hiện.

355
00:26:04,000 --> 00:26:10,000
Điều này là khó khăn hơn so với stack, push và pop.

356
00:26:10,000 --> 00:26:15,000
>> Bất cứ ai có bất kỳ mã, chúng ta có thể làm việc với?

357
00:26:15,000 --> 00:26:21,000
Ngay cả khi hoàn toàn không đầy đủ?

358
00:26:21,000 --> 00:26:23,000
[Sinh viên] Yeah, nó hoàn toàn không đầy đủ, mặc dù.

359
00:26:23,000 --> 00:26:27,000
Hoàn toàn không đầy đủ là tốt miễn là chúng ta có thể lưu các sửa đổi?

360
00:26:27,000 --> 00:26:32,000
Tôi quên rằng mỗi lần duy nhất.

361
00:26:32,000 --> 00:26:39,000
Được rồi, bỏ qua những gì sẽ xảy ra khi chúng ta cần phải thay đổi kích thước điều.

362
00:26:39,000 --> 00:26:42,000
Hoàn toàn bỏ qua thay đổi kích cỡ.

363
00:26:42,000 --> 00:26:49,000
Giải thích mã này.

364
00:26:49,000 --> 00:26:54,000
Tôi đang kiểm tra đầu tiên của tất cả các kích thước là ít hơn so với bản sao đầu tiên của tất cả các

365
00:26:54,000 --> 00:27:01,000
và sau đó sau đó, tôi chèn-I lấy đầu + kích thước,

366
00:27:01,000 --> 00:27:05,000
và tôi chắc chắn rằng nó kết thúc tốt đẹp xung quanh khả năng của mảng,

367
00:27:05,000 --> 00:27:08,000
và tôi chèn chuỗi mới ở vị trí đó.

368
00:27:08,000 --> 00:27:12,000
Sau đó, tôi tăng kích thước và trả lại đúng sự thật.

369
00:27:12,000 --> 00:27:22,000
>> [Rob B.] Điều này chắc chắn là một trong những trường hợp mà bạn sẽ muốn được sử dụng mod.

370
00:27:22,000 --> 00:27:25,000
Bất kỳ loại trường hợp, nơi bạn có gói xung quanh, nếu bạn nghĩ rằng gói xung quanh,

371
00:27:25,000 --> 00:27:29,000
những suy nghĩ ngay lập tức nên mod.

372
00:27:29,000 --> 00:27:36,000
Là một tối ưu hóa nhanh chóng / mã một dòng của bạn ngắn hơn,

373
00:27:36,000 --> 00:27:42,000
bạn nhận thấy rằng các dòng sau này

374
00:27:42,000 --> 00:27:53,000
chỉ là kích thước + +, do đó, bạn nhập vào dòng này, kích thước + +.

375
00:27:53,000 --> 00:27:58,000
Bây giờ ở đây, chúng ta có các trường hợp

376
00:27:58,000 --> 00:28:01,000
mà chúng ta không có đủ bộ nhớ,

377
00:28:01,000 --> 00:28:05,000
vì vậy chúng tôi đang gia tăng năng lực của chúng tôi 2.

378
00:28:05,000 --> 00:28:09,000
Tôi đoán bạn có thể có cùng một vấn đề ở đây, nhưng chúng ta có thể bỏ qua nó,

379
00:28:09,000 --> 00:28:13,000
mà nếu bạn thất bại trong việc nâng cao năng lực của bạn,

380
00:28:13,000 --> 00:28:18,000
sau đó bạn sẽ muốn làm giảm năng lực của bạn 2 lần nữa.

381
00:28:18,000 --> 00:28:24,000
Một lưu ý ngắn gọn là giống như bạn có thể làm + =,

382
00:28:24,000 --> 00:28:30,000
bạn cũng có thể làm << =.

383
00:28:30,000 --> 00:28:43,000
Hầu như bất cứ điều gì có thể đi trước bằng, + =, | =, & =, << =

384
00:28:43,000 --> 00:28:52,000
Char * mới là khối bộ nhớ mới của chúng tôi.

385
00:28:52,000 --> 00:28:55,000
Oh, ở đây.

386
00:28:55,000 --> 00:29:02,000
>> Làm gì mọi người nghĩ về các loại của khối bộ nhớ mới của chúng tôi?

387
00:29:02,000 --> 00:29:06,000
[Sinh viên] Nó sẽ được char **.

388
00:29:06,000 --> 00:29:12,000
Nghĩ về cấu trúc của chúng tôi ở đây,

389
00:29:12,000 --> 00:29:14,000
dây là những gì chúng tôi đang phân bổ lại.

390
00:29:14,000 --> 00:29:21,000
Chúng tôi đang làm cho một lưu trữ toàn bộ mới năng động cho các phần tử trong hàng đợi.

391
00:29:21,000 --> 00:29:25,000
Những gì chúng ta sẽ được gán cho chuỗi của bạn là những gì chúng tôi đang mallocing ngay bây giờ,

392
00:29:25,000 --> 00:29:30,000
và như vậy mới là có được một char **.

393
00:29:30,000 --> 00:29:34,000
Nó sẽ là một mảng của chuỗi.

394
00:29:34,000 --> 00:29:38,000
Sau đó, các trường hợp theo đó chúng tôi đang đi để trả lại sai là gì?

395
00:29:38,000 --> 00:29:41,000
[Sinh viên] Chúng ta có nên làm char *?

396
00:29:41,000 --> 00:29:44,000
[Rob B.] Vâng, cuộc gọi tốt.

397
00:29:44,000 --> 00:29:46,000
[Sinh viên] Cái gì thế?

398
00:29:46,000 --> 00:29:49,000
[Rob B. Chúng tôi muốn làm kích thước của char * bởi vì chúng ta không còn

399
00:29:49,000 --> 00:29:53,000
điều này thực sự sẽ là một vấn đề rất lớn bởi vì sizeof (char) sẽ là 1.

400
00:29:53,000 --> 00:29:55,000
Sizeof char * sẽ là 4,

401
00:29:55,000 --> 00:29:58,000
vì vậy rất nhiều lần khi bạn đang làm việc với ints,

402
00:29:58,000 --> 00:30:01,000
bạn có xu hướng để có được đi với nó bởi vì kích thước của int và kích thước của int *

403
00:30:01,000 --> 00:30:04,000
trên một hệ thống 32-bit đang có được điều tương tự.

404
00:30:04,000 --> 00:30:09,000
Nhưng ở đây, sizeof (char) và sizeof (char *) là sẽ được điều tương tự.

405
00:30:09,000 --> 00:30:15,000
>> Hoàn cảnh, nơi chúng tôi quay trở lại sai là gì?

406
00:30:15,000 --> 00:30:17,000
[Sinh viên] là null.

407
00:30:17,000 --> 00:30:23,000
Yeah, nếu mới là vô giá trị, chúng tôi quay trở lại sai,

408
00:30:23,000 --> 00:30:34,000
và tôi sẽ ném xuống đây

409
00:30:34,000 --> 00:30:37,000
[Sinh viên] [không nghe được]

410
00:30:37,000 --> 00:30:39,000
[Rob B.] Yeah, điều này là tốt.

411
00:30:39,000 --> 00:30:46,000
Bạn có thể có thể làm 2 lần công suất hoặc 1 ca năng lực và sau đó chỉ đặt nó ở đây hoặc bất cứ điều gì.

412
00:30:46,000 --> 00:30:52,000
Chúng tôi sẽ làm điều đó như chúng tôi đã có nó.

413
00:30:52,000 --> 00:30:56,000
Công suất >> = 1.

414
00:30:56,000 --> 00:31:08,000
Và bạn sẽ không bao giờ phải lo lắng về việc bị mất vị trí số 1

415
00:31:08,000 --> 00:31:12,000
bởi vì bạn còn lại chuyển bằng 1, vì vậy số 1 nơi nhất thiết phải là một 0,

416
00:31:12,000 --> 00:31:16,000
như vậy ngay chuyển bằng 1, bạn vẫn sẽ được sử dụng tốt.

417
00:31:16,000 --> 00:31:19,000
[Sinh viên bạn cần phải làm điều đó trước khi trở về?

418
00:31:19,000 --> 00:31:29,000
[Rob B. Có, điều này làm cho hoàn toàn không có ý nghĩa.

419
00:31:29,000 --> 00:31:36,000
>> Bây giờ giả sử chúng ta sẽ kết thúc trở về đúng để kết thúc.

420
00:31:36,000 --> 00:31:39,000
Cách chúng ta sẽ làm những memmoves,

421
00:31:39,000 --> 00:31:45,000
chúng ta cần phải cẩn thận với cách chúng tôi làm cho họ.

422
00:31:45,000 --> 00:31:50,000
Có ai có bất cứ lời đề nghị làm thế nào chúng ta làm cho họ?

423
00:32:17,000 --> 00:32:21,000
Đây là khởi đầu của chúng tôi.

424
00:32:21,000 --> 00:32:28,000
Chắc chắn, chúng tôi muốn bắt đầu từ đầu một lần nữa

425
00:32:28,000 --> 00:32:35,000
và sao chép những thứ từ đó, 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
Làm thế nào để bạn làm điều đó?

427
00:32:41,000 --> 00:32:52,000
Trước tiên, tôi phải nhìn vào trang người đàn ông cho memmove một lần nữa.

428
00:32:52,000 --> 00:32:57,000
Memmove, trật tự của các đối số luôn luôn là quan trọng.

429
00:32:57,000 --> 00:33:01,000
Chúng tôi muốn đích của chúng tôi đầu tiên, nguồn thứ hai, kích thước 3.

430
00:33:01,000 --> 00:33:06,000
Hiện có rất nhiều các chức năng đảo ngược nguồn và đích.

431
00:33:06,000 --> 00:33:11,000
Nguồn đích, có xu hướng để phù hợp phần nào.

432
00:33:17,000 --> 00:33:21,000
Di chuyển, những gì là nó trở về?

433
00:33:21,000 --> 00:33:27,000
Nó trả về một con trỏ đến đích, vì lý do gì bạn có thể muốn điều đó.

434
00:33:27,000 --> 00:33:32,000
Tôi hình ảnh có thể đọc nó, nhưng chúng tôi muốn chuyển vào đích của chúng tôi.

435
00:33:32,000 --> 00:33:35,000
>> Đích của chúng tôi là gì được không?

436
00:33:35,000 --> 00:33:37,000
[Sinh viên].

437
00:33:37,000 --> 00:33:39,000
[Rob B.] Có, và nơi chúng ta sao chép từ?

438
00:33:39,000 --> 00:33:43,000
Điều đầu tiên chúng tôi được sao chép này là 1, 3, 4.

439
00:33:43,000 --> 00:33:50,000
-1 là gì, 3, 4.

440
00:33:50,000 --> 00:33:55,000
Địa chỉ này 1 là gì?

441
00:33:55,000 --> 00:33:58,000
Địa chỉ rằng 1 là gì?

442
00:33:58,000 --> 00:34:01,000
[Sinh viên] [không nghe được]

443
00:34:01,000 --> 00:34:03,000
Rob B. Head + địa chỉ của các yếu tố đầu tiên.

444
00:34:03,000 --> 00:34:05,000
Làm thế nào để chúng ta có được những yếu tố đầu tiên trong mảng?

445
00:34:05,000 --> 00:34:10,000
[Sinh viên] Queue.

446
00:34:10,000 --> 00:34:15,000
[Rob B.] Vâng, q.strings.

447
00:34:15,000 --> 00:34:20,000
Hãy nhớ rằng, ở đây, người đứng đầu của chúng tôi là 1.

448
00:34:20,000 --> 00:34:24,000
Darn. Tôi chỉ nghĩ rằng đó là kỳ diệu

449
00:34:24,000 --> 00:34:29,000
Ở đây, người đứng đầu của chúng tôi là 1. Tôi sẽ thay đổi màu sắc của tôi quá.

450
00:34:29,000 --> 00:34:36,000
Và đây là chuỗi.

451
00:34:36,000 --> 00:34:41,000
Này, chúng tôi có thể viết nó như là chúng tôi đã làm ở đây

452
00:34:41,000 --> 00:34:43,000
với người đứng đầu + q.strings.

453
00:34:43,000 --> 00:34:51,000
Rất nhiều người cũng viết & q.strings [đầu].

454
00:34:51,000 --> 00:34:55,000
Đây không phải là thực sự bất kỳ kém hiệu quả hơn.

455
00:34:55,000 --> 00:34:58,000
Bạn có thể nghĩ về nó như là bạn đang dereferencing nó và sau đó nhận được địa chỉ,

456
00:34:58,000 --> 00:35:04,000
nhưng trình biên dịch sẽ dịch nó với những gì chúng ta đã có trước khi anyway, q.strings + đầu.

457
00:35:04,000 --> 00:35:06,000
Dù bằng cách nào bạn muốn nghĩ về nó.

458
00:35:06,000 --> 00:35:11,000
>> Và có bao nhiêu byte chúng ta muốn sao chép?

459
00:35:11,000 --> 00:35:15,000
[Sinh viên] - đầu năng lực.

460
00:35:15,000 --> 00:35:18,000
Đầu năng lực.

461
00:35:18,000 --> 00:35:21,000
Và sau đó bạn luôn luôn có thể viết ra một ví dụ

462
00:35:21,000 --> 00:35:23,000
để tìm ra nếu đó là đúng.

463
00:35:23,000 --> 00:35:26,000
[Sinh viên] Nó cần phải được chia bởi 2 sau đó.

464
00:35:26,000 --> 00:35:30,000
Yeah, vì vậy tôi đoán chúng ta có thể sử dụng kích thước.

465
00:35:30,000 --> 00:35:35,000
Chúng tôi vẫn có kích thước là-

466
00:35:35,000 --> 00:35:39,000
sử dụng kích thước, chúng tôi có kích thước bằng 4.

467
00:35:39,000 --> 00:35:42,000
Kích thước của chúng tôi là 4. Đầu của chúng tôi là 1.

468
00:35:42,000 --> 00:35:46,000
Chúng tôi muốn sao chép 3 yếu tố này.

469
00:35:46,000 --> 00:35:54,000
Đó là sanity kiểm tra xem kích thước đầu là chính xác 3.

470
00:35:54,000 --> 00:35:58,000
Và trở lại đây, giống như chúng tôi đã nói trước,

471
00:35:58,000 --> 00:36:00,000
nếu chúng ta sử dụng năng lực, sau đó chúng tôi phải chia 2

472
00:36:00,000 --> 00:36:04,000
bởi vì chúng tôi đã phát triển năng lực của chúng tôi, do đó, thay vì, chúng ta sẽ sử dụng kích thước.

473
00:36:11,000 --> 00:36:13,000
Rằng các bản sao phần đó.

474
00:36:13,000 --> 00:36:18,000
Bây giờ, chúng ta cần để sao chép các phần khác, phần còn lại của đầu.

475
00:36:18,000 --> 00:36:28,000
>> Đó sẽ memmove vào những gì vị trí?

476
00:36:28,000 --> 00:36:32,000
[Sinh viên] cộng với kích thước đầu.

477
00:36:32,000 --> 00:36:38,000
Có, vì vậy chúng tôi đã sao chép kích thước byte đầu,

478
00:36:38,000 --> 00:36:43,000
và vì vậy mà chúng ta muốn sao chép các byte còn lại là mới

479
00:36:43,000 --> 00:36:48,000
và sau đó kích thước trừ-tốt, số byte, chúng tôi đã sao chép.

480
00:36:48,000 --> 00:36:52,000
Và sau đó chúng tôi sao chép từ?

481
00:36:52,000 --> 00:36:54,000
[Sinh viên] Q.strings [0].

482
00:36:54,000 --> 00:36:56,000
[Rob B.] Vâng, q.strings.

483
00:36:56,000 --> 00:37:02,000
Chúng tôi có thể làm q.strings [0].

484
00:37:02,000 --> 00:37:05,000
Điều này là đáng kể ít phổ biến hơn này.

485
00:37:05,000 --> 00:37:14,000
Nếu nó chỉ là 0, sau đó bạn sẽ có xu hướng để xem q.strings.

486
00:37:14,000 --> 00:37:16,000
Đó là nơi mà chúng tôi đang sao chép từ.

487
00:37:16,000 --> 00:37:18,000
Chúng tôi đã có bao nhiêu byte còn lại để sao chép? >> [Sinh viên] 10.

488
00:37:18,000 --> 00:37:20,000
Đúng.

489
00:37:20,000 --> 00:37:25,000
[Sinh viên] Chúng ta phải nhân 5 - 10 lần kích thước của các byte hoặc một cái gì đó?

490
00:37:25,000 --> 00:37:30,000
Yeah, vì vậy đây là nơi mà chính xác những gì chúng ta sao chép?

491
00:37:30,000 --> 00:37:32,000
[Sinh viên] [không nghe được]

492
00:37:32,000 --> 00:37:34,000
Loại trong những điều chúng ta đang sao chép là gì?

493
00:37:34,000 --> 00:37:36,000
[Sinh viên] [không nghe được]

494
00:37:36,000 --> 00:37:41,000
Yeah, vì vậy char * chúng tôi đang sao chép, chúng tôi không biết nơi mà những người đang đến từ.

495
00:37:41,000 --> 00:37:47,000
Vâng, họ đang trỏ đến, giống như các chuỗi, chúng tôi kết thúc đẩy nó vào hàng đợi

496
00:37:47,000 --> 00:37:49,000
hoặc enqueuing vào hàng đợi.

497
00:37:49,000 --> 00:37:51,000
Nơi mà những người đến từ đâu, chúng tôi không có ý tưởng.

498
00:37:51,000 --> 00:37:56,000
Chúng ta chỉ cần để theo dõi các s * char mình.

499
00:37:56,000 --> 00:38:00,000
Chúng tôi không muốn để sao chép kích thước byte đầu.

500
00:38:00,000 --> 00:38:03,000
Chúng tôi muốn sao chép kích thước đầu char * s,

501
00:38:03,000 --> 00:38:11,000
do đó, chúng ta sẽ nhân này bằng sizeof (char *).

502
00:38:11,000 --> 00:38:17,000
Cùng xuống đây, người đứng đầu * sizeof (char *).

503
00:38:17,000 --> 00:38:24,000
>> [Sinh viên] về [không nghe được?

504
00:38:24,000 --> 00:38:26,000
Quyền này ở đây?

505
00:38:26,000 --> 00:38:28,000
[Sinh viên] Không có, dưới đây, kích thước đầu.

506
00:38:28,000 --> 00:38:30,000
[Rob B. Điều này ngay tại đây?

507
00:38:30,000 --> 00:38:32,000
Con trỏ số học.

508
00:38:32,000 --> 00:38:35,000
Làm thế nào để con trỏ số học là sẽ làm việc

509
00:38:35,000 --> 00:38:40,000
nó sẽ tự động nhân bởi kích thước của các loại mà chúng ta đang đối phó với.

510
00:38:40,000 --> 00:38:46,000
Cũng giống như ở đây, mới + (size - đầu)

511
00:38:46,000 --> 00:38:56,000
là chính xác tương đương với & [size đầu]

512
00:38:56,000 --> 00:39:00,000
cho đến khi chúng tôi hy vọng rằng để làm việc một cách chính xác,

513
00:39:00,000 --> 00:39:04,000
vì nếu chúng ta đang đối phó với một mảng int, sau đó chúng tôi không chỉ số int-

514
00:39:04,000 --> 00:39:07,000
hoặc nếu đó là kích thước của 5 và bạn muốn các yếu tố thứ 4, sau đó chúng tôi lập chỉ mục vào

515
00:39:07,000 --> 00:39:10,000
int array [4].

516
00:39:10,000 --> 00:39:14,000
Bạn đừng-[4] * kích thước của int.

517
00:39:14,000 --> 00:39:21,000
Xử lý tự động, và trường hợp này

518
00:39:21,000 --> 00:39:29,000
có nghĩa là tương đương, do đó, các cú pháp khung

519
00:39:29,000 --> 00:39:34,000
chỉ cần đi để được chuyển đổi này ngay sau khi bạn biên dịch.

520
00:39:34,000 --> 00:39:38,000
Đó là điều mà bạn cần phải cẩn thận đó

521
00:39:38,000 --> 00:39:42,000
khi bạn đang thêm kích thước đầu

522
00:39:42,000 --> 00:39:45,000
bạn có thêm không phải là một byte.

523
00:39:45,000 --> 00:39:53,000
Bạn thêm một char *, có thể là một byte hoặc bất cứ điều gì.

524
00:39:53,000 --> 00:39:56,000
>> Các câu hỏi khác?

525
00:39:56,000 --> 00:40:04,000
Được rồi, dequeue sẽ được dễ dàng hơn.

526
00:40:04,000 --> 00:40:11,000
Tôi sẽ cung cấp cho bạn một phút để thực hiện.

527
00:40:11,000 --> 00:40:18,000
Oh, và tôi đoán đây là tình hình tương tự

528
00:40:18,000 --> 00:40:21,000
trường hợp enqueue, nếu chúng ta đang enqueuing null,

529
00:40:21,000 --> 00:40:24,000
có lẽ chúng ta muốn để xử lý nó, có lẽ chúng tôi không.

530
00:40:24,000 --> 00:40:27,000
Chúng tôi sẽ không làm điều đó một lần nữa ở đây, nhưng giống như trường hợp chồng của chúng tôi.

531
00:40:27,000 --> 00:40:34,000
Nếu chúng ta enqueue null, chúng tôi có thể muốn bỏ qua nó.

532
00:40:34,000 --> 00:40:40,000
Bất cứ ai cũng có một số mã tôi có thể kéo lên?

533
00:40:40,000 --> 00:40:45,000
[Sinh viên] Tôi chỉ có dequeue.

534
00:40:45,000 --> 00:40:56,000
Phiên bản 2 là được rồi.

535
00:40:56,000 --> 00:40:59,000
Bạn muốn giải thích?

536
00:40:59,000 --> 00:41:01,000
[Sinh viên] Đầu tiên, bạn hãy chắc chắn có điều gì đó trong hàng đợi

537
00:41:01,000 --> 00:41:07,000
và rằng kích thước sẽ giảm 1.

538
00:41:07,000 --> 00:41:11,000
Bạn cần phải làm điều đó, và sau đó bạn trở về đầu

539
00:41:11,000 --> 00:41:13,000
và sau đó di chuyển đầu lập 1.

540
00:41:13,000 --> 00:41:19,000
Được rồi, do đó, có một trường hợp góc chúng ta phải xem xét. Yeah.

541
00:41:19,000 --> 00:41:24,000
[Sinh viên] Nếu đầu của bạn là yếu tố cuối cùng,

542
00:41:24,000 --> 00:41:26,000
sau đó bạn không muốn đầu đến điểm bên ngoài của mảng.

543
00:41:26,000 --> 00:41:29,000
>> Yeah, vì vậy ngay sau khi đầu chạm cuối mảng của chúng tôi,

544
00:41:29,000 --> 00:41:35,000
khi chúng ta dequeue, đầu của chúng tôi nên được modded trở về 0.

545
00:41:35,000 --> 00:41:40,000
Thật không may, chúng tôi không thể làm điều đó trong một bước.

546
00:41:40,000 --> 00:41:44,000
Tôi đoán là cách tôi có thể sửa chữa nó là

547
00:41:44,000 --> 00:41:52,000
này là có được một char *, những gì chúng ta đang quay trở lại,

548
00:41:52,000 --> 00:41:55,000
bất cứ tên biến của bạn muốn trở thành.

549
00:41:55,000 --> 00:42:02,000
Sau đó, chúng tôi muốn để mod đầu bởi năng lực của chúng tôi

550
00:42:02,000 --> 00:42:10,000
và sau đó trở về ret.

551
00:42:10,000 --> 00:42:14,000
Rất nhiều người dân ở đây, họ có thể làm

552
00:42:14,000 --> 00:42:19,000
đây là trường hợp của-bạn sẽ thấy mọi người làm đầu

553
00:42:19,000 --> 00:42:29,000
lớn hơn năng lực, làm đầu năng lực.

554
00:42:29,000 --> 00:42:36,000
Và đó chỉ là làm việc xung quanh mod là gì.

555
00:42:36,000 --> 00:42:41,000
Trưởng mod = công suất là rất sạch hơn

556
00:42:41,000 --> 00:42:51,000
của một gói xung quanh hơn nếu đầu lớn hơn so với khả năng đầu năng lực.

557
00:42:51,000 --> 00:42:56,000
>> Câu hỏi?

558
00:42:56,000 --> 00:43:02,000
Được rồi, điều cuối cùng chúng ta đã để lại là danh sách liên kết của chúng tôi.

559
00:43:02,000 --> 00:43:07,000
Bạn có thể sử dụng một số hành vi của danh sách liên kết nếu bạn đã làm

560
00:43:07,000 --> 00:43:11,000
danh sách liên kết trong bảng băm của bạn, nếu bạn đã làm một bảng băm.

561
00:43:11,000 --> 00:43:15,000
Tôi mạnh mẽ khuyên bạn nên làm một bảng băm.

562
00:43:15,000 --> 00:43:17,000
Bạn có thể đã thực hiện một Trie,

563
00:43:17,000 --> 00:43:23,000
nhưng cố gắng là khó khăn hơn.

564
00:43:23,000 --> 00:43:27,000
Về lý thuyết, họ đang tiệm cận tốt hơn.

565
00:43:27,000 --> 00:43:30,000
Nhưng chỉ cần nhìn vào bảng lớn,

566
00:43:30,000 --> 00:43:35,000
và cố gắng không bao giờ làm tốt hơn, và chúng chiếm nhiều bộ nhớ hơn.

567
00:43:35,000 --> 00:43:43,000
Mọi thứ về cố gắng kết thúc lên được tồi tệ hơn cho công việc nhiều hơn.

568
00:43:43,000 --> 00:43:49,000
Đó là những gì David Malan của giải pháp luôn luôn là

569
00:43:49,000 --> 00:43:56,000
ông luôn luôn giải pháp Trie của mình, và chúng ta hãy xem nơi ông hiện nay là.

570
00:43:56,000 --> 00:44:00,000
Ông là gì theo, David J?

571
00:44:00,000 --> 00:44:06,000
# 18, do đó, không phải terribly,

572
00:44:06,000 --> 00:44:09,000
và đó sẽ là một trong những cố gắng bạn có thể nghĩ

573
00:44:09,000 --> 00:44:17,000
hoặc một trong những cố gắng của Trie.

574
00:44:17,000 --> 00:44:23,000
Đó không phải là giải pháp ban đầu của mình?

575
00:44:23,000 --> 00:44:29,000
Tôi cảm thấy như Trie giải pháp có xu hướng được nhiều hơn trong phạm vi này sử dụng bộ nhớ RAM.

576
00:44:29,000 --> 00:44:33,000
>> Đi xuống đầu, và RAM sử dụng trong các chữ số duy nhất.

577
00:44:33,000 --> 00:44:36,000
Đi xuống hướng phía dưới, và sau đó bạn bắt đầu thấy cố gắng

578
00:44:36,000 --> 00:44:41,000
nơi bạn có sử dụng RAM hoàn toàn lớn,

579
00:44:41,000 --> 00:44:45,000
và cố gắng khó khăn hơn.

580
00:44:45,000 --> 00:44:53,000
Không hoàn toàn giá trị nó nhưng một kinh nghiệm giáo dục nếu bạn đã làm một.

581
00:44:53,000 --> 00:44:56,000
Điều cuối cùng là danh sách liên kết của chúng tôi,

582
00:44:56,000 --> 00:45:04,000
và những ba điều, ngăn xếp, hàng đợi và danh sách liên kết,

583
00:45:04,000 --> 00:45:09,000
bất cứ điều gì trong tương lai bao giờ bạn làm trong lĩnh vực khoa học máy tính

584
00:45:09,000 --> 00:45:12,000
sẽ cho rằng bạn có quen với những điều này.

585
00:45:12,000 --> 00:45:19,000
Họ là những nguyên tắc cơ bản cho tất cả mọi thứ.

586
00:45:19,000 --> 00:45:25,000
>> Danh sách liên kết, và ở đây chúng tôi có một danh sách đơn lẻ liên kết là có được việc thực hiện của chúng tôi.

587
00:45:25,000 --> 00:45:34,000
Những gì không liên kết đơn lẻ có nghĩa là như trái ngược với liên kết kép? Vâng.

588
00:45:34,000 --> 00:45:37,000
[Sinh viên] Nó chỉ chỉ vào con trỏ tiếp theo thay vì các con trỏ,

589
00:45:37,000 --> 00:45:39,000
giống như một trước và một sau khi nó.

590
00:45:39,000 --> 00:45:44,000
Yeah, do đó, trong định dạng hình ảnh, tôi đã làm những gì chỉ cần làm?

591
00:45:44,000 --> 00:45:48,000
Tôi có hai điều. Tôi có hình ảnh và hình ảnh.

592
00:45:48,000 --> 00:45:51,000
Trong bức ảnh định dạng, liên kết đơn lẻ của chúng tôi danh sách,

593
00:45:51,000 --> 00:45:57,000
chắc chắn, chúng tôi có một số loại con trỏ đến người đứng đầu danh sách của chúng tôi,

594
00:45:57,000 --> 00:46:02,000
và sau đó trong danh sách của chúng tôi, chúng tôi chỉ có con trỏ,

595
00:46:02,000 --> 00:46:05,000
và có thể điều này dẫn đến giá trị null.

596
00:46:05,000 --> 00:46:08,000
Nó sẽ là bản vẽ điển hình của bạn của một danh sách liên kết đơn lẻ.

597
00:46:08,000 --> 00:46:14,000
Một danh sách liên kết kép, bạn có thể đi ngược.

598
00:46:14,000 --> 00:46:19,000
Nếu tôi cung cấp cho bạn bất kỳ nút nào trong danh sách, sau đó nhất thiết các bạn có thể nhận được để

599
00:46:19,000 --> 00:46:23,000
bất kỳ nút khác trong danh sách nếu nó là một danh sách liên kết kép.

600
00:46:23,000 --> 00:46:27,000
Nhưng nếu tôi nhận được nút thứ ba trong danh sách và nó là một danh sách liên kết đơn lẻ,

601
00:46:27,000 --> 00:46:30,000
không có cách nào bạn đã bao giờ đi để có được các nút đầu tiên và thứ hai.

602
00:46:30,000 --> 00:46:34,000
Và có lợi ích và detriments, và một trong những rõ ràng

603
00:46:34,000 --> 00:46:42,000
là bạn mất nhiều kích cỡ, và bạn có để theo dõi những điều này chỉ bây giờ.

604
00:46:42,000 --> 00:46:49,000
Nhưng chúng tôi chỉ quan tâm đơn lẻ liên kết.

605
00:46:49,000 --> 00:46:53,000
>> Một số điều chúng ta sẽ phải thực hiện.

606
00:46:53,000 --> 00:47:00,000
Nút struct typedef của bạn, int i: struct node * next; nút.

607
00:47:00,000 --> 00:47:09,000
Đó typedef nên được đốt cháy vào trong tâm trí của bạn.

608
00:47:09,000 --> 00:47:14,000
Bài kiểm tra 1 phải được cung cấp cho một typedef của một nút danh sách liên kết,

609
00:47:14,000 --> 00:47:18,000
và bạn sẽ có thể ngay lập tức scribble mà xuống

610
00:47:18,000 --> 00:47:22,000
mà không cần suy nghĩ về nó.

611
00:47:22,000 --> 00:47:27,000
Tôi đoán một vài câu hỏi, tại sao chúng ta cần cấu trúc ở đây?

612
00:47:27,000 --> 00:47:32,000
Tại sao chúng ta không thể nói rằng * nút?

613
00:47:32,000 --> 00:47:35,000
[Sinh viên] [không nghe được]

614
00:47:35,000 --> 00:47:38,000
Yeah.

615
00:47:38,000 --> 00:47:44,000
Điều duy nhất mà xác định một nút như một điều

616
00:47:44,000 --> 00:47:47,000
là typedef chính nó.

617
00:47:47,000 --> 00:47:55,000
Nhưng kể từ thời điểm này, khi chúng ta đang loại phân tích cú pháp thông qua định nghĩa này nút struct,

618
00:47:55,000 --> 00:48:01,000
chúng tôi đã không hoàn thành typedef của chúng tôi, do đó, kể từ khi typedef đã không hoàn thành,

619
00:48:01,000 --> 00:48:05,000
nút không tồn tại.

620
00:48:05,000 --> 00:48:12,000
Nhưng struct node không có gì, và nút này ở đây,

621
00:48:12,000 --> 00:48:14,000
điều này cũng có thể được gọi là bất cứ điều gì khác.

622
00:48:14,000 --> 00:48:16,000
Điều này có thể được gọi là n.

623
00:48:16,000 --> 00:48:19,000
Nó có thể được gọi là danh sách các node liên kết.

624
00:48:19,000 --> 00:48:21,000
Nó có thể được gọi là bất cứ điều gì.

625
00:48:21,000 --> 00:48:26,000
Tuy nhiên, cấu trúc node này cần phải được gọi là điều tương tự như cấu trúc node này.

626
00:48:26,000 --> 00:48:29,000
Những gì bạn gọi điều này cũng có mặt ở đây,

627
00:48:29,000 --> 00:48:32,000
và vì vậy mà cũng trả lời điểm thứ hai của câu hỏi

628
00:48:32,000 --> 00:48:37,000
đó là lý do tại sao rất nhiều lần khi bạn nhìn thấy cấu trúc và typedefs của cấu trúc,

629
00:48:37,000 --> 00:48:42,000
bạn sẽ thấy các cấu trúc vô danh hợp bạn sẽ chỉ nhìn thấy struct typedef,

630
00:48:42,000 --> 00:48:47,000
thực hiện từ điển, cấu trúc, hoặc bất cứ điều gì.

631
00:48:47,000 --> 00:48:51,000
>> Tại sao ở đây chúng ta cần nói nút?

632
00:48:51,000 --> 00:48:54,000
Tại sao nó không thể là một cấu trúc vô danh?

633
00:48:54,000 --> 00:48:56,000
Nó gần như cùng một câu trả lời.

634
00:48:56,000 --> 00:48:58,000
[Sinh viên] Bạn cần phải đề cập đến nó trong cấu trúc.

635
00:48:58,000 --> 00:49:04,000
Yeah, trong các cấu trúc, bạn cần tham khảo các cấu trúc riêng của mình.

636
00:49:04,000 --> 00:49:10,000
Nếu bạn không cung cấp cho các cấu trúc một cái tên, nếu nó là một cấu trúc vô danh, bạn không thể tham chiếu đến nó.

637
00:49:10,000 --> 00:49:17,000
Và cuối cùng nhưng không kém tất cả những nên được phần nào đơn giản,

638
00:49:17,000 --> 00:49:20,000
và họ sẽ giúp bạn nhận ra nếu bạn đang viết này xuống

639
00:49:20,000 --> 00:49:24,000
rằng bạn đang làm một cái gì đó sai lầm nếu các loại của sự vật không có ý nghĩa.

640
00:49:24,000 --> 00:49:28,000
Cuối cùng nhưng không kém, tại sao điều này có là struct node *?

641
00:49:28,000 --> 00:49:34,000
Tại sao không thể chỉ được cấu trúc nút tiếp theo?

642
00:49:34,000 --> 00:49:37,000
[Sinh viên] Con trỏ trỏ tới các cấu trúc tiếp theo.

643
00:49:37,000 --> 00:49:39,000
Đó là chắc chắn những gì chúng ta muốn.

644
00:49:39,000 --> 00:49:42,000
Tại sao nó không bao giờ có thể là struct node tiếp theo?

645
00:49:42,000 --> 00:49:50,000
Tại sao nó có được struct node * next? Yeah.

646
00:49:50,000 --> 00:49:53,000
[Sinh viên] Nó giống như một vòng lặp vô hạn.

647
00:49:53,000 --> 00:49:55,000
Yeah.

648
00:49:55,000 --> 00:49:57,000
[Sinh viên] sẽ là tất cả trong một.

649
00:49:57,000 --> 00:50:02,000
Yeah, chỉ cần nghĩ về làm thế nào chúng ta sẽ làm kích thước hoặc một cái gì đó.

650
00:50:02,000 --> 00:50:08,000
Kích thước của một cấu trúc cơ bản là + hoặc - một số mô hình ở đây hoặc có.

651
00:50:08,000 --> 00:50:15,000
Đó là cơ bản sẽ là tổng của các kích thước của những thứ trong cấu trúc.

652
00:50:15,000 --> 00:50:18,000
Quyền này ở đây, mà không thay đổi bất cứ điều gì, kích thước sẽ được dễ dàng.

653
00:50:18,000 --> 00:50:24,000
Kích thước của nút struct là có được kích thước của kích thước + i tiếp theo.

654
00:50:24,000 --> 00:50:27,000
Kích thước của i sẽ là 4. Kích thước của tiếp theo sẽ là 4.

655
00:50:27,000 --> 00:50:30,000
Kích thước của nút struct sẽ là 8.

656
00:50:30,000 --> 00:50:34,000
Nếu chúng ta không có *, suy nghĩ của sizeof,

657
00:50:34,000 --> 00:50:37,000
sau đó sizeof (i) sẽ là 4.

658
00:50:37,000 --> 00:50:43,000
Kích thước của nút struct tiếp theo sẽ được kích thước của i + kích thước của nút struct tiếp theo

659
00:50:43,000 --> 00:50:46,000
+ Kích thước của kích thước + i của nút struct tiếp theo.

660
00:50:46,000 --> 00:50:55,000
Nó sẽ là một đệ quy vô hạn của các nút.

661
00:50:55,000 --> 00:51:00,000
Đây là lý do tại sao điều này là những thứ như thế nào có được.

662
00:51:00,000 --> 00:51:03,000
>> Một lần nữa, chắc chắn ghi nhớ đó,

663
00:51:03,000 --> 00:51:06,000
hoặc ít nhất là hiểu nó đủ để bạn có thể có thể

664
00:51:06,000 --> 00:51:12,000
lý do thông qua những gì nó sẽ giống như.

665
00:51:12,000 --> 00:51:14,000
Những điều chúng ta sẽ muốn thực hiện.

666
00:51:14,000 --> 00:51:18,000
Nếu độ dài của danh sách

667
00:51:18,000 --> 00:51:21,000
bạn có thể ăn gian và giữ cho xung quanh một

668
00:51:21,000 --> 00:51:24,000
chiều dài toàn cầu hoặc một cái gì đó, nhưng chúng tôi sẽ không làm điều đó.

669
00:51:24,000 --> 00:51:28,000
Chúng tôi sẽ để đếm độ dài của danh sách.

670
00:51:28,000 --> 00:51:34,000
Chúng tôi đã có, vì vậy đó là cơ bản giống như một tìm kiếm,

671
00:51:34,000 --> 00:51:41,000
vì vậy chúng tôi có một danh sách liên kết các số nguyên để xem nếu số nguyên này là trong danh sách liên kết.

672
00:51:41,000 --> 00:51:44,000
Thêm tiền tố sẽ để chèn vào đầu danh sách.

673
00:51:44,000 --> 00:51:46,000
Nối sẽ chèn ở cuối.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted sẽ để chèn vào vị trí sắp xếp trong danh sách.

675
00:51:53,000 --> 00:52:01,000
Insert_sorted loại giả định rằng bạn không bao giờ được sử dụng thêm vào trước hoặc thêm trong cách xấu.

676
00:52:01,000 --> 00:52:09,000
>> Insert_sorted khi bạn đang thực hiện insert_sorted-

677
00:52:09,000 --> 00:52:13,000
Chúng ta đã có danh sách của chúng tôi liên kết.

678
00:52:13,000 --> 00:52:18,000
Đây là những gì nó trông giống như, 2, 4, 5.

679
00:52:18,000 --> 00:52:24,000
Tôi muốn chèn 3, do đó, miễn là danh sách đã được sắp xếp,

680
00:52:24,000 --> 00:52:27,000
thật dễ dàng để tìm thấy nơi 3 thuộc về.

681
00:52:27,000 --> 00:52:29,000
Tôi bắt đầu tại 2.

682
00:52:29,000 --> 00:52:32,000
Được rồi, 3 là lớn hơn 2, vì vậy tôi muốn tiếp tục đi.

683
00:52:32,000 --> 00:52:35,000
Oh, 4 là quá lớn, vì vậy tôi biết 3 sẽ đi từ 2 đến 4,

684
00:52:35,000 --> 00:52:39,000
và tôi có để sửa chữa con trỏ và tất cả các công cụ.

685
00:52:39,000 --> 00:52:43,000
Nhưng nếu chúng ta không nghiêm sử dụng insert_sorted,

686
00:52:43,000 --> 00:52:50,000
như chúng ta hãy chỉ nói rằng tôi thêm vào trước 6,

687
00:52:50,000 --> 00:52:55,000
sau đó danh sách liên kết của tôi là sẽ trở thành điều này.

688
00:52:55,000 --> 00:53:01,000
Nó bây giờ làm cho không có ý nghĩa, vì vậy cho insert_sorted, bạn chỉ có thể giả định

689
00:53:01,000 --> 00:53:04,000
danh sách được sắp xếp, mặc dù hoạt động tồn tại

690
00:53:04,000 --> 00:53:09,000
có thể gây ra nó không được phân loại, và đó là nó.

691
00:53:09,000 --> 00:53:20,000
Tìm một chèn hữu ích để những người đang có những điều chính bạn sẽ phải thực hiện.

692
00:53:20,000 --> 00:53:24,000
>> Để bây giờ, mất vài phút để làm chiều dài và chứa,

693
00:53:24,000 --> 00:53:30,000
và những người cần được tương đối nhanh chóng.

694
00:53:41,000 --> 00:53:48,000
Gần thời gian đóng cửa, do đó, bất cứ ai có bất cứ điều gì cho chiều dài hoặc có chứa?

695
00:53:48,000 --> 00:53:50,000
Họ sẽ để được gần như giống hệt nhau.

696
00:53:50,000 --> 00:53:57,000
[Sinh viên] Thêm bài này vào danh sách Video của bạn.

697
00:53:57,000 --> 00:54:01,000
Hãy xem, sửa đổi.

698
00:54:01,000 --> 00:54:04,000
Okay.

699
00:54:12,000 --> 00:54:15,000
Bạn muốn giải thích?

700
00:54:15,000 --> 00:54:21,000
[Sinh viên] Tôi chỉ tạo ra một nút con trỏ và khởi tạo nó đầu tiên, là biến toàn cầu của chúng tôi,

701
00:54:21,000 --> 00:54:27,000
và sau đó tôi kiểm tra xem nếu nó là null vì vậy tôi không nhận được một lỗi seg và trở về 0 nếu đó là trường hợp.

702
00:54:27,000 --> 00:54:34,000
Nếu không, tôi lặp qua, theo dõi trong số nguyên

703
00:54:34,000 --> 00:54:38,000
bao nhiêu lần tôi đã truy cập vào phần tử tiếp theo của danh sách

704
00:54:38,000 --> 00:54:43,000
và trong cùng một hoạt động tăng cũng có thể truy cập yếu tố đó thực tế,

705
00:54:43,000 --> 00:54:47,000
và sau đó tôi liên tục làm cho việc kiểm tra để xem nếu nó là vô giá trị,

706
00:54:47,000 --> 00:54:56,000
và nếu nó là vô giá trị, sau đó nó hủy bỏ và chỉ cần trả về số lượng các yếu tố tôi đã truy cập.

707
00:54:56,000 --> 00:55:01,000
>> [Rob B.] Có ai có bất kỳ ý kiến ​​về bất cứ điều gì?

708
00:55:01,000 --> 00:55:06,000
Điều này có vẻ tốt đúng đắn khôn ngoan.

709
00:55:06,000 --> 00:55:10,000
[Sinh viên] Tôi không nghĩ rằng bạn cần các nút == null.

710
00:55:10,000 --> 00:55:13,000
Yeah, vì vậy nếu nút == null trở về 0.

711
00:55:13,000 --> 00:55:18,000
Nhưng nếu null nút == sau đó này-oh, có một vấn đề đúng đắn.

712
00:55:18,000 --> 00:55:23,000
Đó chỉ là bạn trả lại tôi, nhưng nó không phải trong phạm vi ngay bây giờ.

713
00:55:23,000 --> 00:55:30,000
Bạn chỉ cần int i, do đó, i = 0.

714
00:55:30,000 --> 00:55:34,000
Nhưng nếu nút là null, sau đó tôi vẫn sẽ là 0,

715
00:55:34,000 --> 00:55:39,000
và chúng ta sẽ trở về 0, do đó, trường hợp này là giống hệt nhau.

716
00:55:39,000 --> 00:55:48,000
Một điều phổ biến khác là để giữ cho tờ khai

717
00:55:48,000 --> 00:55:51,000
của nút bên trong cho vòng lặp.

718
00:55:51,000 --> 00:55:54,000
Bạn có thể nói-oh, không có.

719
00:55:54,000 --> 00:55:56,000
Hãy để giữ cho nó như thế này.

720
00:55:56,000 --> 00:55:59,000
Tôi có lẽ sẽ đặt int i = 0 ở đây,

721
00:55:59,000 --> 00:56:05,000
sau đó node * node = đầu tiên ở đây.

722
00:56:05,000 --> 00:56:11,000
Và điều này có lẽ là làm thế nào nhận được thoát khỏi điều này ngay bây giờ.

723
00:56:11,000 --> 00:56:14,000
Đây có lẽ là làm thế nào tôi sẽ có văn bản nó.

724
00:56:14,000 --> 00:56:21,000
Bạn cũng có thể nhìn vào nó như thế này.

725
00:56:21,000 --> 00:56:25,000
Điều này cho cấu trúc vòng lặp ngay tại đây

726
00:56:25,000 --> 00:56:30,000
nên được gần như là tự nhiên với bạn như int i = 0

727
00:56:30,000 --> 00:56:33,000
i là ít hơn so với chiều dài của mảng i + +.

728
00:56:33,000 --> 00:56:38,000
Nếu đó là làm thế nào bạn lặp qua một mảng, đây là làm thế nào bạn lặp qua một danh sách liên kết.

729
00:56:38,000 --> 00:56:45,000
>> Điều này cần được bản chất thứ hai tại một số điểm.

730
00:56:45,000 --> 00:56:50,000
Với ý nghĩ đó, điều này là có được gần như cùng một.

731
00:56:50,000 --> 00:56:57,000
Bạn sẽ muốn để lặp lại trên một danh sách liên kết.

732
00:56:57,000 --> 00:57:02,000
Nếu node-Tôi không có ý tưởng những gì giá trị được gọi là.

733
00:57:02,000 --> 00:57:04,000
Node i.

734
00:57:04,000 --> 00:57:15,000
Nếu giá trị tại nút đó tôi trở về đúng sự thật, và đó là nó.

735
00:57:15,000 --> 00:57:18,000
Chú ý rằng cách duy nhất chúng tôi đã từng trả về false

736
00:57:18,000 --> 00:57:23,000
là nếu chúng ta lặp qua danh sách liên kết toàn bộ và không bao giờ trở lại đúng sự thật,

737
00:57:23,000 --> 00:57:29,000
để điều này không.

738
00:57:29,000 --> 00:57:36,000
Là một phụ lưu ý, chúng ta có thể sẽ không nhận được để phụ thêm hoặc thêm vào trước.

739
00:57:36,000 --> 00:57:39,000
>> Nhanh chóng lưu ý cuối.

740
00:57:39,000 --> 00:57:52,000
Nếu bạn thấy các từ khoá tĩnh, vì vậy chúng ta hãy nói static int count = 0,

741
00:57:52,000 --> 00:57:56,000
sau đó chúng ta làm count + +, bạn về cơ bản có thể nghĩ về nó như là một biến toàn cầu,

742
00:57:56,000 --> 00:58:00,000
mặc dù tôi chỉ nói điều này không phải là làm thế nào chúng ta sẽ thực hiện chiều dài.

743
00:58:00,000 --> 00:58:06,000
Tôi làm điều này ở đây, và sau đó đếm + +.

744
00:58:06,000 --> 00:58:11,000
Bất kỳ cách nào chúng ta có thể nhập vào một nút vào danh sách liên kết của chúng tôi, chúng tôi được incrementing số của chúng tôi.

745
00:58:11,000 --> 00:58:15,000
Điểm này là các từ khoá tĩnh có nghĩa là gì.

746
00:58:15,000 --> 00:58:20,000
Nếu tôi chỉ có số int = 0 đó sẽ là biến toàn cầu thường xuyên.

747
00:58:20,000 --> 00:58:25,000
Static int count phương tiện là nó là một biến toàn cầu cho tập tin này.

748
00:58:25,000 --> 00:58:28,000
Nó là không thể cho một số tập tin khác,

749
00:58:28,000 --> 00:58:34,000
suy nghĩ của pset 5, nếu bạn đã bắt đầu.

750
00:58:34,000 --> 00:58:39,000
Bạn có cả hai speller.c, và bạn có dictionary.c,

751
00:58:39,000 --> 00:58:42,000
và nếu bạn chỉ cần khai báo một điều toàn cầu, sau đó bất cứ điều gì trong speller.c

752
00:58:42,000 --> 00:58:45,000
có thể được truy cập trong dictionary.c và ngược lại.

753
00:58:45,000 --> 00:58:48,000
Biến toàn cầu có thể truy cập bất kỳ tập tin c.

754
00:58:48,000 --> 00:58:54,000
nhưng các biến tĩnh chỉ có thể truy cập từ bên trong các tập tin riêng của mình,

755
00:58:54,000 --> 00:59:01,000
như vậy bên trong kiểm tra chính tả hoặc bên trong của dictionary.c,

756
00:59:01,000 --> 00:59:06,000
này là loại thế nào tôi sẽ khai báo biến của tôi cho kích thước của mảng của tôi

757
00:59:06,000 --> 00:59:10,000
hoặc kích thước của số từ trong từ điển của tôi.

758
00:59:10,000 --> 00:59:15,000
Vì tôi không muốn khai báo một biến toàn cầu mà bất cứ ai đã truy cập vào,

759
00:59:15,000 --> 00:59:18,000
Tôi thực sự chỉ quan tâm đến nó cho mục đích riêng của tôi.

760
00:59:18,000 --> 00:59:21,000
>> Những điều tốt về điều này cũng là tên toàn bộ các công cụ va chạm.

761
00:59:21,000 --> 00:59:27,000
Nếu một số file khác cố gắng sử dụng một biến toàn cầu tính, mọi thứ đi rất, rất sai trái,

762
00:59:27,000 --> 00:59:33,000
do đó, điều này độc đáo giữ những điều an toàn, và chỉ có bạn mới có thể truy cập vào nó,

763
00:59:33,000 --> 00:59:38,000
và không ai khác có thể, và nếu người khác khai báo một biến toàn cầu tính,

764
00:59:38,000 --> 00:59:43,000
sau đó nó sẽ không can thiệp với biến tĩnh đếm được gọi là.

765
00:59:43,000 --> 00:59:47,000
Đó là những gì tĩnh là. Đây là một biến tập tin toàn cầu.

766
00:59:47,000 --> 00:59:52,000
>> Các câu hỏi về bất cứ điều gì?

767
00:59:52,000 --> 00:59:59,000
Tất cả các thiết lập. Bye.

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