1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [Bagian 6] [Lebih Nyaman]

2
00:00:01,000 --> 00:00:04,000
[Rob Bowden] [Harvard University]

3
00:00:04,000 --> 00:00:09,000
[Ini adalah CS50.] [CS50.TV]

4
00:00:09,000 --> 00:00:11,000
>> Kita dapat menuju ke bagian kami dari pertanyaan.

5
00:00:11,000 --> 00:00:17,000
Aku mengirim URL untuk ruang sebelumnya.

6
00:00:17,000 --> 00:00:22,000
Awal bagian dari pertanyaan mengatakan-

7
00:00:22,000 --> 00:00:26,000
ternyata aku tidak sepenuhnya unsick-adalah pertanyaan yang sangat mudah

8
00:00:26,000 --> 00:00:28,000
hanya apa yang Valgrind?

9
00:00:28,000 --> 00:00:30,000
Apa Valgrind lakukan?

10
00:00:30,000 --> 00:00:34,000
Siapapun ingin mengatakan apa Valgrind tidak?

11
00:00:34,000 --> 00:00:36,000
[Mahasiswa] Cek kebocoran memori.

12
00:00:36,000 --> 00:00:41,000
Ya, Valgrind adalah checker memori umum.

13
00:00:41,000 --> 00:00:44,000
Ini, pada akhirnya, memberitahu Anda jika Anda memiliki kebocoran memori,

14
00:00:44,000 --> 00:00:49,000
yang sebagian besar apa yang kita menggunakannya untuk karena jika Anda ingin

15
00:00:49,000 --> 00:00:54,000
melakukannya dengan baik pada set masalah atau jika Anda ingin

16
00:00:54,000 --> 00:00:59,000
mendapatkan di papan besar, Anda perlu tidak memiliki kebocoran memori apapun,

17
00:00:59,000 --> 00:01:01,000
dan jika Anda memiliki kebocoran memori yang Anda tidak dapat menemukan,

18
00:01:01,000 --> 00:01:04,000
juga perlu diingat bahwa setiap kali Anda membuka file

19
00:01:04,000 --> 00:01:07,000
dan jika Anda tidak menutupnya, itu adalah kebocoran memori.

20
00:01:07,000 --> 00:01:10,000
>> Banyak orang mencari simpul beberapa bahwa mereka tidak membebaskan

21
00:01:10,000 --> 00:01:15,000
ketika benar-benar, mereka tidak menutup kamus pada langkah pertama.

22
00:01:15,000 --> 00:01:19,000
Ia juga memberitahu Anda jika Anda memiliki valid membaca atau menulis,

23
00:01:19,000 --> 00:01:22,000
yang berarti jika Anda mencoba dan menetapkan nilai

24
00:01:22,000 --> 00:01:26,000
itu di luar akhir tumpukan, dan itu tidak terjadi kesalahan seg

25
00:01:26,000 --> 00:01:30,000
tapi Valgrind menangkap itu, karena Anda tidak harus benar-benar bisa menulis di sana,

26
00:01:30,000 --> 00:01:33,000
dan sehingga Anda pasti tidak harus memiliki salah satu dari mereka baik.

27
00:01:33,000 --> 00:01:38,000
Bagaimana Anda menggunakan Valgrind?

28
00:01:38,000 --> 00:01:42,000
Bagaimana Anda menggunakan Valgrind?

29
00:01:42,000 --> 00:01:45,000
>> Ini adalah pertanyaan umum dari

30
00:01:45,000 --> 00:01:49,000
jenis menjalankannya dan melihat output.

31
00:01:49,000 --> 00:01:51,000
Output melanda banyak kali.

32
00:01:51,000 --> 00:01:54,000
Ada juga kesalahan menyenangkan di mana jika Anda memiliki beberapa hal yang sangat salah

33
00:01:54,000 --> 00:01:59,000
terjadi dalam satu lingkaran, maka pada akhirnya akan mengatakan, "Terlalu banyak kesalahan.

34
00:01:59,000 --> 00:02:03,000
Aku akan berhenti menghitung sekarang. "

35
00:02:03,000 --> 00:02:08,000
Ini pada dasarnya output tekstual bahwa Anda harus mengurai.

36
00:02:08,000 --> 00:02:13,000
Pada akhirnya, ia akan memberitahu Anda kebocoran memori apapun yang Anda miliki,

37
00:02:13,000 --> 00:02:16,000
berapa banyak blok, yang dapat berguna karena

38
00:02:16,000 --> 00:02:20,000
jika satu unfreed blok, maka biasanya lebih mudah untuk menemukan

39
00:02:20,000 --> 00:02:23,000
dari 1.000 blok unfreed.

40
00:02:23,000 --> 00:02:26,000
1.000 blok unfreed mungkin berarti Anda tidak membebaskan

41
00:02:26,000 --> 00:02:30,000
Anda terkait daftar tepat atau sesuatu.

42
00:02:30,000 --> 00:02:32,000
Itu Valgrind.

43
00:02:32,000 --> 00:02:35,000
>> Sekarang kita memiliki bagian kita pertanyaan,

44
00:02:35,000 --> 00:02:38,000
yang Anda tidak perlu men-download.

45
00:02:38,000 --> 00:02:41,000
Anda dapat klik pada nama saya dan menarik mereka di ruang.

46
00:02:41,000 --> 00:02:44,000
Sekarang klik pada saya.

47
00:02:44,000 --> 00:02:46,000
Revisi 1 akan menjadi tumpukan, yang kita lakukan pertama kali.

48
00:02:46,000 --> 00:02:55,000
Revisi 2 akan antrian, dan Revisi 3 akan menjadi linked list sendiri-sendiri.

49
00:02:55,000 --> 00:02:58,000
Mulai off dengan tumpukan kami.

50
00:02:58,000 --> 00:03:02,000
Seperti dikatakan di sini, tumpukan adalah salah satu dari yang paling dasar,

51
00:03:02,000 --> 00:03:07,000
dasar struktur data dari ilmu komputer.

52
00:03:07,000 --> 00:03:11,000
Contoh prototipikal adalah sangat

53
00:03:11,000 --> 00:03:13,000
tumpukan nampan di ruang makan.

54
00:03:13,000 --> 00:03:16,000
Pada dasarnya setiap kali Anda sedang diperkenalkan ke stack,

55
00:03:16,000 --> 00:03:20,000
seseorang akan berkata, "Oh, seperti tumpukan nampan."

56
00:03:20,000 --> 00:03:22,000
Anda tumpukan nampan up.

57
00:03:22,000 --> 00:03:24,000
Kemudian ketika Anda pergi untuk menarik nampan,

58
00:03:24,000 --> 00:03:31,000
baki pertama yang mendapatkan ditarik adalah yang terakhir yang dimasukkan pada stack.

59
00:03:31,000 --> 00:03:34,000
Tumpukan juga-seperti yang dikatakan di sini-

60
00:03:34,000 --> 00:03:37,000
kita memiliki segmen memori yang disebut stack.

61
00:03:37,000 --> 00:03:40,000
Dan mengapa disebut stack?

62
00:03:40,000 --> 00:03:42,000
>> Karena seperti struktur tumpukan data,

63
00:03:42,000 --> 00:03:46,000
itu mendorong dan muncul frame stack di stack,

64
00:03:46,000 --> 00:03:53,000
di mana frame tumpukan seperti panggilan khusus dari suatu fungsi.

65
00:03:53,000 --> 00:03:57,000
Dan seperti stack, Anda akan selalu harus kembali

66
00:03:57,000 --> 00:04:03,000
dari panggilan fungsi sebelum Anda bisa mendapatkan ke dalam stack frame yang lebih rendah lagi.

67
00:04:03,000 --> 00:04:08,000
Anda tidak dapat memiliki panggilan foo bar panggilan utama dan kembali bar untuk langsung main.

68
00:04:08,000 --> 00:04:14,000
Itu selalu harus mengikuti tumpukan yang benar mendorong dan muncul.

69
00:04:14,000 --> 00:04:18,000
Dua operasi, seperti saya katakan, adalah push dan pop.

70
00:04:18,000 --> 00:04:20,000
Mereka adalah istilah universal.

71
00:04:20,000 --> 00:04:26,000
Anda harus tahu push dan pop dalam hal tumpukan tidak peduli apa.

72
00:04:26,000 --> 00:04:28,000
Kita akan melihat antrian yang agak berbeda.

73
00:04:28,000 --> 00:04:32,000
Ini tidak benar-benar memiliki istilah universal, tapi push dan pop yang universal untuk tumpukan.

74
00:04:32,000 --> 00:04:34,000
Push hanya menempatkan pada stack.

75
00:04:34,000 --> 00:04:37,000
Pop adalah mengambil dari tumpukan.

76
00:04:37,000 --> 00:04:43,000
Dan kita lihat di sini kita memiliki tumpukan struct typedef kami,

77
00:04:43,000 --> 00:04:46,000
sehingga kita memiliki string char **.

78
00:04:46,000 --> 00:04:51,000
Jangan takut oleh **.

79
00:04:51,000 --> 00:04:54,000
Ini akan berakhir menjadi sebuah array string

80
00:04:54,000 --> 00:04:58,000
atau sebuah array dari pointer ke karakter, di mana

81
00:04:58,000 --> 00:05:00,000
pointer ke karakter cenderung string.

82
00:05:00,000 --> 00:05:05,000
Tidak harus string, tapi di sini, mereka akan menjadi string.

83
00:05:05,000 --> 00:05:08,000
>> Kami memiliki sebuah array dari string.

84
00:05:08,000 --> 00:05:14,000
Kami memiliki ukuran, yang mewakili berapa banyak elemen saat ini di stack,

85
00:05:14,000 --> 00:05:19,000
dan kemudian kita memiliki kapasitas, yang adalah berapa banyak elemen dapat berada di stack.

86
00:05:19,000 --> 00:05:22,000
Kapasitas harus memulai sebagai sesuatu yang lebih besar dari 1,

87
00:05:22,000 --> 00:05:27,000
tetapi ukuran akan memulai sebagai 0.

88
00:05:27,000 --> 00:05:36,000
Sekarang, pada dasarnya ada tiga cara yang berbeda yang dapat Anda pikirkan stack.

89
00:05:36,000 --> 00:05:39,000
Nah, ada mungkin lebih, tetapi dua cara utama adalah

90
00:05:39,000 --> 00:05:43,000
Anda dapat menerapkannya menggunakan array, atau Anda dapat menerapkannya menggunakan linked list.

91
00:05:43,000 --> 00:05:48,000
Daftar link adalah jenis sepele untuk membuat tumpukan dari.

92
00:05:48,000 --> 00:05:51,000
Hal ini sangat mudah untuk membuat tumpukan menggunakan linked list,

93
00:05:51,000 --> 00:05:55,000
jadi di sini, kita akan membuat stack menggunakan array,

94
00:05:55,000 --> 00:05:59,000
dan kemudian menggunakan array, ada juga dua cara Anda dapat berpikir tentang hal itu.

95
00:05:59,000 --> 00:06:01,000
Sebelumnya, ketika saya mengatakan kami memiliki kapasitas untuk stack,

96
00:06:01,000 --> 00:06:04,000
sehingga kami dapat muat elemen pada stack.

97
00:06:04,000 --> 00:06:09,000
>> Salah satu cara itu bisa terjadi adalah segera setelah Anda mencapai 10 elemen, maka Anda sudah selesai.

98
00:06:09,000 --> 00:06:13,000
Anda mungkin tahu bahwa ada batas atas dari 10 hal di dunia

99
00:06:13,000 --> 00:06:16,000
bahwa Anda tidak akan pernah memiliki lebih dari 10 hal pada stack Anda,

100
00:06:16,000 --> 00:06:20,000
dalam hal ini Anda dapat memiliki batas atas ukuran tumpukan Anda.

101
00:06:20,000 --> 00:06:23,000
Atau Anda bisa memiliki tumpukan Anda harus tak terbatas,

102
00:06:23,000 --> 00:06:27,000
tetapi jika Anda melakukan sebuah array, yang berarti bahwa setiap kali Anda mencapai 10 elemen,

103
00:06:27,000 --> 00:06:29,000
maka Anda akan harus tumbuh menjadi 20 elemen, dan ketika anda menekan 20 elemen,

104
00:06:29,000 --> 00:06:33,000
Anda akan harus tumbuh array Anda untuk 30 unsur atau elemen 40.

105
00:06:33,000 --> 00:06:37,000
Anda akan perlu untuk meningkatkan kapasitas, yang adalah apa yang akan kita lakukan di sini.

106
00:06:37,000 --> 00:06:40,000
Setiap kali kita mencapai ukuran maksimum tumpukan kami,

107
00:06:40,000 --> 00:06:46,000
ketika kita mendorong sesuatu yang lain, kami akan perlu untuk meningkatkan kapasitas.

108
00:06:46,000 --> 00:06:50,000
Di sini, kami telah mendorong dinyatakan sebagai dorongan bool (char * str).

109
00:06:50,000 --> 00:06:54,000
Str * Char adalah string yang kita mendorong ke stack,

110
00:06:54,000 --> 00:06:58,000
dan bool hanya mengatakan apakah kita berhasil atau gagal.

111
00:06:58,000 --> 00:07:00,000
>> Bagaimana bisa kita gagal?

112
00:07:00,000 --> 00:07:04,000
Apa keadaan-satunya yang dapat Anda pikirkan

113
00:07:04,000 --> 00:07:07,000
di mana kita akan perlu kembali palsu?

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

115
00:07:09,000 --> 00:07:12,000
[Mahasiswa] Jika itu penuh dan kita sedang menggunakan implementasi dibatasi.

116
00:07:12,000 --> 00:07:17,000
Ya, jadi bagaimana kita mendefinisikan-ia menjawab

117
00:07:17,000 --> 00:07:23,000
jika itu penuh dan kita sedang menggunakan implementasi dibatasi.

118
00:07:23,000 --> 00:07:26,000
Kemudian kita pasti akan kembali palsu.

119
00:07:26,000 --> 00:07:31,000
Segera setelah kami mencapai 10 hal dalam array, kita tidak bisa muat 11, jadi kami kembali salah.

120
00:07:31,000 --> 00:07:32,000
Bagaimana jika itu tak terbatas? Ya.

121
00:07:32,000 --> 00:07:38,000
Jika Anda tidak dapat memperluas array untuk beberapa alasan.

122
00:07:38,000 --> 00:07:43,000
Ya, jadi memori adalah sumber daya yang terbatas,

123
00:07:43,000 --> 00:07:51,000
dan akhirnya, jika kita menjaga hal-hal mendorong ke stack berulang-ulang,

124
00:07:51,000 --> 00:07:54,000
kita akan mencoba dan mengalokasikan array yang lebih besar untuk menyesuaikan

125
00:07:54,000 --> 00:07:59,000
kapasitas yang lebih besar, dan malloc atau apa pun yang kami gunakan akan kembali palsu.

126
00:07:59,000 --> 00:08:02,000
Nah, malloc akan mengembalikan null.

127
00:08:02,000 --> 00:08:05,000
>> Ingat, setiap kali Anda pernah menelepon malloc, Anda harus memeriksa untuk melihat apakah itu

128
00:08:05,000 --> 00:08:12,000
mengembalikan null atau yang lain yang merupakan pengurangan kebenaran.

129
00:08:12,000 --> 00:08:17,000
Karena kita ingin memiliki tumpukan tak terbatas,

130
00:08:17,000 --> 00:08:21,000
kasus-satunya kita akan kembali palsu adalah jika kita mencoba untuk

131
00:08:21,000 --> 00:08:26,000
meningkatkan kapasitas dan malloc atau apa pun kembali palsu.

132
00:08:26,000 --> 00:08:30,000
Kemudian pop tidak membutuhkan argumen,

133
00:08:30,000 --> 00:08:37,000
dan mengembalikan string yang ada di atas tumpukan.

134
00:08:37,000 --> 00:08:41,000
Apapun yang terakhir didorong pada stack adalah apa pop yang kembali,

135
00:08:41,000 --> 00:08:44,000
dan juga menghapusnya dari stack.

136
00:08:44,000 --> 00:08:50,000
Dan melihat bahwa ia mengembalikan null jika tidak ada pada stack.

137
00:08:50,000 --> 00:08:53,000
Itu selalu mungkin bahwa stack kosong.

138
00:08:53,000 --> 00:08:55,000
Di Jawa, jika Anda terbiasa untuk itu, atau bahasa lainnya,

139
00:08:55,000 --> 00:09:01,000
mencoba untuk pop dari tumpukan kosong dapat menyebabkan pengecualian atau sesuatu.

140
00:09:01,000 --> 00:09:09,000
>> Tapi di C, null adalah jenis banyak kasus bagaimana kita menangani masalah ini.

141
00:09:09,000 --> 00:09:13,000
Kembali nol adalah bagaimana kita akan menandakan bahwa tumpukan itu kosong.

142
00:09:13,000 --> 00:09:16,000
Kami telah menyediakan kode yang akan menguji fungsionalitas tumpukan Anda,

143
00:09:16,000 --> 00:09:19,000
menerapkan mendorong dan pop.

144
00:09:19,000 --> 00:09:23,000
Ini tidak akan banyak kode.

145
00:09:23,000 --> 00:09:40,000
Aku akan-sebenarnya, sebelum kita melakukan itu, petunjuk, petunjuk-

146
00:09:40,000 --> 00:09:44,000
jika Anda belum melihatnya, malloc bukanlah satu-satunya fungsi

147
00:09:44,000 --> 00:09:47,000
yang mengalokasikan memori di heap untuk Anda.

148
00:09:47,000 --> 00:09:51,000
Ada keluarga fungsi alokasi.

149
00:09:51,000 --> 00:09:53,000
Yang pertama adalah malloc, yang Anda terbiasa.

150
00:09:53,000 --> 00:09:56,000
Lalu ada calloc, yang melakukan hal yang sama seperti malloc,

151
00:09:56,000 --> 00:09:59,000
tetapi akan nol semuanya untuk Anda.

152
00:09:59,000 --> 00:10:04,000
Jika Anda pernah ingin mengatur semuanya untuk null setelah mallocing sesuatu

153
00:10:04,000 --> 00:10:06,000
Anda seharusnya hanya menggunakan calloc di tempat pertama alih-alih menulis

154
00:10:06,000 --> 00:10:09,000
untuk loop untuk nol seluruh blok memori.

155
00:10:09,000 --> 00:10:15,000
>> Realloc seperti malloc dan memiliki banyak kasus khusus,

156
00:10:15,000 --> 00:10:19,000
tetapi pada dasarnya apa yang dilakukan adalah realloc

157
00:10:19,000 --> 00:10:24,000
dibutuhkan pointer yang sudah dialokasikan.

158
00:10:24,000 --> 00:10:27,000
Realloc adalah fungsi yang ingin memperhatikan sini.

159
00:10:27,000 --> 00:10:31,000
Dibutuhkan pointer yang sudah kembali dari malloc.

160
00:10:31,000 --> 00:10:35,000
Katakanlah Anda meminta dari malloc pointer dari 10 byte.

161
00:10:35,000 --> 00:10:38,000
Lalu kemudian Anda sadar bahwa Anda ingin 20 byte,

162
00:10:38,000 --> 00:10:42,000
sehingga Anda sebut realloc pada bahwa pointer dengan 20 byte,

163
00:10:42,000 --> 00:10:47,000
dan realloc otomatis akan menyalin atas segala sesuatu untuk Anda.

164
00:10:47,000 --> 00:10:51,000
Jika Anda baru saja menelepon malloc lagi, seperti saya memiliki blok 10 byte.

165
00:10:51,000 --> 00:10:53,000
Sekarang aku butuh blok 20 byte,

166
00:10:53,000 --> 00:10:58,000
jadi jika saya malloc 20 byte, maka saya harus secara manual menyalin selama 10 byte dari hal pertama

167
00:10:58,000 --> 00:11:01,000
ke hal kedua dan kemudian bebas hal pertama.

168
00:11:01,000 --> 00:11:04,000
Realloc akan menangani untuk Anda.

169
00:11:04,000 --> 00:11:11,000
>> Perhatikan tanda tangan akan menjadi void *,

170
00:11:11,000 --> 00:11:15,000
yang hanya kembali pointer ke blok memori,

171
00:11:15,000 --> 00:11:17,000
maka void * ptr.

172
00:11:17,000 --> 00:11:22,000
Anda dapat menganggap void * sebagai pointer generik.

173
00:11:22,000 --> 00:11:27,000
Umumnya, Anda tidak pernah berurusan dengan void *,

174
00:11:27,000 --> 00:11:30,000
tapi malloc mengembalikan void *, dan kemudian itu hanya digunakan seperti

175
00:11:30,000 --> 00:11:34,000
ini benar-benar akan menjadi char *.

176
00:11:34,000 --> 00:11:37,000
The * sebelumnya kekosongan yang telah dikembalikan oleh malloc

177
00:11:37,000 --> 00:11:41,000
sekarang akan diteruskan ke realloc, dan kemudian ukuran

178
00:11:41,000 --> 00:11:49,000
adalah nomor baru byte Anda ingin mengalokasikan, sehingga kapasitas baru Anda.

179
00:11:49,000 --> 00:11:57,000
Saya akan memberi Anda beberapa menit, dan melakukannya di ruang kita.

180
00:11:57,000 --> 00:12:02,000
Mulailah dengan Revisi 1.

181
00:12:16,000 --> 00:12:21,000
Saya akan menghentikan Anda setelah semoga tentang waktu yang cukup untuk melaksanakan push,

182
00:12:21,000 --> 00:12:24,000
dan kemudian saya akan memberi Anda istirahat lain untuk melakukan pop.

183
00:12:24,000 --> 00:12:27,000
Tapi itu benar-benar tidak bahwa kode sama sekali.

184
00:12:27,000 --> 00:12:35,000
Kode yang paling mungkin adalah hal memperluas, memperluas kapasitas.

185
00:12:35,000 --> 00:12:39,000
Oke, tidak ada tekanan harus benar-benar dilakukan,

186
00:12:39,000 --> 00:12:47,000
tetapi selama Anda merasa seperti Anda berada di jalan yang benar, itu bagus.

187
00:12:47,000 --> 00:12:53,000
>> Apakah ada yang punya kode mereka merasa nyaman dengan saya menariknya ke atas?

188
00:12:53,000 --> 00:12:59,000
Ya, aku akan, tetapi tidak ada yang punya kode saya dapat menarik?

189
00:12:59,000 --> 00:13:05,000
Oke, bisa Anda mulai, menyimpannya, apa pun itu?

190
00:13:05,000 --> 00:13:09,000
Aku selalu lupa langkah itu.

191
00:13:09,000 --> 00:13:15,000
Oke, melihat dorongan,

192
00:13:15,000 --> 00:13:18,000
Anda ingin menjelaskan kode Anda?

193
00:13:18,000 --> 00:13:24,000
[Mahasiswa] Pertama-tama, saya meningkatkan ukuran.

194
00:13:24,000 --> 00:13:28,000
Saya kira mungkin aku harus memiliki-pula, saya meningkatkan ukuran,

195
00:13:28,000 --> 00:13:31,000
dan saya melihat apakah itu kurang dari kapasitas.

196
00:13:31,000 --> 00:13:36,000
Dan jika itu kurang dari kapasitas, saya tambahkan ke array yang sudah kita miliki.

197
00:13:36,000 --> 00:13:42,000
Dan jika tidak, saya melipatgandakan kapasitas dengan 2,

198
00:13:42,000 --> 00:13:50,000
dan saya mengalokasikan array string untuk sesuatu dengan ukuran kapasitas yang lebih besar sekarang.

199
00:13:50,000 --> 00:13:55,000
Dan kemudian jika itu gagal, saya memberitahu pengguna dan kembali palsu,

200
00:13:55,000 --> 00:14:04,000
dan jika tidak apa-apa, maka saya menempatkan string di tempat yang baru.

201
00:14:04,000 --> 00:14:07,000
>> [Rob B.] Juga perhatikan bahwa kita menggunakan operator bitwise bagus di sini

202
00:14:07,000 --> 00:14:09,000
kalikan dengan 2.

203
00:14:09,000 --> 00:14:11,000
Ingat, pergeseran kiri selalu akan dikalikan dengan 2.

204
00:14:11,000 --> 00:14:15,000
Shift kanan dibagi oleh 2 selama Anda ingat bahwa itu berarti

205
00:14:15,000 --> 00:14:18,000
membagi dengan 2 seperti dalam integer dibagi dengan 2.

206
00:14:18,000 --> 00:14:20,000
Mungkin memotong sebuah 1 sini atau di sana.

207
00:14:20,000 --> 00:14:26,000
Tapi pergeseran ditinggalkan oleh 1 selalu akan dikalikan dengan 2,

208
00:14:26,000 --> 00:14:32,000
kecuali Anda meluap batas-batas integer, dan kemudian tidak akan.

209
00:14:32,000 --> 00:14:34,000
Sebuah komentar samping.

210
00:14:34,000 --> 00:14:39,000
Saya ingin melakukan-ini tidak akan mengubah coding cara apapun,

211
00:14:39,000 --> 00:14:48,000
tapi saya ingin melakukan sesuatu seperti ini.

212
00:14:48,000 --> 00:14:51,000
Ini benar-benar akan membuatnya sedikit lebih panjang.

213
00:15:04,000 --> 00:15:08,000
Mungkin ini bukan kasus yang sempurna untuk menunjukkan hal ini,

214
00:15:08,000 --> 00:15:14,000
tapi saya ingin segmen itu ke dalam blok-

215
00:15:14,000 --> 00:15:17,000
oke, jika ini jika terjadi, maka aku akan melakukan sesuatu,

216
00:15:17,000 --> 00:15:19,000
dan kemudian fungsi dilakukan.

217
00:15:19,000 --> 00:15:22,000
Saya tidak perlu kemudian gulir mata saya semua jalan ke bawah fungsi

218
00:15:22,000 --> 00:15:25,000
untuk melihat apa yang terjadi setelah itu yang lain.

219
00:15:25,000 --> 00:15:27,000
Ini jika ini jika terjadi, maka saya hanya kembali.

220
00:15:27,000 --> 00:15:30,000
Hal ini juga memiliki manfaat tambahan yang bagus dari segala sesuatu di luar ini

221
00:15:30,000 --> 00:15:33,000
kini bergeser ke kiri sekali.

222
00:15:33,000 --> 00:15:40,000
Saya tidak perlu lagi-jika Anda pernah dekat ridiculously antrean panjang,

223
00:15:40,000 --> 00:15:45,000
maka mereka 4 byte bisa membantu, dan juga sesuatu yang lebih kiri adalah,

224
00:15:45,000 --> 00:15:48,000
kurang kewalahan jika Anda merasa seperti-oke, aku harus ingat

225
00:15:48,000 --> 00:15:53,000
Aku sedang dalam loop sementara di dalam suatu dalam lain dari untuk loop.

226
00:15:53,000 --> 00:15:58,000
Di mana saja Anda dapat melakukan ini segera kembali, aku jenis seperti.

227
00:15:58,000 --> 00:16:05,000
Ini benar-benar opsional dan tidak diharapkan dengan cara apapun.

228
00:16:05,000 --> 00:16:12,000
>> [Mahasiswa] Harus ada ukuran - dalam kondisi gagal?

229
00:16:12,000 --> 00:16:19,000
Kondisi gagal di sini adalah kita gagal realloc, jadi ya.

230
00:16:19,000 --> 00:16:22,000
Perhatikan bagaimana dalam kondisi gagal, mungkin,

231
00:16:22,000 --> 00:16:26,000
kecuali kita free stuff kemudian, kami selalu akan gagal

232
00:16:26,000 --> 00:16:29,000
tidak peduli berapa kali kita mencoba untuk mendorong sesuatu.

233
00:16:29,000 --> 00:16:32,000
Jika kita terus mendorong, kami menjaga ukuran incrementing,

234
00:16:32,000 --> 00:16:36,000
meskipun kita tidak menempatkan sesuatu ke stack.

235
00:16:36,000 --> 00:16:39,000
Biasanya kita tidak kenaikan ukuran sampai

236
00:16:39,000 --> 00:16:43,000
setelah kita telah berhasil meletakkannya di stack.

237
00:16:43,000 --> 00:16:50,000
Kami akan melakukannya, katakanlah, baik di sini dan di sini.

238
00:16:50,000 --> 00:16:56,000
Dan kemudian bukannya mengatakan s.size kapasitas ≤, itu kurang dari kapasitas,

239
00:16:56,000 --> 00:17:01,000
hanya karena kami pindah di mana segala sesuatu.

240
00:17:01,000 --> 00:17:07,000
>> Dan ingat, satu-satunya tempat yang kita mungkin bisa kembali palsu

241
00:17:07,000 --> 00:17:14,000
di sini, di mana realloc kembali nol,

242
00:17:14,000 --> 00:17:19,000
dan jika Anda kebetulan mengingat standard error,

243
00:17:19,000 --> 00:17:22,000
mungkin Anda mungkin menganggap ini kasus di mana Anda ingin mencetak standard error,

244
00:17:22,000 --> 00:17:26,000
sehingga fprintf stderr bukan hanya mencetak langsung ke luar standar.

245
00:17:26,000 --> 00:17:31,000
Sekali lagi, itu bukan harapan, tapi kalau itu kesalahan,

246
00:17:31,000 --> 00:17:41,000
ketik printf, maka Anda mungkin ingin membuatnya mencetak ke standard error bukannya keluar standar.

247
00:17:41,000 --> 00:17:44,000
>> Ada yang punya hal lain yang perlu diperhatikan? Ya.

248
00:17:44,000 --> 00:17:47,000
[Siswa] Dapatkah Anda pergi selama [tak terdengar]?

249
00:17:47,000 --> 00:17:55,000
[Rob B.] Ya, binariness sebenarnya atau hanya apa itu?

250
00:17:55,000 --> 00:17:57,000
[Siswa] Jadi Anda kalikan dengan 2?

251
00:17:57,000 --> 00:17:59,000
[Rob B.] Ya, pada dasarnya.

252
00:17:59,000 --> 00:18:11,000
Di tanah biner, kita selalu memiliki set kami digit.

253
00:18:11,000 --> 00:18:22,000
Pergeseran kiri ini dengan 1 dasarnya sisipan di sini di sisi kanan.

254
00:18:22,000 --> 00:18:25,000
Kembali ke ini, hanya mengingat bahwa segala sesuatu dalam biner

255
00:18:25,000 --> 00:18:28,000
adalah kekuatan dari 2, jadi ini merupakan 2 ke 0 tersebut,

256
00:18:28,000 --> 00:18:30,000
ini 2 ke 1, ini 2 ke 2.

257
00:18:30,000 --> 00:18:33,000
Dengan memasukkan 0 ke sisi kanan sekarang, kita hanya menggeser segala sesuatunya.

258
00:18:33,000 --> 00:18:38,000
Apa yang digunakan untuk menjadi 2 ke 0 kini 2 ke 1, 2 adalah untuk 2.

259
00:18:38,000 --> 00:18:41,000
Sisi kanan yang kita dimasukkan

260
00:18:41,000 --> 00:18:44,000
ini tentu akan menjadi 0,

261
00:18:44,000 --> 00:18:46,000
yang masuk akal.

262
00:18:46,000 --> 00:18:49,000
Jika Anda pernah kalikan jumlah dengan 2, itu tidak akan berakhir aneh,

263
00:18:49,000 --> 00:18:54,000
sehingga 2 ke tempat 0 harus 0,

264
00:18:54,000 --> 00:18:59,000
dan ini adalah apa yang saya setengah memperingatkan tentang sebelum adalah jika Anda kebetulan bergeser

265
00:18:59,000 --> 00:19:01,000
melampaui jumlah bit dalam integer,

266
00:19:01,000 --> 00:19:04,000
maka 1 ini akan berakhir pergi.

267
00:19:04,000 --> 00:19:10,000
Itulah satu-satunya khawatir jika Anda kebetulan akan berurusan dengan kapasitas benar-benar besar.

268
00:19:10,000 --> 00:19:15,000
Tapi pada saat itu, maka Anda sedang berhadapan dengan sebuah array dari miliaran hal,

269
00:19:15,000 --> 00:19:25,000
yang tidak mungkin masuk ke dalam memori tetap.

270
00:19:25,000 --> 00:19:31,000
>> Sekarang kita bisa sampai ke pop, yang bahkan lebih mudah.

271
00:19:31,000 --> 00:19:36,000
Anda bisa melakukannya seperti jika Anda kebetulan pop sejumlah,

272
00:19:36,000 --> 00:19:38,000
dan sekarang kau pada kapasitas setengah lagi.

273
00:19:38,000 --> 00:19:42,000
Anda bisa realloc untuk mengecilkan jumlah memori yang Anda miliki,

274
00:19:42,000 --> 00:19:47,000
namun Anda tidak perlu khawatir tentang hal itu, sehingga kasus realloc hanya akan menjadi

275
00:19:47,000 --> 00:19:50,000
tumbuh memori, tidak pernah menyusut memori,

276
00:19:50,000 --> 00:19:59,000
yang akan membuat super pop mudah.

277
00:19:59,000 --> 00:20:02,000
Sekarang antrian, yang akan menjadi seperti tumpukan,

278
00:20:02,000 --> 00:20:06,000
tetapi agar Anda mengambil hal-hal dibalik.

279
00:20:06,000 --> 00:20:10,000
Contoh prototipikal dari antrian adalah garis,

280
00:20:10,000 --> 00:20:12,000
jadi saya kira jika Anda orang Inggris, saya akan mengatakan

281
00:20:12,000 --> 00:20:17,000
contoh prototipikal dari antrian adalah antrian.

282
00:20:17,000 --> 00:20:22,000
Jadi seperti baris, jika Anda adalah orang pertama di garis,

283
00:20:22,000 --> 00:20:24,000
Anda berharap untuk menjadi orang pertama yang keluar dari garis.

284
00:20:24,000 --> 00:20:31,000
Jika Anda adalah orang terakhir di baris, Anda akan menjadi orang terakhir dilayani.

285
00:20:31,000 --> 00:20:35,000
Kami menyebutnya pola FIFO, sedangkan tumpukan adalah LIFO pola.

286
00:20:35,000 --> 00:20:40,000
Kata-kata cukup universal.

287
00:20:40,000 --> 00:20:46,000
>> Seperti tumpukan dan tidak seperti array, antrian biasanya tidak mengizinkan akses ke elemen di tengah.

288
00:20:46,000 --> 00:20:50,000
Di sini, stack, kita memiliki push dan pop.

289
00:20:50,000 --> 00:20:54,000
Di sini, kita kebetulan telah memanggil mereka enqueue dan dequeue.

290
00:20:54,000 --> 00:20:58,000
Saya juga mendengar mereka disebut pergeseran dan unshift.

291
00:20:58,000 --> 00:21:02,000
Saya pernah mendengar orang mengatakan push dan pop juga berlaku untuk antrian.

292
00:21:02,000 --> 00:21:05,000
Aku telah mendengar menyisipkan, menghapus,

293
00:21:05,000 --> 00:21:11,000
sehingga mendorong dan pop, jika Anda berbicara tentang tumpukan, Anda mendorong dan muncul.

294
00:21:11,000 --> 00:21:16,000
Jika Anda berbicara tentang antrian, Anda bisa memilih kata-kata yang ingin Anda gunakan

295
00:21:16,000 --> 00:21:23,000
untuk penyisipan dan penghapusan, dan tidak ada konsensus tentang apa yang harus disebut.

296
00:21:23,000 --> 00:21:27,000
Tapi di sini, kita memiliki enqueue dan dequeue.

297
00:21:27,000 --> 00:21:37,000
Sekarang, struct terlihat hampir identik dengan struct stack.

298
00:21:37,000 --> 00:21:40,000
Tapi kita harus melacak kepala.

299
00:21:40,000 --> 00:21:44,000
Saya kira itu mengatakan di sini, tapi mengapa kita perlu kepala?

300
00:21:53,000 --> 00:21:57,000
Prototipe pada dasarnya identik dengan mendorong dan pop.

301
00:21:57,000 --> 00:21:59,000
Anda dapat menganggapnya sebagai push dan pop.

302
00:21:59,000 --> 00:22:08,000
Satu-satunya perbedaan adalah pop yang kembali-bukan yang terakhir, itu kembali yang pertama.

303
00:22:08,000 --> 00:22:12,000
2, 1, 3, 4, atau sesuatu.

304
00:22:12,000 --> 00:22:14,000
Dan inilah awal.

305
00:22:14,000 --> 00:22:17,000
Antrian kami benar-benar penuh, jadi ada empat unsur di dalamnya.

306
00:22:17,000 --> 00:22:21,000
Akhir antrian kami saat ini 2,

307
00:22:21,000 --> 00:22:24,000
dan sekarang kita pergi untuk memasukkan sesuatu yang lain.

308
00:22:24,000 --> 00:22:29,000
>> Ketika kita ingin memasukkan sesuatu yang lain, apa yang kita lakukan untuk versi tumpukan

309
00:22:29,000 --> 00:22:36,000
adalah kita memperluas kami blok memori.

310
00:22:36,000 --> 00:22:40,000
Apa masalah ini?

311
00:22:40,000 --> 00:22:45,000
[Siswa] Anda memindahkan 2 tersebut.

312
00:22:45,000 --> 00:22:51,000
Apa yang saya katakan sebelumnya tentang akhir antrian,

313
00:22:51,000 --> 00:22:57,000
ini tidak masuk akal bahwa kita mulai dari 1,

314
00:22:57,000 --> 00:23:01,000
maka kita ingin dequeue 1, kemudian dequeue 3, kemudian dequeue 4,

315
00:23:01,000 --> 00:23:05,000
kemudian dequeue 2, kemudian dequeue satu ini.

316
00:23:05,000 --> 00:23:08,000
Kita tidak bisa menggunakan realloc sekarang,

317
00:23:08,000 --> 00:23:11,000
atau setidaknya, Anda harus menggunakan realloc dengan cara yang berbeda.

318
00:23:11,000 --> 00:23:15,000
Tapi mungkin sebaiknya Anda tidak hanya menggunakan realloc.

319
00:23:15,000 --> 00:23:18,000
Anda akan harus secara manual menyalin memori Anda.

320
00:23:18,000 --> 00:23:21,000
>> Ada dua fungsi untuk menyalin memori.

321
00:23:21,000 --> 00:23:25,000
Ada memcopy dan memmove.

322
00:23:25,000 --> 00:23:29,000
Saat ini saya membaca halaman manual untuk melihat mana yang Anda akan ingin menggunakan.

323
00:23:29,000 --> 00:23:35,000
Oke, memcopy, perbedaannya adalah

324
00:23:35,000 --> 00:23:38,000
bahwa memcopy dan memmove, yang menangani kasus ini dengan benar

325
00:23:38,000 --> 00:23:41,000
di mana Anda menyalin ke wilayah yang terjadi tumpang tindih wilayah

326
00:23:41,000 --> 00:23:46,000
Anda menyalin dari.

327
00:23:46,000 --> 00:23:50,000
Memcopy tidak menanganinya. Memmove tidak.

328
00:23:50,000 --> 00:23:59,000
Anda dapat menganggap masalah sebagai-

329
00:23:59,000 --> 00:24:09,000
katakanlah saya ingin menyalin orang ini,

330
00:24:09,000 --> 00:24:13,000
keempat orang ini ke atas.

331
00:24:13,000 --> 00:24:16,000
Pada akhirnya, apa yang array harus seperti

332
00:24:16,000 --> 00:24:26,000
setelah salinan tersebut 2, 1, 2, 1, 3, 4, dan kemudian beberapa hal di akhir.

333
00:24:26,000 --> 00:24:29,000
Tapi ini tergantung pada urutan di mana kita benar-benar menyalin,

334
00:24:29,000 --> 00:24:32,000
karena jika kita tidak mempertimbangkan fakta bahwa wilayah kita menyalin ke

335
00:24:32,000 --> 00:24:35,000
tumpang tindih yang kita menyalin dari,

336
00:24:35,000 --> 00:24:46,000
maka kita bisa melakukan seperti start di sini, copy 2 ke tempat kita ingin pergi,

337
00:24:46,000 --> 00:24:52,000
kemudian memindahkan pointer kita ke depan.

338
00:24:52,000 --> 00:24:56,000
>> Sekarang kita akan berada di sini dan di sini, dan sekarang kami ingin menyalin

339
00:24:56,000 --> 00:25:04,000
orang ini atas orang ini dan bergerak pointer kita ke depan.

340
00:25:04,000 --> 00:25:07,000
Apa yang kita akan akhirnya mendapatkan adalah 2, 1, 2, 1, 2, 1

341
00:25:07,000 --> 00:25:10,000
bukannya 2 yang sesuai, 1, 2, 1, 3, 4 karena

342
00:25:10,000 --> 00:25:15,000
2, 1 mengesampingkan 3 aslinya, 4.

343
00:25:15,000 --> 00:25:19,000
Memmove menangani yang benar.

344
00:25:19,000 --> 00:25:23,000
Dalam hal ini, pada dasarnya hanya selalu menggunakan memmove

345
00:25:23,000 --> 00:25:26,000
karena menangani dengan benar.

346
00:25:26,000 --> 00:25:29,000
Hal ini biasanya tidak melakukan lebih buruk.

347
00:25:29,000 --> 00:25:32,000
Idenya adalah bukan mulai dari awal dan menyalin cara ini

348
00:25:32,000 --> 00:25:35,000
seperti kita lakukan di sini, itu dimulai dari akhir dan salinan dalam,

349
00:25:35,000 --> 00:25:38,000
dan dalam hal ini, Anda tidak pernah memiliki masalah.

350
00:25:38,000 --> 00:25:40,000
Ada kinerja tidak hilang.

351
00:25:40,000 --> 00:25:47,000
Selalu gunakan memmove. Jangan khawatir tentang memcopy.

352
00:25:47,000 --> 00:25:51,000
Dan di sanalah Anda akan harus terpisah memmove

353
00:25:51,000 --> 00:26:01,000
bagian-dibungkus sekitar antrian Anda.

354
00:26:01,000 --> 00:26:04,000
Jangan khawatir jika tidak benar-benar dilakukan.

355
00:26:04,000 --> 00:26:10,000
Ini lebih sulit daripada tumpukan, push pop, dan.

356
00:26:10,000 --> 00:26:15,000
>> Ada yang punya kode yang kami bisa bekerja dengan?

357
00:26:15,000 --> 00:26:21,000
Bahkan jika benar-benar tidak lengkap?

358
00:26:21,000 --> 00:26:23,000
[Mahasiswa] Ya, itu benar-benar lengkap, meskipun.

359
00:26:23,000 --> 00:26:27,000
Benar-benar lengkap baik-baik saja selama kita-bisa Anda menyimpan revisi?

360
00:26:27,000 --> 00:26:32,000
Saya lupa bahwa setiap saat.

361
00:26:32,000 --> 00:26:39,000
Oke, mengabaikan apa yang terjadi ketika kita perlu mengubah ukuran hal.

362
00:26:39,000 --> 00:26:42,000
Sepenuhnya mengabaikan resize.

363
00:26:42,000 --> 00:26:49,000
Jelaskan kode ini.

364
00:26:49,000 --> 00:26:54,000
Aku memeriksa pertama-tama jika ukurannya kurang dari salinan pertama-tama

365
00:26:54,000 --> 00:27:01,000
dan kemudian setelah itu, saya memasukkan-saya mengambil kepala + ukuran,

366
00:27:01,000 --> 00:27:05,000
dan saya pastikan membungkus kapasitas array,

367
00:27:05,000 --> 00:27:08,000
dan saya memasukkan string baru di posisi itu.

368
00:27:08,000 --> 00:27:12,000
Lalu aku meningkatkan ukuran dan kembali benar.

369
00:27:12,000 --> 00:27:22,000
>> [Rob B.] Ini jelas salah satu kasus di mana Anda akan ingin menggunakan mod.

370
00:27:22,000 --> 00:27:25,000
Setiap jenis kasus di mana Anda telah membungkus sekitar, jika Anda berpikir membungkus di sekitar,

371
00:27:25,000 --> 00:27:29,000
pemikiran yang harus segera diwujudkan mod.

372
00:27:29,000 --> 00:27:36,000
Sebagai optimasi cepat / membuat kode Anda satu baris pendek,

373
00:27:36,000 --> 00:27:42,000
Anda melihat bahwa garis segera setelah yang satu ini

374
00:27:42,000 --> 00:27:53,000
hanya ukuran + +, sehingga Anda menggabungkan itu ke baris ini, ukuran + +.

375
00:27:53,000 --> 00:27:58,000
Sekarang di sini, kita memiliki kasus

376
00:27:58,000 --> 00:28:01,000
di mana kita tidak memiliki cukup memori,

377
00:28:01,000 --> 00:28:05,000
jadi kita meningkatkan kapasitas kita dengan 2.

378
00:28:05,000 --> 00:28:09,000
Saya kira Anda bisa memiliki masalah yang sama di sini, tapi kita bisa mengabaikannya sekarang,

379
00:28:09,000 --> 00:28:13,000
di mana jika Anda gagal untuk meningkatkan kapasitas Anda,

380
00:28:13,000 --> 00:28:18,000
maka Anda akan ingin menurunkan kapasitas Anda dengan 2 lagi.

381
00:28:18,000 --> 00:28:24,000
Lain catatan pendek adalah seperti yang dapat Anda lakukan + =,

382
00:28:24,000 --> 00:28:30,000
Anda juga dapat melakukan << =.

383
00:28:30,000 --> 00:28:43,000
Hampir apa pun bisa pergi sebelum sama, + =, | =, & =, << =.

384
00:28:43,000 --> 00:28:52,000
Char * baru blok baru memori.

385
00:28:52,000 --> 00:28:55,000
Oh, di sini.

386
00:28:55,000 --> 00:29:02,000
>> Apa yang orang pikirkan tentang jenis blok baru memori?

387
00:29:02,000 --> 00:29:06,000
[Mahasiswa] Harus char **.

388
00:29:06,000 --> 00:29:12,000
Berpikir kembali ke struct kami di sini,

389
00:29:12,000 --> 00:29:14,000
string adalah apa yang kita merealokasi.

390
00:29:14,000 --> 00:29:21,000
Kami membuat penyimpanan dinamis keseluruhan baru untuk elemen dalam antrian.

391
00:29:21,000 --> 00:29:25,000
Apa yang kita akan menugaskan ke string Anda adalah apa yang kita mallocing sekarang,

392
00:29:25,000 --> 00:29:30,000
dan sebagainya baru akan menjadi char **.

393
00:29:30,000 --> 00:29:34,000
Ini akan menjadi sebuah array dari string.

394
00:29:34,000 --> 00:29:38,000
Lalu apa yang terjadi di mana kita akan kembali palsu?

395
00:29:38,000 --> 00:29:41,000
[Mahasiswa] Haruskah kita melakukan char *?

396
00:29:41,000 --> 00:29:44,000
[Rob B.] Ya, panggilan yang baik.

397
00:29:44,000 --> 00:29:46,000
[Mahasiswa] Apa itu?

398
00:29:46,000 --> 00:29:49,000
[Rob B.] Kami ingin melakukan ukuran char * karena kita tidak lagi-

399
00:29:49,000 --> 00:29:53,000
ini benar-benar akan menjadi masalah yang sangat besar karena sizeof (char) akan menjadi 1.

400
00:29:53,000 --> 00:29:55,000
Sizeof char * akan menjadi 4,

401
00:29:55,000 --> 00:29:58,000
sehingga banyak kali ketika Anda sedang berhadapan dengan ints,

402
00:29:58,000 --> 00:30:01,000
Anda cenderung untuk pergi dengan itu karena ukuran int dan ukuran * int

403
00:30:01,000 --> 00:30:04,000
pada sistem 32-bit akan menjadi hal yang sama.

404
00:30:04,000 --> 00:30:09,000
Tapi di sini, sizeof (char) dan sizeof (char *) sekarang akan menjadi hal yang sama.

405
00:30:09,000 --> 00:30:15,000
>> Apa keadaan di mana kita kembali palsu?

406
00:30:15,000 --> 00:30:17,000
[Mahasiswa] New adalah null.

407
00:30:17,000 --> 00:30:23,000
Ya, jika baru adalah null, kita kembali palsu,

408
00:30:23,000 --> 00:30:34,000
dan aku akan melemparkan ke bawah sini-

409
00:30:34,000 --> 00:30:37,000
[Mahasiswa] [tak terdengar]

410
00:30:37,000 --> 00:30:39,000
[Rob B.] Ya, ini baik-baik saja.

411
00:30:39,000 --> 00:30:46,000
Anda juga bisa melakukan 2 kali kapasitas atau pergeseran kapasitas 1 dan kemudian hanya meletakkannya di sini atau apa pun.

412
00:30:46,000 --> 00:30:52,000
Kami akan melakukannya yang kita miliki.

413
00:30:52,000 --> 00:30:56,000
Kapasitas >> = 1.

414
00:30:56,000 --> 00:31:08,000
Dan Anda tidak akan pernah perlu khawatir tentang kehilangan tempat 1 s

415
00:31:08,000 --> 00:31:12,000
karena Anda meninggalkan bergeser oleh 1, sehingga tempat 1 adalah selalu 0,

416
00:31:12,000 --> 00:31:16,000
sehingga benar bergeser oleh 1, Anda masih akan baik-baik saja.

417
00:31:16,000 --> 00:31:19,000
[Siswa] Apakah Anda perlu melakukan itu sebelum kembali?

418
00:31:19,000 --> 00:31:29,000
[Rob B.] Ya, ini membuat benar-benar tidak masuk akal.

419
00:31:29,000 --> 00:31:36,000
>> Sekarang asumsikan kita akan berakhir kembali benar sampai akhir.

420
00:31:36,000 --> 00:31:39,000
Cara kita akan melakukan hal-memmoves,

421
00:31:39,000 --> 00:31:45,000
kita perlu berhati-hati dengan bagaimana kita melakukannya.

422
00:31:45,000 --> 00:31:50,000
Apakah ada yang punya saran untuk bagaimana kita melakukannya?

423
00:32:17,000 --> 00:32:21,000
Berikut kami mulai.

424
00:32:21,000 --> 00:32:28,000
Tak pelak lagi, kami ingin mulai dari awal lagi

425
00:32:28,000 --> 00:32:35,000
dan copy hal-hal dari sana, 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
Bagaimana Anda melakukan itu?

427
00:32:41,000 --> 00:32:52,000
Pertama, saya harus melihat halaman manual untuk memmove lagi.

428
00:32:52,000 --> 00:32:57,000
Memmove, urutan argumen selalu penting.

429
00:32:57,000 --> 00:33:01,000
Kami ingin tujuan pertama kami, sumber kedua, ketiga ukuran.

430
00:33:01,000 --> 00:33:06,000
Ada banyak fungsi yang membalikkan sumber dan tujuan.

431
00:33:06,000 --> 00:33:11,000
Tujuan, sumber cenderung konsisten agak.

432
00:33:17,000 --> 00:33:21,000
Pindah, apa itu kembali?

433
00:33:21,000 --> 00:33:27,000
Ia mengembalikan pointer ke tujuan, untuk alasan apapun Anda mungkin ingin itu.

434
00:33:27,000 --> 00:33:32,000
Aku bisa gambar membacanya, tapi kami ingin pindah ke tujuan kami.

435
00:33:32,000 --> 00:33:35,000
>> Apa yang tujuan kita akan?

436
00:33:35,000 --> 00:33:37,000
[Mahasiswa] New.

437
00:33:37,000 --> 00:33:39,000
[Rob B.] Ya, dan di mana kita menyalin dari?

438
00:33:39,000 --> 00:33:43,000
Hal pertama yang kita menyalin ini 1, 3, 4.

439
00:33:43,000 --> 00:33:50,000
Apa-1 ini, 3, 4.

440
00:33:50,000 --> 00:33:55,000
Apa alamat ini 1?

441
00:33:55,000 --> 00:33:58,000
Apa alamat itu 1?

442
00:33:58,000 --> 00:34:01,000
[Mahasiswa] [tak terdengar]

443
00:34:01,000 --> 00:34:03,000
[Rob B.] Kepala + alamat dari elemen pertama.

444
00:34:03,000 --> 00:34:05,000
Bagaimana kita mendapatkan elemen pertama dalam array?

445
00:34:05,000 --> 00:34:10,000
[Siswa] Antrian.

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

447
00:34:15,000 --> 00:34:20,000
Ingat, di sini, kepala kita adalah 1.

448
00:34:20,000 --> 00:34:24,000
Darn it. Saya hanya berpikir itu ajaib-

449
00:34:24,000 --> 00:34:29,000
Di sini, kepala kita adalah 1. Aku akan mengubah warna saya juga.

450
00:34:29,000 --> 00:34:36,000
Dan di sini adalah string.

451
00:34:36,000 --> 00:34:41,000
Ini, kita bisa menulis seperti yang kita lakukan di sini

452
00:34:41,000 --> 00:34:43,000
dengan kepala + q.strings.

453
00:34:43,000 --> 00:34:51,000
Banyak orang juga menulis & q.strings [kepala].

454
00:34:51,000 --> 00:34:55,000
Hal ini tidak benar-benar ada kurang efisien.

455
00:34:55,000 --> 00:34:58,000
Anda mungkin menganggapnya sebagai Anda dereferencing dan kemudian mendapatkan alamat,

456
00:34:58,000 --> 00:35:04,000
namun compiler akan menerjemahkannya dengan apa yang kita miliki sebelumnya pula, q.strings + kepala.

457
00:35:04,000 --> 00:35:06,000
Entah cara Anda ingin memikirkan hal itu.

458
00:35:06,000 --> 00:35:11,000
>> Dan berapa banyak byte yang kita ingin menyalin?

459
00:35:11,000 --> 00:35:15,000
[Mahasiswa] Kapasitas - kepala.

460
00:35:15,000 --> 00:35:18,000
Kapasitas - kepala.

461
00:35:18,000 --> 00:35:21,000
Dan kemudian Anda selalu bisa menulis contoh

462
00:35:21,000 --> 00:35:23,000
untuk mengetahui apakah itu benar.

463
00:35:23,000 --> 00:35:26,000
[Mahasiswa] Perlu dibagi 2 kemudian.

464
00:35:26,000 --> 00:35:30,000
Ya, jadi saya kira kita bisa menggunakan ukuran.

465
00:35:30,000 --> 00:35:35,000
Kami masih memiliki ukuran yang-

466
00:35:35,000 --> 00:35:39,000
menggunakan ukuran, kami memiliki ukuran sama dengan 4.

467
00:35:39,000 --> 00:35:42,000
Ukuran kami adalah 4. Kepala kami adalah 1.

468
00:35:42,000 --> 00:35:46,000
Kami ingin menyalin 3 elemen.

469
00:35:46,000 --> 00:35:54,000
Itulah kewarasan memeriksa ukuran itu - kepala dengan benar 3.

470
00:35:54,000 --> 00:35:58,000
Dan datang kembali ke sini, seperti yang kita katakan sebelumnya,

471
00:35:58,000 --> 00:36:00,000
jika kita menggunakan kemampuan, maka kita harus membagi dengan 2

472
00:36:00,000 --> 00:36:04,000
karena kita sudah tumbuh kemampuan kita, jadi bukan, kita akan menggunakan ukuran.

473
00:36:11,000 --> 00:36:13,000
Bahwa salinan bagian itu.

474
00:36:13,000 --> 00:36:18,000
Sekarang, kita perlu menyalin bagian lain, bagian yang tersisa dari awal.

475
00:36:18,000 --> 00:36:28,000
>> Itu akan memmove ke posisi apa?

476
00:36:28,000 --> 00:36:32,000
[Mahasiswa] Plus ukuran - kepala.

477
00:36:32,000 --> 00:36:38,000
Ya, jadi kami telah disalin dalam ukuran - byte kepala,

478
00:36:38,000 --> 00:36:43,000
dan jadi di mana kita ingin menyalin byte tersisa yang baru

479
00:36:43,000 --> 00:36:48,000
dan kemudian ukuran minus-baik, jumlah byte kita sudah disalin masuk

480
00:36:48,000 --> 00:36:52,000
Dan kemudian di mana kita menyalin dari?

481
00:36:52,000 --> 00:36:54,000
[Mahasiswa] Q.strings [0].

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

483
00:36:56,000 --> 00:37:02,000
Kita juga bisa melakukan & q.strings [0].

484
00:37:02,000 --> 00:37:05,000
Ini secara signifikan kurang umum daripada ini.

485
00:37:05,000 --> 00:37:14,000
Jika itu hanya akan menjadi 0, maka Anda akan cenderung melihat q.strings.

486
00:37:14,000 --> 00:37:16,000
Di situlah kita menyalin dari.

487
00:37:16,000 --> 00:37:18,000
Berapa banyak byte yang kita miliki untuk menyalin? >> [Siswa] 10.

488
00:37:18,000 --> 00:37:20,000
Benar.

489
00:37:20,000 --> 00:37:25,000
[Mahasiswa] Apakah kita harus kalikan 5 - 10 kali ukuran byte atau sesuatu?

490
00:37:25,000 --> 00:37:30,000
Ya, jadi ini adalah di mana-apa sebenarnya yang kita menyalin?

491
00:37:30,000 --> 00:37:32,000
[Mahasiswa] [tak terdengar]

492
00:37:32,000 --> 00:37:34,000
Apa jenis hal yang kita menyalin?

493
00:37:34,000 --> 00:37:36,000
[Mahasiswa] [tak terdengar]

494
00:37:36,000 --> 00:37:41,000
Ya, jadi char * s yang kita menyalin, kita tidak tahu di mana mereka berasal.

495
00:37:41,000 --> 00:37:47,000
Nah, di mana mereka menunjuk ke, seperti string, kita akhirnya mendorongnya ke antrian

496
00:37:47,000 --> 00:37:49,000
atau enqueuing ke antrian.

497
00:37:49,000 --> 00:37:51,000
Dimana mereka berasal dari, kita tidak tahu.

498
00:37:51,000 --> 00:37:56,000
Kita hanya perlu untuk melacak file * char s sendiri.

499
00:37:56,000 --> 00:38:00,000
Kami tidak ingin menyalin ukuran - byte kepala.

500
00:38:00,000 --> 00:38:03,000
Kami ingin menyalin ukuran - Kepala char * s,

501
00:38:03,000 --> 00:38:11,000
jadi kita akan kalikan ini dengan sizeof (char *).

502
00:38:11,000 --> 00:38:17,000
Sama di sini, kepala * sizeof (char *).

503
00:38:17,000 --> 00:38:24,000
>> [Siswa] Bagaimana [tak terdengar]?

504
00:38:24,000 --> 00:38:26,000
Ini di sini?

505
00:38:26,000 --> 00:38:28,000
[Mahasiswa] Tidak, di bawah itu, ukuran - kepala.

506
00:38:28,000 --> 00:38:30,000
[Rob B.] ini di sini?

507
00:38:30,000 --> 00:38:32,000
Pointer aritmatika.

508
00:38:32,000 --> 00:38:35,000
Bagaimana aritmatika pointer akan bekerja adalah

509
00:38:35,000 --> 00:38:40,000
secara otomatis mengalikan oleh ukuran dari jenis yang kita hadapi.

510
00:38:40,000 --> 00:38:46,000
Sama seperti di sini, baru + (ukuran - kepala)

511
00:38:46,000 --> 00:38:56,000
adalah persis setara dengan & [ukuran - kepala] baru

512
00:38:56,000 --> 00:39:00,000
sampai kita berharap bahwa bekerja dengan benar,

513
00:39:00,000 --> 00:39:04,000
karena jika kita sedang berhadapan dengan sebuah array int, maka kita tidak indeks oleh int-

514
00:39:04,000 --> 00:39:07,000
atau apakah itu dari ukuran 5 dan Anda ingin elemen 4, maka kita indeks ke dalam

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

516
00:39:10,000 --> 00:39:14,000
Anda jangan-[4] * ukuran int.

517
00:39:14,000 --> 00:39:21,000
Yang menangani secara otomatis, dan kasus ini

518
00:39:21,000 --> 00:39:29,000
secara harfiah setara, sehingga sintaks braket

519
00:39:29,000 --> 00:39:34,000
hanya akan dikonversi ini segera setelah Anda mengkompilasi.

520
00:39:34,000 --> 00:39:38,000
Itu sesuatu yang Anda harus berhati-hati itu

521
00:39:38,000 --> 00:39:42,000
ketika Anda menambahkan ukuran - kepala

522
00:39:42,000 --> 00:39:45,000
Anda tidak menambahkan satu byte.

523
00:39:45,000 --> 00:39:53,000
Anda menambahkan satu char *, yang dapat menjadi salah satu byte atau apa pun.

524
00:39:53,000 --> 00:39:56,000
>> Pertanyaan lain?

525
00:39:56,000 --> 00:40:04,000
Oke, dequeue akan menjadi lebih mudah.

526
00:40:04,000 --> 00:40:11,000
Saya akan memberikan satu menit untuk melaksanakan.

527
00:40:11,000 --> 00:40:18,000
Oh, dan saya kira ini adalah situasi yang sama di mana

528
00:40:18,000 --> 00:40:21,000
apa kasus enqueue, jika kita enqueuing nol,

529
00:40:21,000 --> 00:40:24,000
mungkin kita ingin menanganinya, mungkin kita tidak.

530
00:40:24,000 --> 00:40:27,000
Kami tidak akan melakukannya lagi di sini, tapi sama seperti kasus tumpukan kami.

531
00:40:27,000 --> 00:40:34,000
Jika kita enqueue nol, kita mungkin ingin mengabaikannya.

532
00:40:34,000 --> 00:40:40,000
Ada yang punya beberapa kode saya dapat menarik?

533
00:40:40,000 --> 00:40:45,000
[Mahasiswa] Saya hanya memiliki dequeue.

534
00:40:45,000 --> 00:40:56,000
Versi 2 adalah bahwa-oke.

535
00:40:56,000 --> 00:40:59,000
Anda ingin menjelaskan?

536
00:40:59,000 --> 00:41:01,000
[Mahasiswa] Pertama, Anda memastikan ada sesuatu dalam antrian

537
00:41:01,000 --> 00:41:07,000
dan bahwa ukuran akan turun 1.

538
00:41:07,000 --> 00:41:11,000
Anda perlu melakukan itu, dan kemudian Anda kembali kepala

539
00:41:11,000 --> 00:41:13,000
dan kemudian menggerakkan kepala ke atas 1.

540
00:41:13,000 --> 00:41:19,000
Oke, jadi ada kasus sudut kita harus mempertimbangkan. Ya.

541
00:41:19,000 --> 00:41:24,000
[Mahasiswa] Jika kepala Anda adalah pada elemen terakhir,

542
00:41:24,000 --> 00:41:26,000
maka Anda tidak ingin kepala ke titik di luar array.

543
00:41:26,000 --> 00:41:29,000
>> Ya, sehingga segera setelah kepala hits akhir array kita,

544
00:41:29,000 --> 00:41:35,000
ketika kita dequeue, kepala kita harus modded kembali ke 0.

545
00:41:35,000 --> 00:41:40,000
Sayangnya, kita tidak bisa melakukan itu dalam satu langkah.

546
00:41:40,000 --> 00:41:44,000
Saya kira cara saya mungkin akan memperbaikinya adalah

547
00:41:44,000 --> 00:41:52,000
ini akan menjadi char *, apa yang kita kembali,

548
00:41:52,000 --> 00:41:55,000
apapun nama variabel Anda ingin menjadi.

549
00:41:55,000 --> 00:42:02,000
Kemudian kita ingin mod kepala oleh kemampuan kita

550
00:42:02,000 --> 00:42:10,000
dan kemudian kembali ret.

551
00:42:10,000 --> 00:42:14,000
Banyak orang di sini yang mungkin mereka lakukan-

552
00:42:14,000 --> 00:42:19,000
ini adalah kasus-Anda akan melihat orang-orang lakukan jika kepala

553
00:42:19,000 --> 00:42:29,000
lebih besar dari kapasitas, lakukan kepala - kapasitas.

554
00:42:29,000 --> 00:42:36,000
Dan itu hanya bekerja sekitar apa mod ini.

555
00:42:36,000 --> 00:42:41,000
Kepala mod = kapasitas jauh lebih bersih

556
00:42:41,000 --> 00:42:51,000
dari pembungkus sekitar daripada jika kepala lebih besar daripada kepala kapasitas - kapasitas.

557
00:42:51,000 --> 00:42:56,000
>> Pertanyaan?

558
00:42:56,000 --> 00:43:02,000
Oke, hal terakhir yang kita telah meninggalkan adalah linked list kami.

559
00:43:02,000 --> 00:43:07,000
Anda mungkin akan digunakan untuk beberapa perilaku linked list jika Anda melakukan

560
00:43:07,000 --> 00:43:11,000
terkait daftar dalam tabel hash Anda, jika Anda melakukan tabel hash.

561
00:43:11,000 --> 00:43:15,000
Saya sangat merekomendasikan melakukan tabel hash.

562
00:43:15,000 --> 00:43:17,000
Anda mungkin sudah melakukan trie,

563
00:43:17,000 --> 00:43:23,000
tetapi mencoba lebih sulit.

564
00:43:23,000 --> 00:43:27,000
Secara teori, mereka asimtotik lebih baik.

565
00:43:27,000 --> 00:43:30,000
Tapi hanya melihat papan besar,

566
00:43:30,000 --> 00:43:35,000
dan mencoba tidak pernah berbuat lebih baik, dan mereka mengambil lebih banyak memori.

567
00:43:35,000 --> 00:43:43,000
Segala sesuatu tentang mencoba akhirnya menjadi buruk untuk bekerja lebih.

568
00:43:43,000 --> 00:43:49,000
Ini adalah apa solusi David Malan selalu adalah

569
00:43:49,000 --> 00:43:56,000
adalah dia selalu posting solusi trie, dan mari kita lihat di mana dia saat ini.

570
00:43:56,000 --> 00:44:00,000
Apa dia di bawah, David J?

571
00:44:00,000 --> 00:44:06,000
Dia # 18, jadi itu tidak terlalu buruk,

572
00:44:06,000 --> 00:44:09,000
dan itu akan menjadi salah satu yang terbaik mencoba Anda bisa memikirkan

573
00:44:09,000 --> 00:44:17,000
atau salah satu yang terbaik mencoba dari trie.

574
00:44:17,000 --> 00:44:23,000
Apakah tidak bahkan solusi aslinya?

575
00:44:23,000 --> 00:44:29,000
Saya merasa seperti trie solusi cenderung lebih dalam kisaran penggunaan RAM.

576
00:44:29,000 --> 00:44:33,000
>> Pergi ke bagian paling atas, dan penggunaan RAM dalam satu digit.

577
00:44:33,000 --> 00:44:36,000
Turun ke bawah, dan kemudian Anda mulai melihat mencoba

578
00:44:36,000 --> 00:44:41,000
di mana Anda mendapatkan penggunaan RAM benar-benar besar,

579
00:44:41,000 --> 00:44:45,000
dan mencoba lebih sulit.

580
00:44:45,000 --> 00:44:53,000
Tidak sepenuhnya layak tapi pengalaman pendidikan jika Anda melakukan satu.

581
00:44:53,000 --> 00:44:56,000
Yang terakhir adalah linked list kami,

582
00:44:56,000 --> 00:45:04,000
dan tiga hal, tumpukan, antrian, dan daftar terhubung,

583
00:45:04,000 --> 00:45:09,000
setiap hal di masa depan Anda pernah dilakukan di ilmu komputer

584
00:45:09,000 --> 00:45:12,000
akan menganggap Anda memiliki keakraban dengan hal-hal ini.

585
00:45:12,000 --> 00:45:19,000
Mereka hanya begitu fundamental bagi segala sesuatu.

586
00:45:19,000 --> 00:45:25,000
>> Linked daftar, dan di sini kami telah daftar tunggal terkait akan menjadi implementasi kami.

587
00:45:25,000 --> 00:45:34,000
Apa tunggal terkait berarti sebagai lawan ganda terkait? Ya.

588
00:45:34,000 --> 00:45:37,000
[Mahasiswa] Ini hanya menunjuk ke pointer berikutnya daripada ke pointer,

589
00:45:37,000 --> 00:45:39,000
seperti yang mendahuluinya dan yang setelah itu.

590
00:45:39,000 --> 00:45:44,000
Ya, sehingga dalam format gambar, apa yang aku lakukan?

591
00:45:44,000 --> 00:45:48,000
Aku punya dua hal. Saya memiliki gambar dan gambar.

592
00:45:48,000 --> 00:45:51,000
Dalam format gambar, daftar tunggal kami terkait,

593
00:45:51,000 --> 00:45:57,000
pasti, kami memiliki beberapa jenis pointer ke kepala daftar kami,

594
00:45:57,000 --> 00:46:02,000
dan kemudian dalam daftar kami, kami hanya memiliki pointer,

595
00:46:02,000 --> 00:46:05,000
dan mungkin ini poin ke null.

596
00:46:05,000 --> 00:46:08,000
Ini akan menjadi gambar khas dari linked list tunggal.

597
00:46:08,000 --> 00:46:14,000
Sebuah daftar ganda terkait, Anda dapat pergi ke belakang.

598
00:46:14,000 --> 00:46:19,000
Jika saya memberi Anda setiap node dalam daftar, maka Anda selalu bisa mendapatkan

599
00:46:19,000 --> 00:46:23,000
node lain dalam daftar jika itu adalah daftar ganda terkait.

600
00:46:23,000 --> 00:46:27,000
Tapi kalau aku mendapatkan simpul ketiga dalam daftar dan itu adalah daftar sendiri-sendiri terkait,

601
00:46:27,000 --> 00:46:30,000
ada cara Anda pernah akan sampai ke node pertama dan kedua.

602
00:46:30,000 --> 00:46:34,000
Dan ada manfaat dan detriments, dan satu yang jelas

603
00:46:34,000 --> 00:46:42,000
adalah Anda mengambil ukuran yang lebih, dan Anda harus melacak di mana hal-hal ini menunjuk sekarang.

604
00:46:42,000 --> 00:46:49,000
Tapi kita hanya peduli tunggal terkait.

605
00:46:49,000 --> 00:46:53,000
>> Beberapa hal yang kita akan harus melaksanakan.

606
00:46:53,000 --> 00:47:00,000
Anda typedef struct node, int i: struct simpul * berikutnya; simpul.

607
00:47:00,000 --> 00:47:09,000
Itu typedef harus dibakar ke dalam pikiran Anda.

608
00:47:09,000 --> 00:47:14,000
Kuis 1 harus seperti memberikan typedef dari simpul linked list,

609
00:47:14,000 --> 00:47:18,000
dan Anda harus dapat segera menuliskan yang turun

610
00:47:18,000 --> 00:47:22,000
bahkan tanpa berpikir tentang hal itu.

611
00:47:22,000 --> 00:47:27,000
Saya kira beberapa pertanyaan, mengapa kita perlu struct di sini?

612
00:47:27,000 --> 00:47:32,000
Mengapa tidak bisa kita katakan * simpul?

613
00:47:32,000 --> 00:47:35,000
[Mahasiswa] [tak terdengar]

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

615
00:47:38,000 --> 00:47:44,000
Satu-satunya hal yang mendefinisikan node sebagai sesuatu yang

616
00:47:44,000 --> 00:47:47,000
adalah typedef itu sendiri.

617
00:47:47,000 --> 00:47:55,000
Tapi seperti dari titik ini, ketika kita jenis parsing melalui simpul definisi struct,

618
00:47:55,000 --> 00:48:01,000
kami belum selesai typedef kami belum, jadi karena typedef belum selesai,

619
00:48:01,000 --> 00:48:05,000
simpul tidak ada.

620
00:48:05,000 --> 00:48:12,000
Tapi struct simpul tidak, dan simpul ini di sini,

621
00:48:12,000 --> 00:48:14,000
ini juga bisa disebut apa pun.

622
00:48:14,000 --> 00:48:16,000
Ini bisa disebut n.

623
00:48:16,000 --> 00:48:19,000
Ini bisa disebut simpul linked list.

624
00:48:19,000 --> 00:48:21,000
Ini bisa disebut apa-apa.

625
00:48:21,000 --> 00:48:26,000
Tapi ini simpul struct perlu disebut hal yang sama seperti ini simpul struct.

626
00:48:26,000 --> 00:48:29,000
Apa yang Anda sebut ini harus juga berada di sini,

627
00:48:29,000 --> 00:48:32,000
dan sebagainya yang juga menjawab titik kedua dari pertanyaan

628
00:48:32,000 --> 00:48:37,000
itulah sebabnya mengapa-banyak kali ketika Anda melihat structs dan typedef struct,

629
00:48:37,000 --> 00:48:42,000
Anda akan melihat structs anonim di mana Anda hanya akan melihat struct typedef,

630
00:48:42,000 --> 00:48:47,000
pelaksanaan struct, kamus, atau apa pun.

631
00:48:47,000 --> 00:48:51,000
>> Kenapa di sini kita perlu untuk mengatakan simpul?

632
00:48:51,000 --> 00:48:54,000
Mengapa tidak bisa itu menjadi struct anonim?

633
00:48:54,000 --> 00:48:56,000
Ini hampir jawaban yang sama.

634
00:48:56,000 --> 00:48:58,000
[Siswa] Anda perlu menyebutnya dalam struct.

635
00:48:58,000 --> 00:49:04,000
Ya, dalam struct, Anda perlu merujuk pada struct itu sendiri.

636
00:49:04,000 --> 00:49:10,000
Jika Anda tidak memberikan struct nama, jika itu sebuah struct anonim, Anda tidak bisa menyebutnya.

637
00:49:10,000 --> 00:49:17,000
Dan last but not least-ini semua harus agak mudah,

638
00:49:17,000 --> 00:49:20,000
dan mereka akan membantu Anda menyadari jika Anda sedang menulis ini turun

639
00:49:20,000 --> 00:49:24,000
bahwa Anda sedang melakukan sesuatu yang salah jika macam hal tidak masuk akal.

640
00:49:24,000 --> 00:49:28,000
Last but not least, mengapa hal ini harus struct * simpul?

641
00:49:28,000 --> 00:49:34,000
Mengapa tidak bisa hanya menjadi struct node berikutnya?

642
00:49:34,000 --> 00:49:37,000
[Mahasiswa] Pointer ke struct berikutnya.

643
00:49:37,000 --> 00:49:39,000
Itu pasti apa yang kita inginkan.

644
00:49:39,000 --> 00:49:42,000
Kenapa bisa tidak pernah menjadi struct node berikutnya?

645
00:49:42,000 --> 00:49:50,000
Mengapa harus struct simpul * selanjutnya? Ya.

646
00:49:50,000 --> 00:49:53,000
[Siswa] Ini seperti infinite loop.

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

648
00:49:55,000 --> 00:49:57,000
[Mahasiswa] Itu semua akan berada dalam satu.

649
00:49:57,000 --> 00:50:02,000
Ya, hanya berpikir tentang bagaimana kita akan melakukan ukuran atau sesuatu.

650
00:50:02,000 --> 00:50:08,000
Ukuran struct pada dasarnya + atau - beberapa pola sini atau di sana.

651
00:50:08,000 --> 00:50:15,000
Ini pada dasarnya akan menjadi jumlah ukuran dari hal-hal di struct.

652
00:50:15,000 --> 00:50:18,000
Ini di sini, tanpa mengubah apapun, ukuran akan menjadi mudah.

653
00:50:18,000 --> 00:50:24,000
Ukuran simpul struct akan menjadi ukuran i ukuran + berikutnya.

654
00:50:24,000 --> 00:50:27,000
Ukuran saya akan menjadi 4. Ukuran selanjutnya akan menjadi 4.

655
00:50:27,000 --> 00:50:30,000
Ukuran simpul struct akan menjadi 8.

656
00:50:30,000 --> 00:50:34,000
Jika kita tidak memiliki *, memikirkan sizeof,

657
00:50:34,000 --> 00:50:37,000
maka sizeof (i) akan menjadi 4.

658
00:50:37,000 --> 00:50:43,000
Ukuran simpul struct selanjutnya akan menjadi ukuran i + ukuran struct simpul berikutnya

659
00:50:43,000 --> 00:50:46,000
+ Ukuran + i ukuran node struct berikutnya.

660
00:50:46,000 --> 00:50:55,000
Ini akan menjadi rekursi tak terbatas node.

661
00:50:55,000 --> 00:51:00,000
Inilah sebabnya mengapa hal ini adalah bagaimana hal-hal yang harus.

662
00:51:00,000 --> 00:51:03,000
>> Sekali lagi, pasti menghafal itu,

663
00:51:03,000 --> 00:51:06,000
atau setidaknya mengerti cukup bahwa Anda dapat dapat

664
00:51:06,000 --> 00:51:12,000
Alasan melalui apa yang seharusnya terlihat seperti.

665
00:51:12,000 --> 00:51:14,000
Hal-hal yang kita akan ingin menerapkan.

666
00:51:14,000 --> 00:51:18,000
Jika panjang daftar-

667
00:51:18,000 --> 00:51:21,000
Anda bisa menipu dan tetap sekitar

668
00:51:21,000 --> 00:51:24,000
global yang panjang atau sesuatu, tapi kami tidak akan melakukan itu.

669
00:51:24,000 --> 00:51:28,000
Kita akan menghitung panjang daftar.

670
00:51:28,000 --> 00:51:34,000
Kami telah mengandung, sehingga pada dasarnya seperti pencarian,

671
00:51:34,000 --> 00:51:41,000
jadi kami memiliki daftar link dari bilangan bulat untuk melihat apakah bilangan bulat ini berada di linked list.

672
00:51:41,000 --> 00:51:44,000
Tambahkan akan memasukkan pada awal daftar.

673
00:51:44,000 --> 00:51:46,000
Append akan memasukkan di akhir.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted akan memasukkan ke dalam posisi yang diurutkan dalam daftar.

675
00:51:53,000 --> 00:52:01,000
Jenis Insert_sorted dari mengasumsikan bahwa Anda tidak pernah digunakan tambahkan atau append dengan cara yang buruk.

676
00:52:01,000 --> 00:52:09,000
>> Insert_sorted ketika Anda menerapkan insert_sorted-

677
00:52:09,000 --> 00:52:13,000
katakanlah kita memiliki daftar kami terkait.

678
00:52:13,000 --> 00:52:18,000
Ini adalah apa yang saat ini tampak seperti, 2, 4, 5.

679
00:52:18,000 --> 00:52:24,000
Saya ingin menyisipkan 3, sehingga selama daftar sendiri sudah diurutkan,

680
00:52:24,000 --> 00:52:27,000
sangat mudah untuk menemukan di mana 3 milik.

681
00:52:27,000 --> 00:52:29,000
Saya mulai 2.

682
00:52:29,000 --> 00:52:32,000
Oke, 3 lebih besar dari 2, jadi saya ingin terus berjalan.

683
00:52:32,000 --> 00:52:35,000
Oh, 4 terlalu besar, jadi saya tahu 3 akan pergi di antara 2 dan 4,

684
00:52:35,000 --> 00:52:39,000
dan saya harus memperbaiki pointer dan segala macamnya.

685
00:52:39,000 --> 00:52:43,000
Tetapi jika kita tidak benar-benar menggunakan insert_sorted,

686
00:52:43,000 --> 00:52:50,000
seperti katakan saja saya tambahkan 6,

687
00:52:50,000 --> 00:52:55,000
maka linked list saya akan menjadi ini.

688
00:52:55,000 --> 00:53:01,000
Sekarang tidak masuk akal, sehingga untuk insert_sorted, Anda hanya bisa berasumsi

689
00:53:01,000 --> 00:53:04,000
bahwa daftar diurutkan, meskipun ada operasi

690
00:53:04,000 --> 00:53:09,000
yang dapat menyebabkan hal itu tidak akan diurutkan, dan hanya itu.

691
00:53:09,000 --> 00:53:20,000
Cari membantu insert-sehingga mereka adalah hal utama Anda akan harus melaksanakan.

692
00:53:20,000 --> 00:53:24,000
>> Untuk saat ini, luangkan waktu sebentar untuk melakukan panjang dan berisi,

693
00:53:24,000 --> 00:53:30,000
dan mereka harus relatif cepat.

694
00:53:41,000 --> 00:53:48,000
Menjelang waktu penutupan, sehingga ada yang punya apa-apa untuk panjang atau berisi?

695
00:53:48,000 --> 00:53:50,000
Mereka akan menjadi hampir identik.

696
00:53:50,000 --> 00:53:57,000
[Siswa] Panjang.

697
00:53:57,000 --> 00:54:01,000
Mari kita lihat, revisi.

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

699
00:54:12,000 --> 00:54:15,000
Anda ingin menjelaskan?

700
00:54:15,000 --> 00:54:21,000
[Mahasiswa] saya hanya membuat simpul pointer dan menginisialisasi pertama, yang merupakan variabel global kami,

701
00:54:21,000 --> 00:54:27,000
dan kemudian aku memeriksa untuk melihat apakah itu nol sehingga saya tidak mendapatkan kesalahan seg dan kembali 0 jika itu yang terjadi.

702
00:54:27,000 --> 00:54:34,000
Jika tidak, saya loop melalui, mencatat dalam bilangan bulat

703
00:54:34,000 --> 00:54:38,000
berapa kali saya telah diakses elemen berikutnya dari daftar

704
00:54:38,000 --> 00:54:43,000
dan dalam operasi peningkatan yang sama juga mengakses elemen yang sebenarnya,

705
00:54:43,000 --> 00:54:47,000
dan kemudian saya terus menerus melakukan cek untuk melihat apakah itu nol,

706
00:54:47,000 --> 00:54:56,000
dan jika itu nol, maka Aborts dan hanya mengembalikan jumlah elemen saya sudah diakses.

707
00:54:56,000 --> 00:55:01,000
>> [Rob B.] Apakah ada yang punya komentar pada apa pun?

708
00:55:01,000 --> 00:55:06,000
Hal ini terlihat benar baik bijaksana.

709
00:55:06,000 --> 00:55:10,000
[Mahasiswa] Saya tidak berpikir Anda membutuhkan node == null.

710
00:55:10,000 --> 00:55:13,000
Ya, jadi jika simpul == 0 kembali nol.

711
00:55:13,000 --> 00:55:18,000
Tapi jika node == null maka ini-oh, ada masalah kebenaran.

712
00:55:18,000 --> 00:55:23,000
Itu hanya Anda kembali i, tapi tidak dalam lingkup sekarang.

713
00:55:23,000 --> 00:55:30,000
Anda hanya perlu int i, sehingga i = 0.

714
00:55:30,000 --> 00:55:34,000
Tetapi jika simpul adalah nol, maka saya masih akan menjadi 0,

715
00:55:34,000 --> 00:55:39,000
dan kita akan kembali 0, sehingga kasus ini identik.

716
00:55:39,000 --> 00:55:48,000
Hal lain yang umum adalah untuk menjaga deklarasi

717
00:55:48,000 --> 00:55:51,000
di dalam node untuk loop.

718
00:55:51,000 --> 00:55:54,000
Anda bisa mengatakan-oh, tidak.

719
00:55:54,000 --> 00:55:56,000
Mari kita tetap seperti ini.

720
00:55:56,000 --> 00:55:59,000
Saya mungkin akan menempatkan int i = 0 di sini,

721
00:55:59,000 --> 00:56:05,000
maka simpul simpul * = pertama di sini.

722
00:56:05,000 --> 00:56:11,000
Dan ini mungkin bagaimana-menyingkirkan ini sekarang.

723
00:56:11,000 --> 00:56:14,000
Ini mungkin bagaimana saya akan menulis itu.

724
00:56:14,000 --> 00:56:21,000
Anda bisa juga melihat-hal seperti ini.

725
00:56:21,000 --> 00:56:25,000
Ini untuk struktur lingkaran di sini

726
00:56:25,000 --> 00:56:30,000
harus hampir sama alami untuk Anda sebagai untuk int i = 0

727
00:56:30,000 --> 00:56:33,000
i adalah kurang dari panjang array i + +.

728
00:56:33,000 --> 00:56:38,000
Jika itu bagaimana Anda iterate atas array, ini adalah bagaimana Anda iterate atas daftar link.

729
00:56:38,000 --> 00:56:45,000
>> Ini harus menjadi sifat kedua di beberapa titik.

730
00:56:45,000 --> 00:56:50,000
Dengan itu dalam pikiran, ini akan menjadi hal yang hampir sama.

731
00:56:50,000 --> 00:56:57,000
Anda akan ingin iterate atas daftar link.

732
00:56:57,000 --> 00:57:02,000
Jika node-aku tidak tahu apa nilai yang disebut.

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

734
00:57:04,000 --> 00:57:15,000
Jika nilai pada node yang = i kembali benar, dan hanya itu.

735
00:57:15,000 --> 00:57:18,000
Perhatikan bahwa satu-satunya cara kita pernah kembali palsu

736
00:57:18,000 --> 00:57:23,000
adalah jika kita iterate atas linked list seluruh dan tidak pernah kembali benar,

737
00:57:23,000 --> 00:57:29,000
jadi itulah apa hal ini.

738
00:57:29,000 --> 00:57:36,000
Sebagai sisi catatan-kita mungkin tidak akan bisa menambahkan atau tambahkan.

739
00:57:36,000 --> 00:57:39,000
>> Cepat catatan terakhir.

740
00:57:39,000 --> 00:57:52,000
Jika Anda melihat kata kunci statis, jadi mari kita katakan static int count = 0,

741
00:57:52,000 --> 00:57:56,000
maka kita lakukan count + +, Anda pada dasarnya dapat menganggapnya sebagai variabel global,

742
00:57:56,000 --> 00:58:00,000
meskipun saya hanya mengatakan ini adalah bukan bagaimana kita akan mengimplementasikan panjang.

743
00:58:00,000 --> 00:58:06,000
Aku melakukan ini di sini, dan kemudian menghitung + +.

744
00:58:06,000 --> 00:58:11,000
Setiap cara kita bisa masuk ke dalam simpul linked list kami, kami incrementing hitungan kami.

745
00:58:11,000 --> 00:58:15,000
Inti dari ini adalah apa kata kunci statis berarti.

746
00:58:15,000 --> 00:58:20,000
Jika saya hanya punya int count = 0 yang akan menjadi variabel global biasa tua.

747
00:58:20,000 --> 00:58:25,000
Apa artinya menghitung static int adalah bahwa itu adalah variabel global untuk file ini.

748
00:58:25,000 --> 00:58:28,000
Tidak mungkin untuk beberapa file lain,

749
00:58:28,000 --> 00:58:34,000
seperti berpikir pset 5, jika Anda sudah mulai.

750
00:58:34,000 --> 00:58:39,000
Anda memiliki speller.c baik, dan Anda memiliki dictionary.c,

751
00:58:39,000 --> 00:58:42,000
dan jika Anda hanya menyatakan hal yang global, maka apa pun di speller.c

752
00:58:42,000 --> 00:58:45,000
dapat diakses dalam dictionary.c dan sebaliknya.

753
00:58:45,000 --> 00:58:48,000
Variabel global dapat diakses oleh file c.,

754
00:58:48,000 --> 00:58:54,000
namun variabel statis hanya dapat diakses dari dalam file itu sendiri,

755
00:58:54,000 --> 00:59:01,000
sehingga dalam spell checker atau dalam dictionary.c,

756
00:59:01,000 --> 00:59:06,000
ini adalah jenis bagaimana saya akan mendeklarasikan variabel saya untuk ukuran array saya

757
00:59:06,000 --> 00:59:10,000
atau ukuran nomor saya dari kata-kata dalam kamus.

758
00:59:10,000 --> 00:59:15,000
Karena saya tidak ingin mendeklarasikan variabel global yang telah ada akses ke,

759
00:59:15,000 --> 00:59:18,000
Saya benar-benar hanya peduli tentang hal itu untuk tujuan saya sendiri.

760
00:59:18,000 --> 00:59:21,000
>> Hal yang baik tentang ini adalah juga hal-hal nama seluruh tabrakan.

761
00:59:21,000 --> 00:59:27,000
Jika beberapa file lain mencoba untuk menggunakan variabel global yang disebut count, hal-hal pergi sangat, sangat salah,

762
00:59:27,000 --> 00:59:33,000
jadi ini baik menjaga hal-hal yang aman, dan hanya Anda yang dapat mengaksesnya,

763
00:59:33,000 --> 00:59:38,000
dan tidak ada orang lain bisa, dan jika orang lain menyatakan sebuah variabel global yang disebut count,

764
00:59:38,000 --> 00:59:43,000
maka tidak akan mengganggu variabel statis Anda disebut count.

765
00:59:43,000 --> 00:59:47,000
Itulah yang statis. Ini adalah variabel file global.

766
00:59:47,000 --> 00:59:52,000
>> Pertanyaan pada apa pun?

767
00:59:52,000 --> 00:59:59,000
Semua siap. Bye.

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