1
00:00:00,000 --> 00:00:08,250

2
00:00:08,250 --> 00:00:12,680
>> 제이슨 허쉬 호른 : 모든 사람을 환영합니다
제 세븐.

3
00:00:12,680 --> 00:00:15,040
우리는 물론 일주일에 일곱에 있습니다.

4
00:00:15,040 --> 00:00:18,440
그리고 다가오는 목요일
할로윈 그래서 나는 어디로이다

5
00:00:18,440 --> 00:00:21,420
호박처럼 옷을 입고.

6
00:00:21,420 --> 00:00:23,460
나는 구부릴에 넣을 수 없습니다
난 왜 내 신발, 그래서 그건

7
00:00:23,460 --> 00:00:25,660
그냥 양말을 신고.

8
00:00:25,660 --> 00:00:29,220
또한 아래 아무것도 입고 있지 않다
그것의 경우이, 그래서 그것을 제외 할 수

9
00:00:29,220 --> 00:00:29,950
당신에게 혼란.

10
00:00:29,950 --> 00:00:31,860
나는 그것에 대해 미리 사과드립니다.

11
00:00:31,860 --> 00:00:33,170
당신은 상상도 할 필요가 없습니다
무슨 일이 일어나고.

12
00:00:33,170 --> 00:00:34,240
나는 팬티를 착용하고 있습니다.

13
00:00:34,240 --> 00:00:36,170
그래서 모든 좋은입니다.

14
00:00:36,170 --> 00:00:41,120
>> 내가 온 이유에 대해 긴 이야기를 가지고
호박으로 옷을 입고,하지만 난에 갈거야

15
00:00:41,120 --> 00:00:45,110
이 섹션의 뒷부분에 그 내용을 저장
내가 시작하려는 때문에.

16
00:00:45,110 --> 00:00:47,720
우리는 흥미로운 일들을 많이 가지고
이번 주에 이동합니다.

17
00:00:47,720 --> 00:00:51,810
그들 대부분이 직접 관련
주의 문제 설정, 맞춤법 오류.

18
00:00:51,810 --> 00:00:54,680
우리는 링크를 통해 갈거야
목록 및 해시 테이블

19
00:00:54,680 --> 00:00:57,160
전체 섹션.

20
00:00:57,160 --> 00:01:02,490
나는 매주 목록을이 목록을 넣어
당신이 당신을 도울 수에 대한 자원

21
00:01:02,490 --> 00:01:04,120
이 과정에서 재료.

22
00:01:04,120 --> 00:01:07,600
손실의 경우 또는 경우 일부를 찾고
자세한 내용은 다음 중 하나를 체크 아웃

23
00:01:07,600 --> 00:01:09,930
이러한 자원.

24
00:01:09,930 --> 00:01:14,530
>> 또, pset6는 맞춤법 오류입니다,
이번 주 PSET.

25
00:01:14,530 --> 00:01:17,690
그리고 그것은 또한 당신을 격려, 그리고
다른를 사용하기를 권장

26
00:01:17,690 --> 00:01:20,320
자원 특히이 PSET하십시오.

27
00:01:20,320 --> 00:01:23,390
특히, 세 I했습니다
화면에 나열 -

28
00:01:23,390 --> 00:01:27,160
우리가 잘 알고 있었어요 GDB,
지금 잠시 동안 사용하고있다

29
00:01:27,160 --> 00:01:29,270
이번 주 매우 도움이 될 것이다.

30
00:01:29,270 --> 00:01:30,190
그래서 나는 여기에서 그졌습니다.

31
00:01:30,190 --> 00:01:32,910
그러나 때마다 당신은 C와 함께 작업하고,
당신은 항상 GDB를하기 위해 사용되어야한다

32
00:01:32,910 --> 00:01:34,430
프로그램을 디버깅합니다.

33
00:01:34,430 --> 00:01:36,660
이번 주에는 또한 Valgrind의.

34
00:01:36,660 --> 00:01:38,535
사람은 Valgrind의가 무엇을 알고 있나요?

35
00:01:38,535 --> 00:01:42,184

36
00:01:42,184 --> 00:01:43,890
>> 청중 : 그것은 메모리 누수를 확인?

37
00:01:43,890 --> 00:01:45,950
>> 제이슨 허쉬 호른 : Valgrind의
메모리 누수를 확인합니다.

38
00:01:45,950 --> 00:01:49,970
그래서 경우에 당신의 malloc 뭔가 당신의
이 프로그램은, 당신은 메모리를 요구하고 있습니다.

39
00:01:49,970 --> 00:01:52,920
프로그램의 끝에서, 당신은이
당신이 모든 걸에서 무료로 쓸 수

40
00:01:52,920 --> 00:01:54,800
다시 메모리를 제공하기 위해 malloc으로 할당.

41
00:01:54,800 --> 00:01:58,420
당신은 말에 무료로 작성하지 않은 경우
프로그램은 결론에 온다

42
00:01:58,420 --> 00:02:00,000
모든 것이 자동으로 켜집니다
해제.

43
00:02:00,000 --> 00:02:02,340
그리고 작은 프로그램을 위해, 그것의
그 큰되지 거래.

44
00:02:02,340 --> 00:02:05,250
하지만 당신은 더 이상 실행을 작성하는 경우
종료되지 않는 프로그램,

45
00:02:05,250 --> 00:02:09,180
반드시 분의 몇
초 부부라면, 메모리 누수

46
00:02:09,180 --> 00:02:10,710
큰 거래 될 수 있습니다.

47
00:02:10,710 --> 00:02:14,940
>> 그래서 pset6에, 기대는 것입니다
당신은 영 (0)으로 메모리 누수를해야합니다

48
00:02:14,940 --> 00:02:15,910
프로그램.

49
00:02:15,910 --> 00:02:18,690
메모리 누수를 확인하기 위해, 실행 Valgrind의
그것은 당신에게 좋은 줄 것이다

50
00:02:18,690 --> 00:02:21,190
출력 당신이 있는지 여부를 알려주는
또는 모든 무료 아니었다.

51
00:02:21,190 --> 00:02:23,940
우리는 나중에 연습합니다
오늘, 희망.

52
00:02:23,940 --> 00:02:25,790
>> 마지막으로, diff 명령.

53
00:02:25,790 --> 00:02:28,900
당신은 유사한 것을 사용
들여다 도구 pset5에.

54
00:02:28,900 --> 00:02:30,780
당신이 안쪽으로 볼 수있었습니다.

55
00:02:30,780 --> 00:02:33,400
또한 당,도 비교를 사용
문제는 사양을 설정합니다.

56
00:02:33,400 --> 00:02:35,950
하지만 당신은 할 수
두 개의 파일을 비교합니다.

57
00:02:35,950 --> 00:02:39,180
당신은 비트 맵 파일과 비교할 수
정보 직원 솔루션의 헤더와

58
00:02:39,180 --> 00:02:42,200
pset5에서 솔루션의 경우
당신이 그것을 사용하기로 결정했습니다.

59
00:02:42,200 --> 00:02:44,030
비교는 할 수
뿐만 아니라, 그렇게.

60
00:02:44,030 --> 00:02:48,620
당신에 대한 올바른 답을 비교할 수 있습니다
답변으로 설정 이번 주 문제

61
00:02:48,620 --> 00:02:52,210
그리고 볼 경우 최대 선 또는 참조
오류가있는 곳.

62
00:02:52,210 --> 00:02:55,870
>> 그래서 그 세 가지 좋은 도구입니다 그
당신이 일주일 동안 사용하고한다

63
00:02:55,870 --> 00:02:58,130
확실히 프로그램을 확인
이 세 가지 도구

64
00:02:58,130 --> 00:03:00,520
그것은 안으로 켜기 전에

65
00:03:00,520 --> 00:03:04,650
또, 매주 언급 한대로,
모두 - 만약 당신이 나를 위해 어떤 의견이 있으면

66
00:03:04,650 --> 00:03:06,470
긍정적이고 건설적인 -

67
00:03:06,470 --> 00:03:09,930
웹 사이트에 머리 주시기 바랍니다
이 슬라이드의 하단에

68
00:03:09,930 --> 00:03:11,270
거기에 그것을 입력.

69
00:03:11,270 --> 00:03:13,440
난 정말 감사
모든 의견.

70
00:03:13,440 --> 00:03:17,360
그리고 당신은 나에게 특정 물건을주는 경우에 그
내가 걸 개선 할 또는 수

71
00:03:17,360 --> 00:03:21,350
당신이 나를 좋아한다고 잘
내가 마음에 그것을 가지고 계속

72
00:03:21,350 --> 00:03:24,040
정말 듣고 열심히 노력
당신의 의견에.

73
00:03:24,040 --> 00:03:27,720
나는 내가 할거야 약속 할 수 없다
모든하지만, 착용 등

74
00:03:27,720 --> 00:03:30,700
매주 의상 호박.

75
00:03:30,700 --> 00:03:34,020
>> 그래서 우리는 대량의 지출 예정
부분은 내가 언급 한 바와 같이, 이야기

76
00:03:34,020 --> 00:03:37,240
링크 된 목록 및 해시 테이블, 어떤
에 직접 적용 할 수있을 것입니다

77
00:03:37,240 --> 00:03:38,780
문제는 이번 주에 설정합니다.

78
00:03:38,780 --> 00:03:42,580
링크 된 목록은 우리가 상대적으로 갈거야
우리는 공정한 조금을 썼다 신속하게하기 때문에

79
00:03:42,580 --> 00:03:44,930
시간의 부분에서 연습 해.

80
00:03:44,930 --> 00:03:48,680
그래서 우리는 바로 들어갈 수 있습니다
링크 된 목록에 대한 문제를 코딩.

81
00:03:48,680 --> 00:03:52,740
그리고 마지막에 우리가 얘기하자
그들이에 어떻게 적용되는지에 테이블을 해시하고

82
00:03:52,740 --> 00:03:55,280
주 문제는 설정.

83
00:03:55,280 --> 00:03:57,560
>> 당신은 이전에이 코드를 본 적이있다.

84
00:03:57,560 --> 00:04:02,730
이것은 구조체이며 정의된다
뭔가 새로운 노드라고합니다.

85
00:04:02,730 --> 00:04:10,660
그리고 노드 안에 정수가있다
바로 여기에 대한 포인터가있다

86
00:04:10,660 --> 00:04:11,830
다른 노드.

87
00:04:11,830 --> 00:04:12,790
우리는 전에 본 적이.

88
00:04:12,790 --> 00:04:14,830
이에오고있다
이제 몇 주.

89
00:04:14,830 --> 00:04:18,680
우리가했던 포인터를 결합한
허용하고, 구조체, 작업

90
00:04:18,680 --> 00:04:22,079
우리는 두 가지를 결합 할
하나의 데이터 타입으로 가지.

91
00:04:22,079 --> 00:04:24,830

92
00:04:24,830 --> 00:04:26,490
>> 화면에 무슨 일이 많이있다.

93
00:04:26,490 --> 00:04:30,220
그러나 모두가 상대적으로해야한다
당신을 잘 알고.

94
00:04:30,220 --> 00:04:33,810
첫 번째 줄에, 우리
새 노드를 선언합니다.

95
00:04:33,810 --> 00:04:41,650
그리고 그 새로운 노드 안에, 내가 설정
하나에 해당 노드의 정수입니다.

96
00:04:41,650 --> 00:04:44,950
우리는 내가 일을 해요 다음 줄에 참조
printf의 명령 만이 회색으로 표시했습니다

97
00:04:44,950 --> 00:04:48,080
printf의 명령 정말 때문에
중요한 부분은 여기 라인 -

98
00:04:48,080 --> 00:04:50,020
new_node.n.

99
00:04:50,020 --> 00:04:51,270
점은 무엇을 의미 하는가?

100
00:04:51,270 --> 00:04:53,810

101
00:04:53,810 --> 00:04:57,240
>> 청중 : 노드로 이동
그것을위한 N 값을 평가합니다.

102
00:04:57,240 --> 00:04:58,370
>> 제이슨 허쉬 호른 : 때문입니다
정확히 맞아.

103
00:04:58,370 --> 00:05:03,300
점은 N 부분에게 접근을 의미
이 새로운 노드의.

104
00:05:03,300 --> 00:05:05,690
이 다음 라인은 무엇입니까?

105
00:05:05,690 --> 00:05:16,140

106
00:05:16,140 --> 00:05:17,050
마이클.

107
00:05:17,050 --> 00:05:21,910
>> 청중 : 그것은 다른 노드를 생성
즉, 새로운 노드를 가리 킵니다.

108
00:05:21,910 --> 00:05:24,870
>> 제이슨 허쉬 호른 : 그래서하지 않습니다
새 노드를 만들 수 있습니다.

109
00:05:24,870 --> 00:05:26,120
그것은 무엇을 만들어?

110
00:05:26,120 --> 00:05:28,300

111
00:05:28,300 --> 00:05:29,300
>> 청중 : 포인터.

112
00:05:29,300 --> 00:05:33,460
>> 제이슨 허쉬 호른 : 노드에 대한 포인터,
여기 노드 *로 표시된 바와 같이.

113
00:05:33,460 --> 00:05:34,800
그래서 노드에 대한 포인터를 만듭니다.

114
00:05:34,800 --> 00:05:37,490
어느 노드가 가리키는
마이클에?

115
00:05:37,490 --> 00:05:38,440
>> 청중 : 새로운 노드?

116
00:05:38,440 --> 00:05:39,240
>> 제이슨 허쉬 호른 : 새로운 노드.

117
00:05:39,240 --> 00:05:43,020
우리가했습니다 때문에 그리고이 가리키는 것
그것을 새로운 노드의 주소를 부여.

118
00:05:43,020 --> 00:05:45,820
그리고 지금이 줄을 우리는 볼 수
의 두 가지 방법

119
00:05:45,820 --> 00:05:46,910
같은 일을 표현.

120
00:05:46,910 --> 00:05:49,650
그리고 지적하고 싶었 방법이
두 가지가 동일합니다.

121
00:05:49,650 --> 00:05:54,740
첫 번째 줄에서, 우리는 역 참조
포인터.

122
00:05:54,740 --> 00:05:55,830
그래서 우리는 노드로 이동합니다.

123
00:05:55,830 --> 00:05:56,830
즉,이 별 의미합니다.

124
00:05:56,830 --> 00:05:57,930
우리는 포인터를하기 전에 봤어요.

125
00:05:57,930 --> 00:05:59,280
해당 노드로 이동합니다.

126
00:05:59,280 --> 00:06:00,370
즉, 괄호 안에 있습니다.

127
00:06:00,370 --> 00:06:04,610
그리고 도트 연산자를 통해 액세스
그 노드의 N 소자.

128
00:06:04,610 --> 00:06:08,430
>> 그래서 구문을 복용
우리는 바로 여기 지금 보았다

129
00:06:08,430 --> 00:06:09,670
포인터로 사용.

130
00:06:09,670 --> 00:06:13,730
물론,이 경우 통화의 종류를 가져옵니다
당신은 그 괄호를 작성하는 -

131
00:06:13,730 --> 00:06:14,940
그 스타와 그 점.

132
00:06:14,940 --> 00:06:16,220
조금 바쁜 가져옵니다.

133
00:06:16,220 --> 00:06:18,500
그래서 우리는 몇 가지 문법 설탕이있다.

134
00:06:18,500 --> 00:06:19,920
그리고 여기이 선 -

135
00:06:19,920 --> 00:06:21,170
ptr_node -> N.

136
00:06:21,170 --> 00:06:25,400

137
00:06:25,400 --> 00:06:28,000
즉, 똑같은 일을한다.

138
00:06:28,000 --> 00:06:30,840
그래서이 두 줄의 코드는
동등 할 것

139
00:06:30,840 --> 00:06:31,650
정확히 똑같은 일.

140
00:06:31,650 --> 00:06:34,210
>> 하지만 전에 이러한 지적하고 싶었
우리는, 당신은 이해할 더 진행

141
00:06:34,210 --> 00:06:39,000
정말 바로 여기에이 일이 있음
역 참조에 대한 그냥 문법 설탕

142
00:06:39,000 --> 00:06:44,200
포인터 다음에가는
그 구조체의 해당 부분입니다.

143
00:06:44,200 --> 00:06:45,525
이 슬라이드에 대한 질문?

144
00:06:45,525 --> 00:06:53,020

145
00:06:53,020 --> 00:06:54,390
OK.

146
00:06:54,390 --> 00:06:58,510
>> 그래서 우리는 몇 가지를 통해 갈거야
당신이에 할 수있는 작업

147
00:06:58,510 --> 00:06:59,730
연결리스트.

148
00:06:59,730 --> 00:07:05,770
연결리스트, 리콜, 시리즈의입니다
서로를 가리 노드.

149
00:07:05,770 --> 00:07:12,470
그리고 우리는 일반적으로 포인터로 시작
라는 헤드는, 일반적으로, 그 가리키는

150
00:07:12,470 --> 00:07:14,040
목록의 첫 번째 일.

151
00:07:14,040 --> 00:07:18,900
여기에서 첫 번째 줄에 우리
먼저 우리의 원래의 L가 있습니다.

152
00:07:18,900 --> 00:07:21,370
그래서 그 것은 당신이 생각할 수있는 -이
바로 여기에 텍스트 당신은 생각할 수

153
00:07:21,370 --> 00:07:23,560
우리가 저장 한 단지 포인터
어딘가 점

154
00:07:23,560 --> 00:07:24,670
첫 번째 요소.

155
00:07:24,670 --> 00:07:27,500
그리고이 연결리스트에서
우리는 네 개의 노드가 있습니다.

156
00:07:27,500 --> 00:07:29,530
각 노드는 큰 상자입니다.

157
00:07:29,530 --> 00:07:33,430
큰 내부의 큰 상자
상자에는 정수 부분입니다.

158
00:07:33,430 --> 00:07:37,400
그리고 우리는 포인터 부분이 있습니다.

159
00:07:37,400 --> 00:07:39,630
>> 이 상자는 그려져 있지 않습니다
얼마나 큰 규모 때문에

160
00:07:39,630 --> 00:07:42,320
바이트의 정수?

161
00:07:42,320 --> 00:07:43,290
얼마나 큰 지금은?

162
00:07:43,290 --> 00:07:43,710
네.

163
00:07:43,710 --> 00:07:45,470
그리고 포인터가 얼마나 큰입니까?

164
00:07:45,470 --> 00:07:45,940
네.

165
00:07:45,940 --> 00:07:48,180
그래서 정말, 우리가 그릴 수 있다면
이 두 상자를 확장 할 수

166
00:07:48,180 --> 00:07:49,690
같은 크기 일 것입니다.

167
00:07:49,690 --> 00:07:52,870
이 경우, 우리는 삽입 할
링크 된 목록에 뭔가.

168
00:07:52,870 --> 00:07:57,190
그래서 당신은 우리가 삽입하고 여기에 아래로 볼 수 있습니다
다섯 우리는 순회

169
00:07:57,190 --> 00:08:01,310
연결리스트, 찾을 곳을 다섯
이동 한 다음 삽입합니다.

170
00:08:01,310 --> 00:08:03,560
>> 의 그 아래로 휴식과 가자
조금 더 천천히.

171
00:08:03,560 --> 00:08:05,510
나는 보드를 가리 키도록하겠습니다.

172
00:08:05,510 --> 00:08:09,930
그래서 우리는 우리의 노드가 다섯이
우리는 mallocs에서 만들었습니다.

173
00:08:09,930 --> 00:08:11,190
왜 모두 웃 고있다?

174
00:08:11,190 --> 00:08:12,130
농담.

175
00:08:12,130 --> 00:08:13,310
OK.

176
00:08:13,310 --> 00:08:14,820
그래서 우리는 다섯 malloc으로 할당했습니다.

177
00:08:14,820 --> 00:08:16,310
우리는이 노드를 생성 한
다른 곳.

178
00:08:16,310 --> 00:08:17,740
우리는 갈은 준비해야합니다.

179
00:08:17,740 --> 00:08:20,130
우리는 전면의 시작
두 우리의 목록입니다.

180
00:08:20,130 --> 00:08:22,380
그리고 우리는 삽입 할
정렬 방식.

181
00:08:22,380 --> 00:08:27,550
>> 그래서 우리는 두 가지를보고 우리가 사용하고 싶은 경우에 사용하면된다
우리가 볼 때 다섯, 우리는 무엇을해야합니까

182
00:08:27,550 --> 00:08:28,800
우리보다 뭔가?

183
00:08:28,800 --> 00:08:31,850

184
00:08:31,850 --> 00:08:33,520
무엇?

185
00:08:33,520 --> 00:08:36,750
우리는 이것으로 다섯을 삽입 할
연결리스트, 그것을 정렬 유지.

186
00:08:36,750 --> 00:08:37,520
우리는 두 번째를 참조하십시오.

187
00:08:37,520 --> 00:08:38,769
그래서 우리는 무엇을해야합니까?

188
00:08:38,769 --> 00:08:39,179
마커스?

189
00:08:39,179 --> 00:08:40,679
>> 청중 : 포인터를 호출
다음 노드로.

190
00:08:40,679 --> 00:08:42,530
>> 제이슨 허쉬 호른 : 왜 할
우리는 다음 단계로 이동?

191
00:08:42,530 --> 00:08:45,970
>> 청중 : 그것은이기 때문에
목록의 다음 노드.

192
00:08:45,970 --> 00:08:48,310
그리고 우리는 다른 위치를 알고있다.

193
00:08:48,310 --> 00:08:50,410
>> 제이슨 허쉬 호른 : 그리고 5는 큰
2 개 이상, 특히.

194
00:08:50,410 --> 00:08:51,600
우리는 정렬을 유지하려는 때문에.

195
00:08:51,600 --> 00:08:52,730
그래서 다섯 개의보다 크다.

196
00:08:52,730 --> 00:08:54,460
그래서 우리는 다음 단계로 이동합니다.

197
00:08:54,460 --> 00:08:55,240
그리고 지금 우리는 네 가지에 도달합니다.

198
00:08:55,240 --> 00:08:56,490
우리가 네 가지에 도달했을 때 어떤 일이 일어나는가?

199
00:08:56,490 --> 00:08:58,920

200
00:08:58,920 --> 00:09:00,310
>> 파이브 사보다 크다.

201
00:09:00,310 --> 00:09:01,460
그래서 우리는 계속.

202
00:09:01,460 --> 00:09:03,110
그리고 지금 우리는 6시입니다.

203
00:09:03,110 --> 00:09:04,360
그리고 우리는 6시에 무엇을 볼 수 있습니까?

204
00:09:04,360 --> 00:09:08,672

205
00:09:08,672 --> 00:09:09,608
예, 카를로스?

206
00:09:09,608 --> 00:09:10,544
>> 청중 : 6 다섯보다 크다.

207
00:09:10,544 --> 00:09:11,480
>> 제이슨 허쉬 호른 : 6입니다
오보다.

208
00:09:11,480 --> 00:09:13,660
우리가 원하는 곳 그래서의
다섯을 삽입합니다.

209
00:09:13,660 --> 00:09:17,320
그러나 염두에 두어야하는 경우 우리
단지 여기에 포인터를 가지고 -

210
00:09:17,320 --> 00:09:19,840
이것은 우리의 여분의 포인터
목록을 통과.

211
00:09:19,840 --> 00:09:21,860
우린 6을 가리키는입니다.

212
00:09:21,860 --> 00:09:25,010
우리는 무엇을 추적을 잃었습니다
여섯 전에 온다.

213
00:09:25,010 --> 00:09:29,130
그래서 우리는에 무언가를 삽입 할 경우
그것을 유지하는이 목록은 분류 우리

214
00:09:29,130 --> 00:09:31,630
아마 얼마나 많은 포인터를 필요로 하는가?

215
00:09:31,630 --> 00:09:32,280
>> 대상 : 두 가지.

216
00:09:32,280 --> 00:09:32,920
>> 제이슨 HIRSCHORN : 두.

217
00:09:32,920 --> 00:09:35,720
하나는 현재의 추적 할
하나 하나의 트랙을 유지하는

218
00:09:35,720 --> 00:09:37,050
이전.

219
00:09:37,050 --> 00:09:38,450
이것은 단지 단일 연결 목록입니다.

220
00:09:38,450 --> 00:09:39,670
그것은 오직 하나의 방향으로 진행한다.

221
00:09:39,670 --> 00:09:43,220
우리는 이중 연결리스트를 가지고 있다면, 여기서
모든 것에 가리키고

222
00:09:43,220 --> 00:09:46,240
그것과 그 이전 일 다음 후
우리는 그렇게 할 필요가 없을 것입니다.

223
00:09:46,240 --> 00:09:49,350
그러나이 경우에 우리는 잃고 싶지 않아
경우에 우리 앞에 와서 무엇을 추적

224
00:09:49,350 --> 00:09:53,350
우리는 다섯 곳을 삽입해야
중간에.

225
00:09:53,350 --> 00:09:55,610
우리가 구를 삽입했다고 말했습니다.

226
00:09:55,610 --> 00:09:57,260
때 무슨 일이 일어날 지
우리는 여덟있어?

227
00:09:57,260 --> 00:10:01,860

228
00:10:01,860 --> 00:10:04,880
>> 청중 : 당신은해야 할 것
그 널 포인트를 얻을.

229
00:10:04,880 --> 00:10:07,820
NULL 대신 포인트를 갖는 당신은이 것
요소를 추가 한 다음이 수

230
00:10:07,820 --> 00:10:09,216
그것은 구를 가리 킵니다.

231
00:10:09,216 --> 00:10:09,700
>> 제이슨 HIRSCHORN : 그렇지.

232
00:10:09,700 --> 00:10:10,600
그래서 우리는 팔을.

233
00:10:10,600 --> 00:10:13,140
우리는 목록의 끝에 도달하기 때문에
이 null로 가리키고 있습니다.

234
00:10:13,140 --> 00:10:16,330
그리고 지금, 대신 갖는 그것은을 가리
널 (null) 우리는 우리의 새로운 노드를 가리있다.

235
00:10:16,330 --> 00:10:19,870
그리고 우리의 포인터를 설정
null로 새로운 노드.

236
00:10:19,870 --> 00:10:21,445
아무도 질문이 있습니까
삽입하는 방법에 대한?

237
00:10:21,445 --> 00:10:25,620

238
00:10:25,620 --> 00:10:28,100
무엇 대해 상관하지 않는 경우
정렬 된 목록을 유지?

239
00:10:28,100 --> 00:10:31,701

240
00:10:31,701 --> 00:10:34,350
>> 청중 :에 그것을 찌르
시작 또는 끝.

241
00:10:34,350 --> 00:10:35,510
>> 제이슨 HIRSCHORN :에 그것을 찌르
시작 또는 끝.

242
00:10:35,510 --> 00:10:37,276
어느 우리는 어떻게해야합니까?

243
00:10:37,276 --> 00:10:38,770
바비?

244
00:10:38,770 --> 00:10:41,020
왜 말?

245
00:10:41,020 --> 00:10:43,250
>> 청중 : 때문에 시작
이미 가득 차 있습니다.

246
00:10:43,250 --> 00:10:43,575
>> 제이슨 HIRSCHORN : OK.

247
00:10:43,575 --> 00:10:44,360
시작은 이미 가득 차 있습니다.

248
00:10:44,360 --> 00:10:46,090
누가 바비에 대해 주장하려고합니다.

249
00:10:46,090 --> 00:10:47,290
마커스.

250
00:10:47,290 --> 00:10:48,910
>> 청중 : 그럼 당신은 아마 원하는
처음에 붙어 있기 때문에

251
00:10:48,910 --> 00:10:50,140
당신은에 넣어 그렇지 않으면 경우
당신이해야 할 거라고 말

252
00:10:50,140 --> 00:10:51,835
전체 목록을 통과.

253
00:10:51,835 --> 00:10:52,990
>> 제이슨 HIRSCHORN : 그렇지.

254
00:10:52,990 --> 00:10:57,970
우리는 런타임에 대해 생각하고이 경우,
끝에 삽입 런타임

255
00:10:57,970 --> 00:11:00,110
N 것, 이것의 크기입니다.

256
00:11:00,110 --> 00:11:03,080
삽입의 큰 O 런타임은 무엇입니까
처음에?

257
00:11:03,080 --> 00:11:04,170
일정 시간.

258
00:11:04,170 --> 00:11:07,075
그래서 당신은 유지에 대해 걱정하지 않는 경우
뭔가, 그냥 훨씬 더 정렬

259
00:11:07,075 --> 00:11:08,420
이 목록의 시작 부분에 삽입합니다.

260
00:11:08,420 --> 00:11:10,320
그리고 일정한 시간에 수행 할 수 있습니다.

261
00:11:10,320 --> 00:11:13,900

262
00:11:13,900 --> 00:11:14,690
>> OK.

263
00:11:14,690 --> 00:11:18,870
다음 작업을 찾을 수있는 다른합니다 -
우리는 검색으로 이것을 표현한 것.

264
00:11:18,870 --> 00:11:22,470
그러나 우리는을 통해 보는거야
일부 개체의 연결리스트.

265
00:11:22,470 --> 00:11:26,000
너희들에 대한 코드를 볼 수있다
강의 전에 검색 할 수 있습니다.

266
00:11:26,000 --> 00:11:29,490
그러나 우리는 종류의 단지로했다
삽입, 또는 적어도 삽입

267
00:11:29,490 --> 00:11:30,580
뭔가를 정렬.

268
00:11:30,580 --> 00:11:36,350
당신은을 통해 보면, 노드에서 노드를 가고,
당신은 당신이하고있는 번호를 찾을 때까지

269
00:11:36,350 --> 00:11:37,780
찾고.

270
00:11:37,780 --> 00:11:39,670
당신이 도달하면 어떻게됩니까
리스트의 끝?

271
00:11:39,670 --> 00:11:43,020
나는 아홉 내가 찾고 있어요 말
목록의 끝에 도달한다.

272
00:11:43,020 --> 00:11:44,270
우리는 무엇을해야합니까?

273
00:11:44,270 --> 00:11:47,147

274
00:11:47,147 --> 00:11:48,110
>> 청중 :는 false?

275
00:11:48,110 --> 00:11:48,690
>> 제이슨 HIRSCHORN : false를 반환합니다.

276
00:11:48,690 --> 00:11:49,960
우리는 그것을 찾을 수 없습니다.

277
00:11:49,960 --> 00:11:52,010
당신은리스트의 끝에 도달하고 있으면
당신은 당신이하고있는 번호를 찾을 수 없습니다

278
00:11:52,010 --> 00:11:54,170
을 찾고, 그것은 거기 아니에요.

279
00:11:54,170 --> 00:11:55,420
에 대한 질문은 찾았나요?

280
00:11:55,420 --> 00:11:59,530

281
00:11:59,530 --> 00:12:04,615
이 정렬 된 목록 인 경우, 어떤 것
우리의 검색에 대해 다른 수?

282
00:12:04,615 --> 00:12:07,370

283
00:12:07,370 --> 00:12:08,103
그래.

284
00:12:08,103 --> 00:12:10,600
>> 청중 : 그것은 첫 번째 값을 찾아 낼 것입니다
즉, 1보다 큰의

285
00:12:10,600 --> 00:12:12,390
당신을 찾고있어
다음 false를 반환합니다.

286
00:12:12,390 --> 00:12:13,190
>> 제이슨 HIRSCHORN : 그렇지.

287
00:12:13,190 --> 00:12:17,310
따라서 정렬 된 목록의 경우, 우리는 얻을 경우
무엇보다 더 큰 무언가

288
00:12:17,310 --> 00:12:20,180
우리가 찾고있는, 우리가 할 필요가 없습니다
목록의 마지막에 계속.

289
00:12:20,180 --> 00:12:24,060
우리는 그 시점에서 false를 반환 할 수 있습니다
우리는 그것을 발견하지 않을거야 때문이다.

290
00:12:24,060 --> 00:12:27,340
문제는 지금 우리가 이야기했습니다된다
정렬 된 연결리스트를 유지하는 것은,

291
00:12:27,340 --> 00:12:28,180
정렬되지 않은 그들을 유지.

292
00:12:28,180 --> 00:12:30,050
그게 당신이있어 뭔가 될 것
아마 생각해야 할 것

293
00:12:30,050 --> 00:12:34,240
당신이 경우 코딩 문제는 다섯을 설정할 때
별도의와 해시 테이블을 선택

294
00:12:34,240 --> 00:12:36,360
체인 접근하는
우리는 이상에 대해 이야기 할 것입니다.

295
00:12:36,360 --> 00:12:41,400
>> 그러나 목록을 유지하는 가치가있다
다음 정렬 및 아마 가질 수

296
00:12:41,400 --> 00:12:42,310
빠른 검색?

297
00:12:42,310 --> 00:12:47,220
아니면 신속하게 삽입하는 것이 좋습니다
다음 일정 런타임에 뭔가 있지만,

298
00:12:47,220 --> 00:12:48,430
검색 이상이?

299
00:12:48,430 --> 00:12:52,250
즉, 바로 거기에 트레이드 오프의 당신에게 그
더 적절한 결정을 얻을

300
00:12:52,250 --> 00:12:53,590
특정 문제에 대한.

301
00:12:53,590 --> 00:12:56,680
그리고 반드시 하나가 아니다
절대적으로 정답.

302
00:12:56,680 --> 00:12:59,520
그러나 그것은 확실히 당신이 얻을 결정의
확인하고, 아마 좋은 방어

303
00:12:59,520 --> 00:13:05,270
점에서, 말, 코멘트 나 두 이유
당신은 다른 통해 하나를 선택했다.

304
00:13:05,270 --> 00:13:06,490
>> 마지막으로, 삭제.

305
00:13:06,490 --> 00:13:08,100
우리는 삭제 봤어요.

306
00:13:08,100 --> 00:13:09,180
그것은 검색과 유사합니다.

307
00:13:09,180 --> 00:13:11,020
우리는 요소를 찾습니다.

308
00:13:11,020 --> 00:13:12,390
우리는 6을 삭제하려고한다고 가정 해 봅시다.

309
00:13:12,390 --> 00:13:14,450
그래서 우리는 여기 여섯을 찾을 수 있습니다.

310
00:13:14,450 --> 00:13:18,860
우리는 확실히 우리 만들어야 할 것
할 것은 모두가 가리키는 것입니다

311
00:13:18,860 --> 00:13:21,220
여섯 - 우리는 단계에서 볼 수 있듯이
여기 아래 두 -

312
00:13:21,220 --> 00:13:26,500
여섯 요구를 가리키는 뭐든간에
지금 여섯을 건너로 변경

313
00:13:26,500 --> 00:13:28,160
무엇이든 여섯 가리키는.

314
00:13:28,160 --> 00:13:31,410
우리는 지금까지 나머지를 고아로하지 않는다
그 설정 잊고으로 우리의 목록

315
00:13:31,410 --> 00:13:32,960
이전 포인터.

316
00:13:32,960 --> 00:13:35,960
그리고 때때로, 따라
프로그램을, 그들은 단지거야

317
00:13:35,960 --> 00:13:37,380
완전히이 노드를 삭제합니다.

318
00:13:37,380 --> 00:13:40,135
때때로 당신은 반환 할 수 있습니다
이 노드의 값입니다.

319
00:13:40,135 --> 00:13:42,490
그래서 작품을 삭제하는 방법입니다.

320
00:13:42,490 --> 00:13:44,610
에 대한 질문은 삭제 하시겠습니까?

321
00:13:44,610 --> 00:13:51,280

322
00:13:51,280 --> 00:13:53,850
>> 청중 : 그래서 당신은 삭제하려고하는 경우
그것은, 당신은 무료로 사용하는 것이 때문에

323
00:13:53,850 --> 00:13:55,655
아마도 그것은 malloc으로 할당 된?

324
00:13:55,655 --> 00:13:57,976
>> 제이슨 HIRSCHORN : 당신은 무료로 할 경우
정확히 바로 당신 뭔가

325
00:13:57,976 --> 00:13:58,540
그것을 malloc으로 할당.

326
00:13:58,540 --> 00:14:00,410
우리는이 값을 반환한다고 가정 해 보자.

327
00:14:00,410 --> 00:14:04,010
우리는 반환 할 수 있습니다 여섯 다음 무료
그것에이 노드와 전화 무료.

328
00:14:04,010 --> 00:14:06,180
아니면 우리는 아마 최초의 무료 전화 것
다음 여섯을 반환합니다.

329
00:14:06,180 --> 00:14:11,210

330
00:14:11,210 --> 00:14:11,580
>> OK.

331
00:14:11,580 --> 00:14:14,010
그래서 코딩 연습을 이동하자.

332
00:14:14,010 --> 00:14:16,090
우리는 세 가지 기능을 코딩하는 것입니다.

333
00:14:16,090 --> 00:14:18,260
첫 번째는 insert_node이라고합니다.

334
00:14:18,260 --> 00:14:22,170
그래서 당신은 내가 당신을 이메일로 코드를 가지고 있고,
당신은 나중에이를보고하는 경우

335
00:14:22,170 --> 00:14:28,020
당신 linked.c에서 코드에 액세스 할
CS50 웹 사이트에서 찾아 볼 수 있습니다.

336
00:14:28,020 --> 00:14:30,880
그러나 linked.c 일부있다
이미 골격 코드

337
00:14:30,880 --> 00:14:32,280
당신을 위해 작성되었습니다.

338
00:14:32,280 --> 00:14:34,560
그리고 몇 가지 기능이 있어요
당신이 작성해야합니다.

339
00:14:34,560 --> 00:14:36,380
>> 처음에 우리가 갈거야
insert_node 물품.

340
00:14:36,380 --> 00:14:39,800
그리고 무엇 insert_node 않습니다
IS는 정수를 삽입합니다.

341
00:14:39,800 --> 00:14:42,440
그리고 당신은 정수에게주는거야
연결리스트로.

342
00:14:42,440 --> 00:14:45,470
특히, 당신이 필요합니다
정렬 된 목록을 유지하는

343
00:14:45,470 --> 00:14:47,650
최소에서 최대로.

344
00:14:47,650 --> 00:14:51,360
또한, 당신은하고 싶지 않아
중복을 삽입합니다.

345
00:14:51,360 --> 00:14:54,600
마지막으로, 당신은 insert_node을 볼 수
부울을 반환합니다.

346
00:14:54,600 --> 00:14:57,140
그래서 당신은 사용자에게 알려 야지
삽입되었는지 여부

347
00:14:57,140 --> 00:15:00,800
true 또는 false를 반환하여 성공.

348
00:15:00,800 --> 00:15:02,580
이 프로그램의 끝에서 -

349
00:15:02,580 --> 00:15:05,750
이 단계에 당신은 필요로하지 않는다
아무것도 해제에 대해 걱정할 필요.

350
00:15:05,750 --> 00:15:11,790
그래서 당신이하고있는 모든 정수를하고있다
그리고리스트에 삽입.

351
00:15:11,790 --> 00:15:13,890
>> 그게 내가 지금 할 당신을 부탁 해요 것입니다.

352
00:15:13,890 --> 00:15:17,620
다시, linked.c에, 어떤 당신
이 모두, 골격 코드입니다.

353
00:15:17,620 --> 00:15:20,980
그리고 당신은 바닥으로 볼 수
샘플 함수 선언.

354
00:15:20,980 --> 00:15:27,390
그러나, 코딩에 가기 전에
C에서, 내가보기 엔 이동하는 것이 좋습니다

355
00:15:27,390 --> 00:15:29,330
단계를 통해 우리는 봤는데
매주 연습.

356
00:15:29,330 --> 00:15:31,100
우리는 이미 겪었어요
이의 사진.

357
00:15:31,100 --> 00:15:33,380
그래서 당신은 몇 가지 이해가 있어야
이 작업을 수행하는 방법의.

358
00:15:33,380 --> 00:15:36,590
하지만 작성하는 것이 좋습니다 것
수정 전에 일부 의사

359
00:15:36,590 --> 00:15:38,640
그리고 우리는 가서거야
그룹으로 의사.

360
00:15:38,640 --> 00:15:41,470
그리고 당신이 작성한 번
의사, 우리가 작성한 한 번 우리의

361
00:15:41,470 --> 00:15:45,850
그룹으로 의사, 당신은 할 수
C.에 코딩로 이동

362
00:15:45,850 --> 00:15:49,980
>> 헤드 업, insert_node 함수
아마의 까다로운입니다

363
00:15:49,980 --> 00:15:53,550
세 우리가 쓰는거야 때문에
에 몇 가지 추가 제약 조건을 추가

364
00:15:53,550 --> 00:15:57,190
프로그래밍, 특히 그
당신은 어떤 삽입하지 않을거야

365
00:15:57,190 --> 00:15:59,880
중복 및 그 목록
정렬을 유지해야한다.

366
00:15:59,880 --> 00:16:02,660
그래서 이것은 비 단순 프로그램
당신이 코딩을 필요로 함을 의미합니다.

367
00:16:02,660 --> 00:16:06,470
그리고 당신은 왜 일곱에 다섯을지지 않습니다
분은 작업을 얻을 수 있습니다

368
00:16:06,470 --> 00:16:07,640
의사와 코드입니다.

369
00:16:07,640 --> 00:16:09,460
그리고 우리가 시작됩니다
그룹으로가는.

370
00:16:09,460 --> 00:16:11,680
다시 말하지만, 당신은 질문이있는 경우
손을 들어 내가 돌아올거야.

371
00:16:11,680 --> 00:16:15,258

372
00:16:15,258 --> 00:16:16,508
.

373
00:16:16,508 --> 00:18:28,370

374
00:18:28,370 --> 00:18:30,120
>> 우리는 또한 일반적으로 이러한 작업을 수행 -

375
00:18:30,120 --> 00:18:32,070
아니면 명시 적으로 당신에게 말을하지 않습니다
사람들과 함께 작업 할 수 있습니다.

376
00:18:32,070 --> 00:18:36,500
하지만 분명히, 내가보기 엔 당신을 격려,
당신은 질문이있는 경우에는, 부탁합니다

377
00:18:36,500 --> 00:18:39,840
당신 옆에 앉아 이웃
또는 누군가와 함께 작동

378
00:18:39,840 --> 00:18:40,510
다른 당신이 원한다면.

379
00:18:40,510 --> 00:18:42,600
이 개인 일 필요는 없습니다
침묵하는 활동.

380
00:18:42,600 --> 00:20:11,770

381
00:20:11,770 --> 00:20:16,330
>> 의 일부를 쓰기 시작하자
보드에 의사.

382
00:20:16,330 --> 00:20:19,395
누가 나에게의 첫 번째 라인을 제공 할 수 있습니다
이 프로그램의 의사?

383
00:20:19,395 --> 00:20:22,240

384
00:20:22,240 --> 00:20:23,640
이 기능의 경우, 오히려 -
insert_node.

385
00:20:23,640 --> 00:20:29,960

386
00:20:29,960 --> 00:20:31,830
알덴?

387
00:20:31,830 --> 00:20:36,560
>> 청중 : 그래서 내가 한 첫 번째 일은이었다
노드와 I에 새로운 포인터를 만들

388
00:20:36,560 --> 00:20:41,320
그것은 동일한 가리키는 초기화
리스트가 가리키고있는 것.

389
00:20:41,320 --> 00:20:41,550
>> 제이슨 HIRSCHORN : OK.

390
00:20:41,550 --> 00:20:45,190
그래서 당신은 새로운 포인터를 만드는
목록이 아닌 노드에.

391
00:20:45,190 --> 00:20:45,420
>> 청중 : 네.

392
00:20:45,420 --> 00:20:46,150
그래.

393
00:20:46,150 --> 00:20:46,540
>> 제이슨 HIRSCHORN : OK.

394
00:20:46,540 --> 00:20:48,221
그리고 우리가 무엇을 할 수 있습니까?

395
00:20:48,221 --> 00:20:49,163
그 후 무엇입니까?

396
00:20:49,163 --> 00:20:50,105
어떤 노드에 대한?

397
00:20:50,105 --> 00:20:51,050
우리는 노드를 필요가 없습니다.

398
00:20:51,050 --> 00:20:52,300
우리는 단지 가치가있다.

399
00:20:52,300 --> 00:20:55,918

400
00:20:55,918 --> 00:20:58,890
우리는 노드를 삽입 할 경우, 어떤 일이 우리가 할
우리도 할 수 있습니다 전에 먼저해야 할

401
00:20:58,890 --> 00:20:59,980
를 삽입하는 방법에 대한 생각?

402
00:20:59,980 --> 00:21:00,820
>> 청중 : 아, 죄송합니다.

403
00:21:00,820 --> 00:21:02,160
우리는 노드에 대한 공간을 MALLOC해야합니다.

404
00:21:02,160 --> 00:21:02,455
>> 제이슨 HIRSCHORN : 좋음.

405
00:21:02,455 --> 00:21:03,210
의는하자 -

406
00:21:03,210 --> 00:21:04,628
OK.

407
00:21:04,628 --> 00:21:06,065
그 높은 도달 할 수 없습니다.

408
00:21:06,065 --> 00:21:08,939

409
00:21:08,939 --> 00:21:09,897
OK.

410
00:21:09,897 --> 00:21:13,236
우리는 아래로 갈 예정하고있어
우리는 두 개의 열을 사용하고 있습니다.

411
00:21:13,236 --> 00:21:13,732
나도 갈 수 없습니다 -

412
00:21:13,732 --> 00:21:14,982
OK.

413
00:21:14,982 --> 00:21:23,660

414
00:21:23,660 --> 00:21:25,130
새 노드를 만듭니다.

415
00:21:25,130 --> 00:21:29,380
당신은 목록에 다른 포인터를 만들 수 있습니다
존재 또는 당신은 목록을 사용할 수 있습니다.

416
00:21:29,380 --> 00:21:30,720
당신은 정말 그렇게 할 필요가 없습니다.

417
00:21:30,720 --> 00:21:31,750
>> 그래서 우리는 새로운 노드를 만들 수 있습니다.

418
00:21:31,750 --> 00:21:32,010
좋아요.

419
00:21:32,010 --> 00:21:32,840
즉, 우리가 처음하는 일이다.

420
00:21:32,840 --> 00:21:34,870
다음은?

421
00:21:34,870 --> 00:21:35,080
>> 청중 : 잠깐.

422
00:21:35,080 --> 00:21:38,330
우리는 지금 새로운 노드를 만들거나해야
우리가 있는지 확인하기 위해 대기해야

423
00:21:38,330 --> 00:21:42,260
노드의 중복이 없다
목록에 전에 우리는 그것을 만들?

424
00:21:42,260 --> 00:21:43,100
>> 제이슨 HIRSCHORN : 좋은 질문입니다.

425
00:21:43,100 --> 00:21:47,770
그 이야기는 나중에하기 때문에 위해 그것을 유지하자
우리가 만들 수 있습니다 시간의 대부분

426
00:21:47,770 --> 00:21:48,220
새 노드.

427
00:21:48,220 --> 00:21:49,110
그래서 우리는 여기에 그하겠습니다.

428
00:21:49,110 --> 00:21:51,006
그러나 그것은 좋은 질문입니다.

429
00:21:51,006 --> 00:21:53,250
우리는 그것을 만들고 우리가 발견하는 경우
중복, 무엇을해야

430
00:21:53,250 --> 00:21:54,490
우리는 반환하기 전에 무엇입니까?

431
00:21:54,490 --> 00:21:55,190
>> 청중 : 그것을 해방.

432
00:21:55,190 --> 00:21:55,470
>> 제이슨 HIRSCHORN : 네.

433
00:21:55,470 --> 00:21:56,500
아마 해방.

434
00:21:56,500 --> 00:21:56,760
OK.

435
00:21:56,760 --> 00:21:59,850
우리는 이후 우리는 무엇을해야합니까
새 노드를 생성?

436
00:21:59,850 --> 00:22:02,260
애니?

437
00:22:02,260 --> 00:22:04,780
>> 청중 : 우리는 둘
노드의 수?

438
00:22:04,780 --> 00:22:05,140
>> 제이슨 HIRSCHORN : 그렇지.

439
00:22:05,140 --> 00:22:07,190
우리는 번호를 넣어 - 우리는 공간을 MALLOC.

440
00:22:07,190 --> 00:22:08,160
나도 떠날거야
모두 한 줄로.

441
00:22:08,160 --> 00:22:08,720
하지만 당신 말이 맞아.

442
00:22:08,720 --> 00:22:10,305
우리는 그 공간을 MALLOC하고,
우리는 안으로 번호를 넣어

443
00:22:10,305 --> 00:22:12,585
우리는 심지어 포인터를 설정할 수 있습니다
null로의 일부.

444
00:22:12,585 --> 00:22:13,720
그게 바로 그렇습니다.

445
00:22:13,720 --> 00:22:17,400
그리고 무엇을 그 후 약?

446
00:22:17,400 --> 00:22:18,490
우리는 보드에이 사진을 끌었다.

447
00:22:18,490 --> 00:22:21,190
그래서 우리는 무엇을해야합니까?

448
00:22:21,190 --> 00:22:22,680
>> 청중 : 우리는 목록을 통해 이동합니다.

449
00:22:22,680 --> 00:22:23,930
>> 제이슨 HIRSCHORN : 목록을 통해 이동합니다.

450
00:22:23,930 --> 00:22:30,620

451
00:22:30,620 --> 00:22:31,100
OK.

452
00:22:31,100 --> 00:22:34,280
그리고 우리는 각 노드에서 무엇을 검사한다.

453
00:22:34,280 --> 00:22:35,955
커트, 우리는 무엇을 확인합니까
각 노드에 대한?

454
00:22:35,955 --> 00:22:41,640
>> 청중 :보기 N 값의 여부
그 노드는 N 값보다 큰

455
00:22:41,640 --> 00:22:43,070
우리의 노드.

456
00:22:43,070 --> 00:22:43,340
>> 제이슨 HIRSCHORN : OK.

457
00:22:43,340 --> 00:22:44,280
내가 할거야 -

458
00:22:44,280 --> 00:22:45,855
OK, 그래.

459
00:22:45,855 --> 00:22:48,160
따라서 N의 -

460
00:22:48,160 --> 00:22:59,040
나는 값이 큰 경우, 말거야
이 노드보다, 우리는 무엇을해야합니까?

461
00:22:59,040 --> 00:23:07,290
>> 청중 : 글쎄, 우리는 삽입
바로 그 전에 것.

462
00:23:07,290 --> 00:23:07,970
>> 제이슨 HIRSCHORN : OK.

463
00:23:07,970 --> 00:23:09,410
그래서이보다 큰 경우에,
우리는 삽입 할.

464
00:23:09,410 --> 00:23:14,010
그러나 우리는 바로 전을 삽입 할
또한 될 필요가 있기

465
00:23:14,010 --> 00:23:16,070
추적을 유지하고,
전에 무슨의.

466
00:23:16,070 --> 00:23:22,690
그래서 전에 삽입합니다.

467
00:23:22,690 --> 00:23:25,120
그래서 우리는 아마 뭔가를 놓친
이전에.

468
00:23:25,120 --> 00:23:27,770
우리는 아마 유지해야
무슨 일이 일어나고 있는지를 추적.

469
00:23:27,770 --> 00:23:28,460
그러나 우리가 다시 얻을 수 있습니다.

470
00:23:28,460 --> 00:23:30,160
그래서 값이보다 작?

471
00:23:30,160 --> 00:23:38,030

472
00:23:38,030 --> 00:23:39,710
커트, 우리는 경우 어떻게해야합니까
값보다 작?

473
00:23:39,710 --> 00:23:43,000
>> 청중 : 그럼 그냥 계속
그것은 마지막 하나가 아니라면.

474
00:23:43,000 --> 00:23:43,550
>> 제이슨 HIRSCHORN : 나는 좋아한다.

475
00:23:43,550 --> 00:23:44,800
그래서 다음 노드로 이동합니다.

476
00:23:44,800 --> 00:23:47,410

477
00:23:47,410 --> 00:23:48,930
그것은 마지막 하나를 제외 -

478
00:23:48,930 --> 00:23:51,100
우리는 아마 검사하고
조건의 측면에서.

479
00:23:51,100 --> 00:23:54,870
하지만 그래, 다음 노드.

480
00:23:54,870 --> 00:23:58,680
그리고는, 너무 낮은지고
그래서 우리는 여기에 이​​동합니다.

481
00:23:58,680 --> 00:24:02,030
그러나 만약에 -

482
00:24:02,030 --> 00:24:03,280
모든 사람이 볼 수 있습니까?

483
00:24:03,280 --> 00:24:07,230

484
00:24:07,230 --> 00:24:11,610
우리가 동일한 있다면 우리는 무엇을해야합니까?

485
00:24:11,610 --> 00:24:15,740
값은 우리가 삽입하려는 경우
이 노드의 값과 동일한?

486
00:24:15,740 --> 00:24:16,320
그래?

487
00:24:16,320 --> 00:24:18,400
>> 청중 : [청취].

488
00:24:18,400 --> 00:24:18,850
>> 제이슨 HIRSCHORN : 네.

489
00:24:18,850 --> 00:24:19,290
이 주어 -

490
00:24:19,290 --> 00:24:20,090
마커스 권리입니다.

491
00:24:20,090 --> 00:24:21,330
우리는 어쩌면 할 수 있었다
다른 무엇인가.

492
00:24:21,330 --> 00:24:25,360
그러나 여기, 우리가 만든 주어진
우리는 해방 후 반환해야합니다.

493
00:24:25,360 --> 00:24:26,774
소년 아.

494
00:24:26,774 --> 00:24:30,080
그것은 더 나은가요?

495
00:24:30,080 --> 00:24:31,850
어떻게 그런 일이있어?

496
00:24:31,850 --> 00:24:33,100
OK.

497
00:24:33,100 --> 00:24:35,360

498
00:24:35,360 --> 00:24:37,640
우리가하는 일 후 무료
[청취] 반환?

499
00:24:37,640 --> 00:24:41,330

500
00:24:41,330 --> 00:24:44,110
OK.

501
00:24:44,110 --> 00:24:45,360
우리는 무엇을 누락?

502
00:24:45,360 --> 00:24:53,500

503
00:24:53,500 --> 00:24:59,650
그래서 우리는 어디를 추적하는
이전 노드의?

504
00:24:59,650 --> 00:25:02,370
>> 청중 : 내가 갈 것이라고 생각
후 새 노드를 만들 수 있습니다.

505
00:25:02,370 --> 00:25:02,600
>> 제이슨 HIRSCHORN : OK.

506
00:25:02,600 --> 00:25:03,940
그래서 처음에 우리는 아마거야 -

507
00:25:03,940 --> 00:25:07,175
그래, 우리는 새로운 포인터를 만들 수 있습니다
이전 노드 포인터와 같은 노드 및

508
00:25:07,175 --> 00:25:09,600
현재 노드의 포인터.

509
00:25:09,600 --> 00:25:12,640
그럼 그 여기에 삽입 할 수 있습니다.

510
00:25:12,640 --> 00:25:15,610

511
00:25:15,610 --> 00:25:26,900
만들기 현재 및 이전
노드에 대한 포인터.

512
00:25:26,900 --> 00:25:28,955
그러나 때 우리가 그 포인터를 조정합니까?

513
00:25:28,955 --> 00:25:30,205
우리가 코드에서 어디에해야합니까?

514
00:25:30,205 --> 00:25:33,830

515
00:25:33,830 --> 00:25:34,160
제프?

516
00:25:34,160 --> 00:25:35,170
>> 대상 : - 값의 조건?

517
00:25:35,170 --> 00:25:36,420
>> 제이슨 HIRSCHORN : 어느
특히 하나?

518
00:25:36,420 --> 00:25:39,862

519
00:25:39,862 --> 00:25:40,720
>> 청중 : 난 그냥 혼동하고 있습니다.

520
00:25:40,720 --> 00:25:44,200
값이 노드보다 크면
그것은 당신이 가고 싶은 것을 의미하지 않는다

521
00:25:44,200 --> 00:25:45,320
다음 노드로?

522
00:25:45,320 --> 00:25:49,515
>> 제이슨 허쉬 호른 : 그래서 우리의 값이면
이 노드의 값보다 큰.

523
00:25:49,515 --> 00:25:52,130
>> 청중 : 그래, 당신이 원하는 것
오른쪽 선 아래로 더 이상 갈?

524
00:25:52,130 --> 00:25:52,590
>> 제이슨 허쉬 호른 : 오른쪽.

525
00:25:52,590 --> 00:25:53,840
그래서 우리는 여기에 삽입하지 않습니다.

526
00:25:53,840 --> 00:25:58,430

527
00:25:58,430 --> 00:26:03,240
값은 현재 노드보다 작 으면
우리는 다음 노드로 이동 - 다음 또는 우리

528
00:26:03,240 --> 00:26:03,835
전에 삽입합니다.

529
00:26:03,835 --> 00:26:05,966
>> 청중이되는, 대기
노드와 어떤 가치인가?

530
00:26:05,966 --> 00:26:08,510

531
00:26:08,510 --> 00:26:09,280
>> 제이슨 허쉬 호른 : 좋은 질문입니다.

532
00:26:09,280 --> 00:26:13,260
값이 함수의 정의에 따라
우리가 제공하는 것입니다.

533
00:26:13,260 --> 00:26:16,910
그래서 값이 우리가 제공하고있는 번호입니다.

534
00:26:16,910 --> 00:26:21,120
그래서 값이보다 작은 경우
노드는, 우리는 삽입하는 시간이 필요합니다.

535
00:26:21,120 --> 00:26:24,575
값이 노드보다 크면
우리는 다음 노드로 이동합니다.

536
00:26:24,575 --> 00:26:26,790
다시 원래의 질문에,
하지만, 어디 -

537
00:26:26,790 --> 00:26:29,060
>> 청중 : 값이 큰 경우
이 노드보다.

538
00:26:29,060 --> 00:26:30,310
>> 제이슨 허쉬 호른 : 그래서
우리는 여기에서 무엇을해야합니까?

539
00:26:30,310 --> 00:26:36,790

540
00:26:36,790 --> 00:26:38,160
달콤한.

541
00:26:38,160 --> 00:26:38,860
즉 올바른 것입니다.

542
00:26:38,860 --> 00:26:41,370
난 그냥 쓰는거야
업데이트 포인터.

543
00:26:41,370 --> 00:26:44,010
그러나 네, 현재 하나
당신은으로 업데이트 할

544
00:26:44,010 --> 00:26:46,080
다음 중 하나를 가리 킵니다.

545
00:26:46,080 --> 00:26:47,330
다른 건 우리가 누락 되었습니까?

546
00:26:47,330 --> 00:26:52,710

547
00:26:52,710 --> 00:26:54,940
그래서 나는이를 입력 할거야
의 gedit에 코드.

548
00:26:54,940 --> 00:26:58,375
나는이 작업을 수행하는 동안, 당신은있을 수 있습니다
코딩 작업에 몇 분 이상

549
00:26:58,375 --> 00:28:19,240
이 C에서

550
00:28:19,240 --> 00:28:20,940
>> 그래서 입력에게 의사가있다.

551
00:28:20,940 --> 00:28:22,940
우리가 시작하기 전에 빠른 메모.

552
00:28:22,940 --> 00:28:25,560
우리는 수에 완전하지 않을 수 있습니다
모든이를 완료

553
00:28:25,560 --> 00:28:27,300
이러한 기능의 세 가지.

554
00:28:27,300 --> 00:28:30,630
그들에게 올바른 해결책이 있습니다
난 너희들에게 이메일 것

555
00:28:30,630 --> 00:28:33,730
섹션 뒤에, 그리고 것
CS50.net에 게시.

556
00:28:33,730 --> 00:28:35,640
그래서 난 당신을 권장하지 않습니다
섹션을보고 이동합니다.

557
00:28:35,640 --> 00:28:40,550
난에서 다음을 시도하는 것이 좋습니다 당신의
자신의 다음 연습을 사용

558
00:28:40,550 --> 00:28:41,760
답을 확인하는 문제.

559
00:28:41,760 --> 00:28:47,070
이들은 모두 설계되었습니다에 밀접하게
관련 및 준수 무엇

560
00:28:47,070 --> 00:28:48,400
당신은 문제 세트에서 수행해야합니다.

561
00:28:48,400 --> 00:28:53,820
그래서 나는이 연습을하는 것이 좋습니다 않습니다
자신에 다음에 코드를 사용

562
00:28:53,820 --> 00:28:54,660
답을 확인합니다.

563
00:28:54,660 --> 00:28:57,060
나는 해시에 이동하려는 않기 때문에
섹션의 어떤 시점에서 테이블.

564
00:28:57,060 --> 00:28:58,150
그래서 우리는 모두 통과되지 않을 수 있습니다.

565
00:28:58,150 --> 00:28:59,960
그러나 우리는 지금 우리가 할 수있는 많은 것을 할 수 있습니다.

566
00:28:59,960 --> 00:29:00,370
>> OK.

567
00:29:00,370 --> 00:29:01,960
우리가 시작합시다.

568
00:29:01,960 --> 00:29:04,770
ASAM, 어떻게 우리는 새로운 노드를 만들려면 어떻게해야합니까?

569
00:29:04,770 --> 00:29:06,810
>> 청중 : 당신은 * 구조체 않습니다.

570
00:29:06,810 --> 00:29:09,640
>> 제이슨 허쉬 호른 : 그래서 우리
여기에이를 수 있습니다.

571
00:29:09,640 --> 00:29:10,040
아, 죄송합니다.

572
00:29:10,040 --> 00:29:13,530
당신은 * 구조체를 말 하였다.

573
00:29:13,530 --> 00:29:17,260
>> 청중 : 그리고 [? 종류?]
노드 나 C 노드.

574
00:29:17,260 --> 00:29:17,780
>> 제이슨 허쉬 호른 : OK.

575
00:29:17,780 --> 00:29:19,740
나는 그것을 new_node 호출하는거야
그래서 우리는 일관성을 유지 할 수 있습니다.

576
00:29:19,740 --> 00:29:22,646

577
00:29:22,646 --> 00:29:33,180
>> 청중 : 당신은 그렇게 설정하려면
, 첫 번째 노드를 머리에.

578
00:29:33,180 --> 00:29:33,580
>> 제이슨 허쉬 호른 : OK.

579
00:29:33,580 --> 00:29:37,290
그래서 지금이 가리키는 - 그래서이
아직 새 노드를 생성하지 않았습니다.

580
00:29:37,290 --> 00:29:41,380
이것은 단지를 가리키는
목록에있는 첫 번째 노드.

581
00:29:41,380 --> 00:29:42,630
어떻게 새 노드를 만들려면 어떻게해야합니까?

582
00:29:42,630 --> 00:29:45,490

583
00:29:45,490 --> 00:29:48,070
나는 새로운 노드를 만들 공간이 필요합니다.

584
00:29:48,070 --> 00:29:49,230
MALLOC.

585
00:29:49,230 --> 00:29:51,710
그리고 얼마나 큰?

586
00:29:51,710 --> 00:30:00,390
>> 청중 : 구조체의 크기입니다.

587
00:30:00,390 --> 00:30:01,150
>> 제이슨 허쉬 호른 :
구조체의 크기입니다.

588
00:30:01,150 --> 00:30:02,400
그리고 구조체는 무엇이라고?

589
00:30:02,400 --> 00:30:09,670

590
00:30:09,670 --> 00:30:09,840
>> 청중 : 노드?

591
00:30:09,840 --> 00:30:11,640
>> 제이슨 허쉬 호른 : 노드.

592
00:30:11,640 --> 00:30:17,640
그래서의 malloc (sizeof 연산자 (노드));
우리에게 공간을 제공합니다.

593
00:30:17,640 --> 00:30:19,740
그리고이 줄은 -

594
00:30:19,740 --> 00:30:21,740
한 가지가이 선에 올바르지 않습니다.

595
00:30:21,740 --> 00:30:24,430
구조체에 대한 포인터 new_node인가?

596
00:30:24,430 --> 00:30:25,650
즉, 일반적인 이름입니다.

597
00:30:25,650 --> 00:30:26,520
그것은 무엇인가 -

598
00:30:26,520 --> 00:30:27,450
노드, 정확하게.

599
00:30:27,450 --> 00:30:29,340
그것은 * 노드입니다.

600
00:30:29,340 --> 00:30:33,010
그리고 우리는 바로 후 무엇을해야합니까
우리는 아산 무언가를 MALLOC?

601
00:30:33,010 --> 00:30:34,476
우리가 가장 먼저하는 일이 무엇입니까?

602
00:30:34,476 --> 00:30:38,850

603
00:30:38,850 --> 00:30:40,320
어떻게 그것이 작동하지 않는 경우에?

604
00:30:40,320 --> 00:30:42,430
>> 청중 : 아, 확인하면
노드를 가리키는?

605
00:30:42,430 --> 00:30:43,310
>> 제이슨 허쉬 호른 : 그렇지.

606
00:30:43,310 --> 00:30:46,750
그래서 new_node 경우 등호 동일
널 (null), 우리는 무엇을해야합니까?

607
00:30:46,750 --> 00:30:51,650

608
00:30:51,650 --> 00:30:54,820
이 부울,이 함수를 반환합니다.

609
00:30:54,820 --> 00:30:57,760
정확히.

610
00:30:57,760 --> 00:30:58,450
좋아 보인다.

611
00:30:58,450 --> 00:30:59,680
거기에 추가 할 수 없나?

612
00:30:59,680 --> 00:31:00,670
우리는 말에 일을 추가합니다.

613
00:31:00,670 --> 00:31:03,160
그러나 지금까지 잘 보인다.

614
00:31:03,160 --> 00:31:06,170
현재 및 이전 포인터를 만듭니다.

615
00:31:06,170 --> 00:31:08,650
마이클, 나는 이것이 어떻게해야합니까?

616
00:31:08,650 --> 00:31:12,810
>> 청중 : 당신은 것
노드를 수행하는 방법 *.

617
00:31:12,810 --> 00:31:21,800

618
00:31:21,800 --> 00:31:25,502
당신은 하나를하지 수 있도록해야 할 것
new_node뿐만 대한

619
00:31:25,502 --> 00:31:26,905
노드는 우리가 이미 있습니다.

620
00:31:26,905 --> 00:31:27,230
>> 제이슨 허쉬 호른 : OK.

621
00:31:27,230 --> 00:31:29,255
따라서 현재 노드가 시작 됐어요.

622
00:31:29,255 --> 00:31:30,505
그 CURR를 호출합니다.

623
00:31:30,505 --> 00:31:39,650

624
00:31:39,650 --> 00:31:39,770
괜찮아요.

625
00:31:39,770 --> 00:31:41,620
우리는 우리가 유지하려는 결정했습니다
우리는 알 필요가 있기 때문에 두

626
00:31:41,620 --> 00:31:42,870
어떻게 그 이전입니다.

627
00:31:42,870 --> 00:31:45,770

628
00:31:45,770 --> 00:31:47,020
그들은 무엇으로 초기화합니까?

629
00:31:47,020 --> 00:31:49,874

630
00:31:49,874 --> 00:31:54,180
>> 청중 : 우리의 목록에서 자신의 가치.

631
00:31:54,180 --> 00:31:58,090
>> 제이슨 허쉬 호른 : 그래서 무엇인가
우리의 목록에 첫 번째 것은?

632
00:31:58,090 --> 00:32:04,050
아니면 우리가 어떻게 알 수 있습니까 곳
우리의 목록의 시작은 무엇입니까?

633
00:32:04,050 --> 00:32:08,015
>> 청중 :이 전달되지 않습니다
함수에?

634
00:32:08,015 --> 00:32:08,466
>> 제이슨 허쉬 호른 : 오른쪽.

635
00:32:08,466 --> 00:32:09,716
그것은 바로 여기에서 통과되었다.

636
00:32:09,716 --> 00:32:15,910

637
00:32:15,910 --> 00:32:18,980
이 함수에 전달 그래서 경우,
목록의 시작, 무엇을 우리가해야

638
00:32:18,980 --> 00:32:21,270
동일한 전류를 설정?

639
00:32:21,270 --> 00:32:22,110
>> 청중 : 목록.

640
00:32:22,110 --> 00:32:22,900
>> 제이슨 허쉬 호른 : 목록.

641
00:32:22,900 --> 00:32:24,090
그게 바로 그렇습니다.

642
00:32:24,090 --> 00:32:26,290
지금은 주소를 가지고
우리의 목록의 시작.

643
00:32:26,290 --> 00:32:28,450
그리고 무엇 이전에 대한?

644
00:32:28,450 --> 00:32:31,920
>> 청중 : 목록을 뺀?

645
00:32:31,920 --> 00:32:32,690
>> 제이슨 허쉬 호른 :있다
그 전에 아무 것도 없습니다.

646
00:32:32,690 --> 00:32:34,580
그래서 우리는 아무것도 의미하지하기 위해 무엇을 할 수 있습니까?

647
00:32:34,580 --> 00:32:35,050
>> 청중 : 널.

648
00:32:35,050 --> 00:32:35,450
>> 제이슨 허쉬 호른 : 네.

649
00:32:35,450 --> 00:32:37,950
좋은 생각처럼 들린다.

650
00:32:37,950 --> 00:32:38,360
완벽한.

651
00:32:38,360 --> 00:32:39,630
감사합니다.

652
00:32:39,630 --> 00:32:42,850
목록을 이동합니다.

653
00:32:42,850 --> 00:32:45,490
콘스탄틴, 얼마나 오래 갈까
목록을 이동하는 방법?

654
00:32:45,490 --> 00:32:49,010
>> 청중 : 우리는 널 (null)에 도달 할 때까지.

655
00:32:49,010 --> 00:32:49,390
>> 제이슨 허쉬 호른 : OK.

656
00:32:49,390 --> 00:32:50,430
그래서, 만약 루프, 동안.

657
00:32:50,430 --> 00:32:52,200
우리는 무엇을하고 있습니까?

658
00:32:52,200 --> 00:32:53,320
>> 청중 : 아마 루프?

659
00:32:53,320 --> 00:32:53,910
>> 제이슨 허쉬 호른 : 이제 루프를하자.

660
00:32:53,910 --> 00:32:55,870
OK.

661
00:32:55,870 --> 00:33:02,465
>> 청중 : 그리고 우리는 말할 -

662
00:33:02,465 --> 00:33:09,764

663
00:33:09,764 --> 00:33:13,390
현재 포인터까지
null이 동일하지 않습니다.

664
00:33:13,390 --> 00:33:19,160
>> 제이슨 허쉬 호른 : 그래서 우리가 알고있는 경우
조건, 우리는 어떻게 루프를 작성할 수 있습니다

665
00:33:19,160 --> 00:33:21,740
그 조건을 기반으로.

666
00:33:21,740 --> 00:33:24,380
우리는 루프의 어떤 종류를 사용해야합니까?

667
00:33:24,380 --> 00:33:25,260
>> 청중 : 동안.

668
00:33:25,260 --> 00:33:25,590
>> 제이슨 허쉬 호른 : 네.

669
00:33:25,590 --> 00:33:27,130
즉 기반으로 더 의미가 있습니다
당신이 말한 끕니다.

670
00:33:27,130 --> 00:33:29,430
우리가 우리에 가고 싶은 경우는 것
단지 그 일을 알고 만들 것

671
00:33:29,430 --> 00:33:31,680
while 루프를 수행하는 것이.

672
00:33:31,680 --> 00:33:39,880
현재는 동일하지 NULL을하지,하지만
값은이 노드보다 작은 경우.

673
00:33:39,880 --> 00:33:41,650
Akshar, 날이 선을 제공합니다.

674
00:33:41,650 --> 00:33:48,810

675
00:33:48,810 --> 00:33:56,955
>> 청중 : 만약 현재 -> N
N 값 미만.

676
00:33:56,955 --> 00:34:00,170

677
00:34:00,170 --> 00:34:03,260
아니면 그 반대.

678
00:34:03,260 --> 00:34:06,140
그 브래킷을 전환합니다.

679
00:34:06,140 --> 00:34:06,620
>> 제이슨 허쉬 호른 : 죄송합니다.

680
00:34:06,620 --> 00:34:08,760
>> 청중 : 브래킷을 변경합니다.

681
00:34:08,760 --> 00:34:10,914
>> 제이슨 허쉬 호른 : 그래서 만약
값보다 크다.

682
00:34:10,914 --> 00:34:18,719

683
00:34:18,719 --> 00:34:22,120
그와 혼란 때문에
위의 언급, 내가 할거야.

684
00:34:22,120 --> 00:34:22,480
그러나 예.

685
00:34:22,480 --> 00:34:25,125
우리의 값이이보다 작은 경우
노드, 우리는 무엇을해야합니까?

686
00:34:25,125 --> 00:34:25,540
오.

687
00:34:25,540 --> 00:34:26,710
바로 여기에 있습니다.

688
00:34:26,710 --> 00:34:27,960
전에 삽입합니다.

689
00:34:27,960 --> 00:34:32,080

690
00:34:32,080 --> 00:34:32,370
OK.

691
00:34:32,370 --> 00:34:33,933
우리가 어떻게해야합니까?

692
00:34:33,933 --> 00:34:34,900
>> 청중 : 그것은 나를 아직도 있나요?

693
00:34:34,900 --> 00:34:36,150
>> 제이슨 허쉬 호른 : 네.

694
00:34:36,150 --> 00:34:38,520

695
00:34:38,520 --> 00:34:39,770
>> 청중 : 당신 -

696
00:34:39,770 --> 00:34:42,909

697
00:34:42,909 --> 00:34:44,159
new_node -> 다음.

698
00:34:44,159 --> 00:34:46,770

699
00:34:46,770 --> 00:34:50,163
>> 제이슨 허쉬 호른 : 그래서 무엇을
즉, 동일하게가는거야?

700
00:34:50,163 --> 00:34:52,070
>> 청중 : 그것은 동일한 전류 것입니다.

701
00:34:52,070 --> 00:34:53,889
>> 제이슨 허쉬 호른 : 그렇지.

702
00:34:53,889 --> 00:34:55,730
그리고 다른 -

703
00:34:55,730 --> 00:34:56,730
우리가 업데이트 밖의 무엇을해야합니까?

704
00:34:56,730 --> 00:34:59,982
>> 청중 : 과거가 널 (null)에 해당하는지 확인합니다.

705
00:34:59,982 --> 00:35:01,870
>> 제이슨 허쉬 호른 : 이동 이전하는 경우 -

706
00:35:01,870 --> 00:35:03,730
그렇다면 이전은 null 같습니다.

707
00:35:03,730 --> 00:35:05,990
>> 청중 : 그게 무슨 의미
머리가 될 수 있습니다.

708
00:35:05,990 --> 00:35:06,780
>> 제이슨 허쉬 호른 : 그 말
그것은 머리되고있다.

709
00:35:06,780 --> 00:35:07,620
그럼 우리는 무엇을해야합니까?

710
00:35:07,620 --> 00:35:12,510
>> 청중 : 우리는 머리를 할은 new_node 같습니다.

711
00:35:12,510 --> 00:35:16,690
>> 제이슨 허쉬 호른 : 머리
new_node 같습니다.

712
00:35:16,690 --> 00:35:20,540
왜 나열하지, 여기에 머리?

713
00:35:20,540 --> 00:35:24,940
>> 청중 : 머리는 글로벌이기 때문에
시작 장소입니다 변수.

714
00:35:24,940 --> 00:35:26,190
>> 제이슨 허쉬 호른 : 스위트.

715
00:35:26,190 --> 00:35:33,750

716
00:35:33,750 --> 00:35:34,170
OK.

717
00:35:34,170 --> 00:35:36,150
그리고 -

718
00:35:36,150 --> 00:35:53,796
>> 청중 : 그럼 당신은 다른 않는보기 이전 ->
다음 new_node 같음.

719
00:35:53,796 --> 00:35:55,080
그리고 당신은 true를 반환.

720
00:35:55,080 --> 00:35:59,560

721
00:35:59,560 --> 00:36:02,700
>> 제이슨 허쉬 호른 : 어디 할
우리는 new_node 끝을 설정?

722
00:36:02,700 --> 00:36:04,850
>> 청중 : 나는 것 -

723
00:36:04,850 --> 00:36:06,180
나는 처음에 그 설정합니다.

724
00:36:06,180 --> 00:36:07,430
>> 제이슨 허쉬 호른 : 그래서 라인?

725
00:36:07,430 --> 00:36:10,000

726
00:36:10,000 --> 00:36:12,598
>> 청중 : 후 if 문
가 알려진 경우 확인.

727
00:36:12,598 --> 00:36:13,057
>> 제이슨 허쉬 호른 : 바로 여기?

728
00:36:13,057 --> 00:36:18,335
>> 청중 : 내가 할 것 new_node -> N
값과 같다.

729
00:36:18,335 --> 00:36:19,585
>> 제이슨 허쉬 호른 : 좋은 데요.

730
00:36:19,585 --> 00:36:21,740

731
00:36:21,740 --> 00:36:25,090
아마 의미가 있습니다 - 우리는하지 않습니다
우리가 왜 왔는지 목록 알아야

732
00:36:25,090 --> 00:36:26,280
우리는 다루고 있기 때문에
하나의 목록과 함께.

733
00:36:26,280 --> 00:36:29,560
이처럼 더 나은 함수 선언
이것은 단지이 제거하는 것입니다

734
00:36:29,560 --> 00:36:34,360
완전히 그냥 삽입
머리에 값.

735
00:36:34,360 --> 00:36:35,930
우리는 심지어 알 필요가 없습니다
우리가 처한 어떤 목록

736
00:36:35,930 --> 00:36:39,140
하지만 지금은 보관 것이다
다음 업데이트시 변경

737
00:36:39,140 --> 00:36:42,590
슬라이드 및 코드.

738
00:36:42,590 --> 00:36:44,980
그래서 지금은 좋아 보인다.

739
00:36:44,980 --> 00:36:46,560
만약 값 -이 줄을 할 수 있습니까?

740
00:36:46,560 --> 00:36:47,810
만약 -

741
00:36:47,810 --> 00:36:52,240

742
00:36:52,240 --> 00:36:53,840
우리는 노아, 여기에 무엇을해야합니까.

743
00:36:53,840 --> 00:36:57,890

744
00:36:57,890 --> 00:37:07,100
>> 청중 : 값이 큰 경우
N CURR->보다 -

745
00:37:07,100 --> 00:37:16,830

746
00:37:16,830 --> 00:37:18,240
>> 제이슨 허쉬 호른 : 어떻게
우리는 다음 노드로 이동?

747
00:37:18,240 --> 00:37:27,760

748
00:37:27,760 --> 00:37:30,530
>> 청중 : 문헌 [Curr -> n은
new_node 동일.

749
00:37:30,530 --> 00:37:37,630

750
00:37:37,630 --> 00:37:39,195
>> 제이슨 허쉬 호른 : 그래서 n은
구조체의 어떤 부분?

751
00:37:39,195 --> 00:37:43,065

752
00:37:43,065 --> 00:37:46,020
정수입니다.

753
00:37:46,020 --> 00:37:50,420
그리고 new_node는 노드에 대한 포인터입니다.

754
00:37:50,420 --> 00:37:51,880
그래서 우리는 CURR의 어떤 부분을 업데이트해야합니까?

755
00:37:51,880 --> 00:38:03,900

756
00:38:03,900 --> 00:38:05,400
하지 N 경우, 다른 부분은 무엇입니까?

757
00:38:05,400 --> 00:38:21,680

758
00:38:21,680 --> 00:38:22,810
노아, 다른 부분은 무엇인가.

759
00:38:22,810 --> 00:38:23,570
>> 청중 : 아, 다음에.

760
00:38:23,570 --> 00:38:25,645
>> 제이슨 허쉬 호른 : 다음, 정확하게.

761
00:38:25,645 --> 00:38:26,410
정확히.

762
00:38:26,410 --> 00:38:28,770
다음으로 오른쪽에 하나입니다.

763
00:38:28,770 --> 00:38:31,540
그리고 우리는 다른 무엇을해야합니까
노아를 업데이트?

764
00:38:31,540 --> 00:38:32,840
>> 청중 : 포인터.

765
00:38:32,840 --> 00:38:34,840
>> 제이슨 허쉬 호른 : 그래서
우리는 현재 업데이트.

766
00:38:34,840 --> 00:38:36,090
>> 청중 : 이전 -> 다음.

767
00:38:36,090 --> 00:38:48,160

768
00:38:48,160 --> 00:38:49,410
>> 제이슨 허쉬 호른 : 네.

769
00:38:49,410 --> 00:38:57,465

770
00:38:57,465 --> 00:38:58,370
OK, 우리는 일시 중지됩니다.

771
00:38:58,370 --> 00:39:02,200
누가 여기에 우리를 도울 수 있는가?

772
00:39:02,200 --> 00:39:03,385
마누, 우리는 무엇을해야 하는가?

773
00:39:03,385 --> 00:39:05,615
>> 청중 : 당신은 설정할 수있어
그것은 CURR -> 다음에 해당.

774
00:39:05,615 --> 00:39:09,110

775
00:39:09,110 --> 00:39:11,630
그러나 이전 행하기 전에 해당 작업을 수행.

776
00:39:11,630 --> 00:39:12,880
>> 제이슨 허쉬 호른 : OK.

777
00:39:12,880 --> 00:39:16,590

778
00:39:16,590 --> 00:39:18,260
다른 건?

779
00:39:18,260 --> 00:39:19,170
Akshar.

780
00:39:19,170 --> 00:39:22,680
>> 청중 : 당신이 생각하지 않는다
다음 CURR->를 변경하는 것을 의미했다.

781
00:39:22,680 --> 00:39:29,270
당신이 CURR 같음을 의미 같아요
CURR -> 다음 노드로 이동 옆에.

782
00:39:29,270 --> 00:39:30,500
>> 제이슨 허쉬 호른 : 그래서 죄송합니다, 어디?

783
00:39:30,500 --> 00:39:32,680
어떤 줄에?

784
00:39:32,680 --> 00:39:33,420
이 라인?

785
00:39:33,420 --> 00:39:33,750
>> 청중 : 네.

786
00:39:33,750 --> 00:39:35,745
확인 CURR 다음 CURR -> 같습니다.

787
00:39:35,745 --> 00:39:39,690

788
00:39:39,690 --> 00:39:43,360
>> 제이슨 허쉬 호른 : 그래서 정답
전류이므로

789
00:39:43,360 --> 00:39:45,220
노드에 대한 포인터입니다.

790
00:39:45,220 --> 00:39:48,550
그리고 우리는 다음을 가리 키도록 할
현재 점점 어떤 노드

791
00:39:48,550 --> 00:39:49,930
을 지적했다.

792
00:39:49,930 --> 00:39:54,410
CURR 자체는 다음이 있습니다.

793
00:39:54,410 --> 00:39:58,620
그러나 우리는한다면 curr.next를 업데이트하기 위해,
실제 노트를 업데이트 할 것

794
00:39:58,620 --> 00:40:01,430
그 자체가 아닌 곳
포인터가 가리키는했다.

795
00:40:01,430 --> 00:40:02,680
어떤이 라인에 대한,하지만.

796
00:40:02,680 --> 00:40:05,160

797
00:40:05,160 --> 00:40:07,330
아비?

798
00:40:07,330 --> 00:40:09,590
>> 청중 : 이전 -> 다음 CURR 같습니다.

799
00:40:09,590 --> 00:40:12,500

800
00:40:12,500 --> 00:40:19,440
>> 제이슨 허쉬 호른 : 그럼 다시, 만약 이전은 (는)
노드에 대한 포인터는 이전 -> 다음입니다

801
00:40:19,440 --> 00:40:23,020
노드에있는 실제 포인터.

802
00:40:23,020 --> 00:40:27,190
그래서이 업데이트 될 것이다
CURR에 노드에 포인터.

803
00:40:27,190 --> 00:40:28,570
우리는 업데이트 할 수 없습니다
노드의 포인터.

804
00:40:28,570 --> 00:40:30,570
우리는 이전 업데이트 할.

805
00:40:30,570 --> 00:40:31,850
그래서 우리는 어떻게해야합니까?

806
00:40:31,850 --> 00:40:34,250
>> 청중 : 그냥보기 이전 될 것이다.

807
00:40:34,250 --> 00:40:34,565
>> 제이슨 허쉬 호른 : 오른쪽.

808
00:40:34,565 --> 00:40:35,560
는 이전 노드에 포인터이다.

809
00:40:35,560 --> 00:40:38,750
이제 우리는로 변경하고
노드에 새로운 포인터.

810
00:40:38,750 --> 00:40:40,830
OK 우리가 아래로 이동하자.

811
00:40:40,830 --> 00:40:41,940
마지막으로,이 마지막 조건.

812
00:40:41,940 --> 00:40:44,896
제프, 우리는 여기에서 무엇을해야합니까?

813
00:40:44,896 --> 00:40:47,515
>> 청중 : 값이있는 경우
CURR-> N과 동일.

814
00:40:47,515 --> 00:40:51,030

815
00:40:51,030 --> 00:40:51,300
>> 제이슨 허쉬 호른 : 죄송합니다.

816
00:40:51,300 --> 00:40:52,372
맙소사.

817
00:40:52,372 --> 00:40:54,330
무엇?

818
00:40:54,330 --> 00:40:55,580
값 == CURR-> N.

819
00:40:55,580 --> 00:41:01,050

820
00:41:01,050 --> 00:41:02,300
우리는 무엇을해야합니까?

821
00:41:02,300 --> 00:41:04,760

822
00:41:04,760 --> 00:41:10,950
>> 청중 : 당신은 우리의 new_node을 무료 것,
다음은 false를 반환 것입니다.

823
00:41:10,950 --> 00:41:21,410

824
00:41:21,410 --> 00:41:23,460
>> 제이슨 허쉬 호른 :이 무엇인지
우리는 지금까지 작성했습니다.

825
00:41:23,460 --> 00:41:25,710
사람은 무엇을해야합니까
우리가하기 전에 추가하는 방법?

826
00:41:25,710 --> 00:41:35,460

827
00:41:35,460 --> 00:41:35,710
OK.

828
00:41:35,710 --> 00:41:36,960
의 해보자.

829
00:41:36,960 --> 00:41:44,180

830
00:41:44,180 --> 00:41:46,110
제어 단부에 도달 할 수있다
void가 아닌 함수의.

831
00:41:46,110 --> 00:41:48,310
아비, 무슨 일이야?

832
00:41:48,310 --> 00:41:51,380
>> 청중 : 당신은 수익을 넣어되어 있습니까
while 루프의 외부에 사실?

833
00:41:51,380 --> 00:41:53,900

834
00:41:53,900 --> 00:41:54,400
>> 제이슨 허쉬 호른 : 모르겠어요.

835
00:41:54,400 --> 00:41:54,780
당신이 나를 하시겠습니까?

836
00:41:54,780 --> 00:41:55,520
>> 청중 : 신경 쓰지 마세요.

837
00:41:55,520 --> 00:41:56,350
아니오.

838
00:41:56,350 --> 00:41:57,180
>> 제이슨 허쉬 호른 : Akshar?

839
00:41:57,180 --> 00:41:59,460
>> 청중 : 나는 당신이 의미 생각
마지막에 반환 거짓을 넣어

840
00:41:59,460 --> 00:42:02,230
while 루프의.

841
00:42:02,230 --> 00:42:03,270
>> 제이슨 허쉬 호른 : 어디
당신은 어디로 가고 싶어?

842
00:42:03,270 --> 00:42:05,270
>> 청중 : while 루프 외부처럼.

843
00:42:05,270 --> 00:42:08,800
그래서 당신은 그 방법에게 while 루프를 종료하는 경우
당신은 끝에 도달했는지

844
00:42:08,800 --> 00:42:09,980
아무것도 일이 없어요.

845
00:42:09,980 --> 00:42:10,410
>> 제이슨 허쉬 호른 : OK.

846
00:42:10,410 --> 00:42:12,340
그래서 우리는 여기에서 무엇을해야합니까?

847
00:42:12,340 --> 00:42:13,702
>> 청중 : 당신은 false를 반환
이뿐만 아니라.

848
00:42:13,702 --> 00:42:15,040
>> 제이슨 허쉬 호른 : 아,
두 곳에서 그것을 할?

849
00:42:15,040 --> 00:42:15,650
>> 청중 : 네.

850
00:42:15,650 --> 00:42:16,900
>> 제이슨 허쉬 호른 : OK.

851
00:42:16,900 --> 00:42:24,840

852
00:42:24,840 --> 00:42:26,160
우리가 가야하나요?

853
00:42:26,160 --> 00:42:26,980
맙소사.

854
00:42:26,980 --> 00:42:27,290
미안 해요.

855
00:42:27,290 --> 00:42:28,480
나는 화면을 드려 죄송합니다.

856
00:42:28,480 --> 00:42:30,530
그것은 종류의 우리에게 끼쳐 요.

857
00:42:30,530 --> 00:42:31,520
그래서 옵션을 선택합니다.

858
00:42:31,520 --> 00:42:35,260
제로는, 코드마다, 프로그램을 종료.

859
00:42:35,260 --> 00:42:36,700
하나는 뭔가를 삽입합니다.

860
00:42:36,700 --> 00:42:37,990
의 세 가지를 삽입 할 수 있습니다.

861
00:42:37,990 --> 00:42:42,900

862
00:42:42,900 --> 00:42:45,380
삽입이 성공하지 못했습니다.

863
00:42:45,380 --> 00:42:46,500
나는 인쇄 할거야.

864
00:42:46,500 --> 00:42:48,050
난 아무것도 필요가 없습니다.

865
00:42:48,050 --> 00:42:48,450
OK.

866
00:42:48,450 --> 00:42:50,250
어쩌면 그것은 단지 우연이었다.

867
00:42:50,250 --> 00:42:52,810
하나를 삽입합니다.

868
00:42:52,810 --> 00:42:55,770
성공하지.

869
00:42:55,770 --> 00:42:57,470
OK.

870
00:42:57,470 --> 00:43:02,400
의 정말 빨리 GDB를 통해 실행하자
무슨 일이 일어나고 있는지 확인합니다.

871
00:43:02,400 --> 00:43:06,055
>> 의 GDB를 기억하십시오. / 이름하여
프로그램은 GDB로 우리를 가져옵니다.

872
00:43:06,055 --> 00:43:07,610
많이 처리 할 수​​ 있다는 것입니다?

873
00:43:07,610 --> 00:43:08,560
깜박이는?

874
00:43:08,560 --> 00:43:10,400
아마.

875
00:43:10,400 --> 00:43:12,760
눈을 감고 몇 가지 깊은을
당신이 피곤하면 호흡

876
00:43:12,760 --> 00:43:13,580
의 그것을보고.

877
00:43:13,580 --> 00:43:14,200
나는 GDB에있어.

878
00:43:14,200 --> 00:43:15,830
GDB에서 내가 가장 먼저하는 일이 무엇입니까?

879
00:43:15,830 --> 00:43:17,050
우리는 알아낼 수있어
무슨 일이 일어나고.

880
00:43:17,050 --> 00:43:17,310
보자.

881
00:43:17,310 --> 00:43:21,650
우리는 그림 6 분을
무슨 일인지.

882
00:43:21,650 --> 00:43:22,900
주요 휴식.

883
00:43:22,900 --> 00:43:25,950

884
00:43:25,950 --> 00:43:28,130
그리고 내가 무엇을해야합니까?

885
00:43:28,130 --> 00:43:29,180
카를로스?

886
00:43:29,180 --> 00:43:31,060
실행합니다.

887
00:43:31,060 --> 00:43:32,250
OK.

888
00:43:32,250 --> 00:43:34,160
의이 옵션을 선택할 수 있습니다.

889
00:43:34,160 --> 00:43:36,330
그리고 N 무엇을 하는가?

890
00:43:36,330 --> 00:43:38,480
다음.

891
00:43:38,480 --> 00:43:38,950
그래.

892
00:43:38,950 --> 00:43:39,740
>> 청중 : 당신이 언급하지 않았다 -

893
00:43:39,740 --> 00:43:45,230
당신은 머리는 것을 말하지 않았다
처음에 null로 초기화.

894
00:43:45,230 --> 00:43:47,140
그러나 나는 당신이 그 확인을했다 생각했다.

895
00:43:47,140 --> 00:43:50,040

896
00:43:50,040 --> 00:43:52,640
>> 제이슨 허쉬 호른 : 가자 -의를 살펴 보자
GDB에, 그리고, 우리는 돌아 가야합니다.

897
00:43:52,640 --> 00:43:54,910
당신이 이미 가지고있는 것처럼하지만 소리
무슨 일이 일어나고 있는지에 대한 몇 가지 아이디어.

898
00:43:54,910 --> 00:43:58,340
그래서 우리는 뭔가를 삽입 할.

899
00:43:58,340 --> 00:43:59,390
OK.

900
00:43:59,390 --> 00:44:00,150
우리는 삽입했다.

901
00:44:00,150 --> 00:44:00,770
int를 입력 해 주시기 바랍니다.

902
00:44:00,770 --> 00:44:01,990
우리는 세 가지를 삽입 할 수 있습니다.

903
00:44:01,990 --> 00:44:03,000
그리고 나는이 줄에 있어요.

904
00:44:03,000 --> 00:44:07,030
어떻게 디버깅을 시작 가는가
삽입 기능을 알고?

905
00:44:07,030 --> 00:44:08,280
맙소사.

906
00:44:08,280 --> 00:44:10,990

907
00:44:10,990 --> 00:44:12,240
즉 많은입니다.

908
00:44:12,240 --> 00:44:14,372

909
00:44:14,372 --> 00:44:16,445
것을 많이 났는데?

910
00:44:16,445 --> 00:44:19,696

911
00:44:19,696 --> 00:44:21,680
>> 청중 : 아, 그것은 죽었다.

912
00:44:21,680 --> 00:44:22,930
>> 제이슨 허쉬 호른 : 그냥
그것을 꺼냈다.

913
00:44:22,930 --> 00:44:27,364

914
00:44:27,364 --> 00:44:28,310
OK.

915
00:44:28,310 --> 00:44:29,560
>> 청중 : 어쩌면 그것은이다
와이어의 다른 쪽 끝.

916
00:44:29,560 --> 00:44:37,000

917
00:44:37,000 --> 00:44:39,470
>> 제이슨 허쉬 호른 : 와우​​.

918
00:44:39,470 --> 00:44:42,330
그래서 결론 -

919
00:44:42,330 --> 00:44:43,470
당신은 무엇을 말 했는가?

920
00:44:43,470 --> 00:44:46,040
>> 청중 : 내가 말했듯이 기술의 아이러니
이 클래스의 어려움.

921
00:44:46,040 --> 00:44:46,410
>> 제이슨 허쉬 호른 : 알아요.

922
00:44:46,410 --> 00:44:48,660
경우에만 그 부분을 제어 할 수 있었다.

923
00:44:48,660 --> 00:44:49,910
[청취]

924
00:44:49,910 --> 00:44:54,430

925
00:44:54,430 --> 00:44:55,400
잘 됐네요.

926
00:44:55,400 --> 00:44:58,680
왜 너희들에 대해 생각을 시작하지 않는다
우리가 잘못 할 수 있었다,

927
00:44:58,680 --> 00:45:01,140
그리고 우리는 90 초가 될 것입니다.

928
00:45:01,140 --> 00:46:18,160

929
00:46:18,160 --> 00:46:23,010
>> Avica, 나는 어떻게 이동하는 방법을 물어 보자
그것을 디버깅하는 내부 insert_node.

930
00:46:23,010 --> 00:46:28,940

931
00:46:28,940 --> 00:46:31,460
우리가 마지막으로 중단 된 곳이야.

932
00:46:31,460 --> 00:46:35,110
어떻게 insert_node 내부에 가야합니까, Avica,
무슨 일이 일어나고 있는지 검사하는 방법?

933
00:46:35,110 --> 00:46:36,360
무엇 GDB 명령?

934
00:46:36,360 --> 00:46:41,050

935
00:46:41,050 --> 00:46:42,390
브레이크 내부에 데려다하지 않을 것입니다.

936
00:46:42,390 --> 00:46:46,200

937
00:46:46,200 --> 00:46:47,130
후작 알고 있나요?

938
00:46:47,130 --> 00:46:48,240
>> 청중 : 무엇?

939
00:46:48,240 --> 00:46:51,780
>> 제이슨 허쉬 호른 : 어떤 GDB 명령
나는이 함수 내에서 이동하는 데 사용?

940
00:46:51,780 --> 00:46:52,070
>> 청중 : 단계?

941
00:46:52,070 --> 00:46:55,140
>> 제이슨 허쉬 호른 :를 통해 단계
내부 나 소요 S..

942
00:46:55,140 --> 00:46:55,476
OK.

943
00:46:55,476 --> 00:46:58,040
New_node는 일부 공간을 mallocing.

944
00:46:58,040 --> 00:46:59,120
모두는 거 같다고.

945
00:46:59,120 --> 00:47:00,370
의이 new_node을 살펴 보자.

946
00:47:00,370 --> 00:47:03,270

947
00:47:03,270 --> 00:47:05,410
그것은 어떤 메모리 주소를 얻었다.

948
00:47:05,410 --> 00:47:07,440
의 확인하자 -

949
00:47:07,440 --> 00:47:08,500
그게 올바른 것입니다.

950
00:47:08,500 --> 00:47:12,220
그래서 여기에 모든 것
제대로 작동 될 수있다.

951
00:47:12,220 --> 00:47:14,530
>> 청중 : 차이 무엇입니까
P와 디스플레이 사이?

952
00:47:14,530 --> 00:47:16,160
>> 제이슨 허쉬 호른 : P는 인쇄를 의미합니다.

953
00:47:16,160 --> 00:47:19,310
그리고 당신이 무엇을 요구하는지
그것과이 사이의 차이는?

954
00:47:19,310 --> 00:47:22,330
이 경우, 아무것도.

955
00:47:22,330 --> 00:47:26,960
그러나 일반적으로있다
약간의 차이.

956
00:47:26,960 --> 00:47:28,220
그리고 당신은 GDB 매뉴얼에 보일 것입니다.

957
00:47:28,220 --> 00:47:29,560
그러나이 경우, 아무것도.

958
00:47:29,560 --> 00:47:31,460
우리는하지만, 인쇄를 사용하는 경향이 있기 때문에
우리는보다 더 많은 작업을 수행 할 필요가 없습니다

959
00:47:31,460 --> 00:47:33,960
단일 값을 인쇄 할 수 있습니다.

960
00:47:33,960 --> 00:47:34,640
>> OK.

961
00:47:34,640 --> 00:47:40,300
그래서 우리는 우리의 코드의 라인 80에있는
목록에 해당 노드 *의 CURR 설정.

962
00:47:40,300 --> 00:47:42,500
우리가 CURR를 인쇄 할 수 있습니다.

963
00:47:42,500 --> 00:47:45,260

964
00:47:45,260 --> 00:47:46,840
이 목록 같습니다.

965
00:47:46,840 --> 00:47:48,850
달콤한.

966
00:47:48,850 --> 00:47:49,340
기다립니다.

967
00:47:49,340 --> 00:47:50,590
그것은 뭔가 같습니다.

968
00:47:50,590 --> 00:47:53,680

969
00:47:53,680 --> 00:47:56,190
그것은 바로 보이지 않는다.

970
00:47:56,190 --> 00:47:56,840
거기 우리는 간다.

971
00:47:56,840 --> 00:47:59,470
그건 GDB에서, 오른쪽, 경우 때문에
당신이 그것을하고있는 라인의

972
00:47:59,470 --> 00:48:00,330
아직 실행되지 않았습니다.

973
00:48:00,330 --> 00:48:03,100
그래서 당신은 실제로 입력해야
줄을 실행하기 위해 다음

974
00:48:03,100 --> 00:48:05,230
그 결과를보고하기 전에.

975
00:48:05,230 --> 00:48:06,680
그래서 여기에 우리가 있습니다.

976
00:48:06,680 --> 00:48:09,490
우리는 단지이 줄을 실행,
이전 널 같습니다.

977
00:48:09,490 --> 00:48:13,590
그래서 다시, 우리는 이전에 인쇄하면
우리는 이상한 아무것도 볼 수 없습니다.

978
00:48:13,590 --> 00:48:18,680
그러나 우리는 실제로 그것을 실행하는 경우
라인, 우리는 볼 수 있습니다

979
00:48:18,680 --> 00:48:20,380
그 라인은 일한.

980
00:48:20,380 --> 00:48:21,060
>> 그래서 우리는 CURR있다.

981
00:48:21,060 --> 00:48:23,180
사람들은 모두 좋다.

982
00:48:23,180 --> 00:48:24,010
오른쪽?

983
00:48:24,010 --> 00:48:28,130
이제 우리는 여기이 선에 있어요.

984
00:48:28,130 --> 00:48:29,310
CURR는 동일 널 (null)을하지 않지만.

985
00:48:29,310 --> 00:48:31,110
음, CURR은 동일 무엇을합니까?

986
00:48:31,110 --> 00:48:32,450
우리는 단지 null이 같게 보았다.

987
00:48:32,450 --> 00:48:33,210
우리는 그것을 밖으로 인쇄.

988
00:48:33,210 --> 00:48:35,110
나는 다시 인쇄합니다.

989
00:48:35,110 --> 00:48:36,720
그래서입니다 while 루프
실행하는 것?

990
00:48:36,720 --> 00:48:37,270
>> 청중 : 호

991
00:48:37,270 --> 00:48:39,790
>> 제이슨 허쉬 호른 : 그래서 내가 입력 한 때
라인, 당신은 우리가 모든 방법을 뛰어 참조

992
00:48:39,790 --> 00:48:41,390
아래로 아래로, false를 반환합니다.

993
00:48:41,390 --> 00:48:44,520
그리고 우리는 false를 반환거야
우리의 프로그램으로 돌아가서

994
00:48:44,520 --> 00:48:48,020
우리가 본처럼 결국, 인쇄,
삽입이 성공하지 못했습니다.

995
00:48:48,020 --> 00:48:51,010
그래서, 사람은 무엇에 대한 아이디어를 가지고
우리는이 문제를 해결하려면 어떻게해야합니까?

996
00:48:51,010 --> 00:48:54,200

997
00:48:54,200 --> 00:48:57,570
내가 볼 때까지 기다릴거야
손의 두 최대 이동합니다.

998
00:48:57,570 --> 00:48:58,830
우리는이 작업을 실행하지 못했습니다.

999
00:48:58,830 --> 00:49:01,660
명심이 처음
우리가하고 있었던 것.

1000
00:49:01,660 --> 00:49:02,430
나는 몇 가지 작업을 수행하지 않을 것이다.

1001
00:49:02,430 --> 00:49:03,670
나는 몇 가지를 할거야.

1002
00:49:03,670 --> 00:49:04,830
부부는 두 가지를 의미하기 때문이다.

1003
00:49:04,830 --> 00:49:07,620
나는 두 개 이상 기다릴 수 있습니다.

1004
00:49:07,620 --> 00:49:10,690
>> 제 1 삽입, CURR,
기본값은 null 등호.

1005
00:49:10,690 --> 00:49:14,050
이 루프는 실행
CURR가 null가 아닌 경우.

1006
00:49:14,050 --> 00:49:18,740
그래서 내가 어떻게이 문제를 해결받을 수 있나요?

1007
00:49:18,740 --> 00:49:19,990
나는 3 손을 참조하십시오.

1008
00:49:19,990 --> 00:49:28,490

1009
00:49:28,490 --> 00:49:29,780
나는 3 개 이상 기다릴 수 있습니다.

1010
00:49:29,780 --> 00:49:33,460

1011
00:49:33,460 --> 00:49:35,940
마커스, 당신은 어떻게 생각합니까?

1012
00:49:35,940 --> 00:49:37,730
>> 청중 : 글쎄, 당신이 그것을 필요로하는 경우에
두 번 이상 실행하면 바로

1013
00:49:37,730 --> 00:49:39,948
DO-whil​​e 루프로 변경.

1014
00:49:39,948 --> 00:49:41,250
>> 제이슨 허쉬 호른 : OK.

1015
00:49:41,250 --> 00:49:44,240
즉, 비록 우리의 문제를 해결할 것인가?

1016
00:49:44,240 --> 00:49:47,750
>> 청중 :이 경우에는의 때문에 없습니다
목록이 비어 있다는 사실.

1017
00:49:47,750 --> 00:49:52,150
그럼 당신은 아마 추가해야
문이 경우 루프가 종료

1018
00:49:52,150 --> 00:49:55,312
당신은 말 할 필요
당신을 점하는 목록,

1019
00:49:55,312 --> 00:49:56,562
그냥 삽입 할 수 있습니다.

1020
00:49:56,562 --> 00:49:58,920

1021
00:49:58,920 --> 00:49:59,680
>> 제이슨 허쉬 호른 : 나는 좋아한다.

1022
00:49:59,680 --> 00:50:00,500
그 의미가 있습니다.

1023
00:50:00,500 --> 00:50:03,390
루프가 종료되면 -

1024
00:50:03,390 --> 00:50:04,800
그것은 여기에 false를 반환합니다 때문입니다.

1025
00:50:04,800 --> 00:50:08,220
그래서 루프가 종료하면, 우리는에있어
아마도 목록의 끝, 또는

1026
00:50:08,220 --> 00:50:10,690
아무것도에 존재하지 않는 경우는 목록의 시작
그것은, 어떤 말과 동일합니다.

1027
00:50:10,690 --> 00:50:12,770
그래서 지금 우리가 삽입 할
여기서 뭔가.

1028
00:50:12,770 --> 00:50:17,380
어떻게 그 코드는 마커스를 보여?

1029
00:50:17,380 --> 00:50:21,600
>> 청중 : 당신은 이미 노드를 얻은 경우
malloc으로 할당, 당신은 말할 수

1030
00:50:21,600 --> 00:50:25,400
new_node -> 다음 NULL 때문에 Equals
그 말에 있어야한다.

1031
00:50:25,400 --> 00:50:27,510
또는 new_node -> 다음에 널 (null)와 같습니다.

1032
00:50:27,510 --> 00:50:27,765
>> 제이슨 허쉬 호른 : OK.

1033
00:50:27,765 --> 00:50:28,190
미안 해요.

1034
00:50:28,190 --> 00:50:35,760
New_node -> 다음 널 (null)과 동일
우리는 끝이기 때문에.

1035
00:50:35,760 --> 00:50:36,460
그게 넣을하지 않습니다

1036
00:50:36,460 --> 00:50:37,710
어떻게 우리가이 목록에 배치해야합니까?

1037
00:50:37,710 --> 00:50:46,130

1038
00:50:46,130 --> 00:50:46,460
오른쪽.

1039
00:50:46,460 --> 00:50:47,750
그건 그냥 동일하게 설정합니다.

1040
00:50:47,750 --> 00:50:50,940
아니 어떻게 우리가 실제로 할
목록에 넣어?

1041
00:50:50,940 --> 00:50:54,170
가리키는 무엇이
목록의 끝?

1042
00:50:54,170 --> 00:50:56,090
>> 청중 : 머리.

1043
00:50:56,090 --> 00:50:57,566
>> 제이슨 허쉬 호른 : 죄송합니다?

1044
00:50:57,566 --> 00:50:59,440
>> 청중 : 머리가 가리키는
리스트의 끝.

1045
00:50:59,440 --> 00:51:01,480
>> 제이슨 허쉬 호른 : 아무것도에서이없는 경우
목록, 헤드가 가리키는

1046
00:51:01,480 --> 00:51:04,170
목록의 끝.

1047
00:51:04,170 --> 00:51:06,920
그래서 작동합니다
제 1 삽입.

1048
00:51:06,920 --> 00:51:09,810
부부가 무엇인지에 대한 경우
목록에있는 것들?

1049
00:51:09,810 --> 00:51:12,470
우리는 설정하지 않고보다
new_node 동일 향한다.

1050
00:51:12,470 --> 00:51:13,790
우리가하고 싶어?

1051
00:51:13,790 --> 00:51:15,610
그래?

1052
00:51:15,610 --> 00:51:16,860
아마 이전.

1053
00:51:16,860 --> 00:51:23,560

1054
00:51:23,560 --> 00:51:24,810
그것은 작동 할 것인가?

1055
00:51:24,810 --> 00:51:28,950

1056
00:51:28,950 --> 00:51:33,050
이전 단지는 것을 기억하라
노드에 대한 포인터.

1057
00:51:33,050 --> 00:51:34,770
그리고 이전 지역 변수입니다.

1058
00:51:34,770 --> 00:51:38,080
그래서이 줄은 로컬 변수를 설정합니다,
이전과 동일하거나

1059
00:51:38,080 --> 00:51:39,380
이 새로운 노드를 가리키는.

1060
00:51:39,380 --> 00:51:41,500
즉, 실제로 두지 않습니다
우리의 목록에서, 그래도.

1061
00:51:41,500 --> 00:51:44,330
우리는 어떻게 우리의 목록에 배치해야합니까?

1062
00:51:44,330 --> 00:51:45,620
Akchar?

1063
00:51:45,620 --> 00:51:46,870
>> 청중 : 나는 당신을 생각
다음 전류>을한다.

1064
00:51:46,870 --> 00:51:50,186

1065
00:51:50,186 --> 00:51:52,550
>> 제이슨 허쉬 호른 : OK.

1066
00:51:52,550 --> 00:51:54,010
CURR -> 다음.

1067
00:51:54,010 --> 00:51:58,768
그래서 다시, 우리는 아래로하고있는 유일한 이유는
여기이며, 어떤 일이 같은 현재합니까?

1068
00:51:58,768 --> 00:51:59,760
>> 청중 : 널 (null)와 같습니다.

1069
00:51:59,760 --> 00:52:01,790
>> 제이슨 허쉬 호른 : 그래서 무엇을
우리가 옆에 널 (null)>을 할 경우 어떻게됩니까?

1070
00:52:01,790 --> 00:52:02,810
우리는 무엇을 얻을 것입니까?

1071
00:52:02,810 --> 00:52:04,060
우리는 세그먼트 오류를​​ 얻을 수 있습니다.

1072
00:52:04,060 --> 00:52:06,600

1073
00:52:06,600 --> 00:52:08,880
>> 청중 : 마 CURR가 null 같습니다.

1074
00:52:08,880 --> 00:52:10,760
>> 제이슨 허쉬 호른 : 그 같은 일이
이전으로하지만,이 때문에

1075
00:52:10,760 --> 00:52:12,820
우리가 설정하고 지역 변수
이 새로운 노드와 동일.

1076
00:52:12,820 --> 00:52:16,680

1077
00:52:16,680 --> 00:52:20,920
이제 우리의 그림으로 돌아 가자
무언가를 삽입.

1078
00:52:20,920 --> 00:52:25,500
우리는 마지막에 삽입한다고 가정 해 봅시다
목록, 바로 여기에있다.

1079
00:52:25,500 --> 00:52:30,010
우리의 현재 포인터가
null로 가리키고 이전 지점

1080
00:52:30,010 --> 00:52:32,800
그 8 가리키는 것.

1081
00:52:32,800 --> 00:52:35,330
그래서 우리는 아비, 업데이트해야합니까?

1082
00:52:35,330 --> 00:52:36,680
>> 청중 : 이전 -> 다음은?

1083
00:52:36,680 --> 00:52:41,980
>> 제이슨 허쉬 호른은 : 이전 -> 다음에 무엇
우리는 업데이트 할 수 있기 때문에 그

1084
00:52:41,980 --> 00:52:44,960
실제로에 삽입합니다
목록의 끝.

1085
00:52:44,960 --> 00:52:47,220
우리는 여전히,하지만, 하나의 버그를
우리는로 실행하는 거라고.

1086
00:52:47,220 --> 00:52:50,090
이 버그는 무엇입니까?

1087
00:52:50,090 --> 00:52:50,790
그래?

1088
00:52:50,790 --> 00:52:53,860
>> 청중 : 그것은 반환 것
이 경우 거짓?

1089
00:52:53,860 --> 00:52:56,380
>> 제이슨 허쉬 호른 : 오,이다
false를 반환하는 것.

1090
00:52:56,380 --> 00:52:57,430
그러나 또 다른 버그가있다.

1091
00:52:57,430 --> 00:52:58,930
그래서 우리는 진정한 반환에 넣어해야합니다.

1092
00:52:58,930 --> 00:53:01,370
>> 청중 : 않습니다 이전 여전히 동일
목록의 맨 위에 널 (null)?

1093
00:53:01,370 --> 00:53:03,645
>> 제이슨 허쉬 호른 : 그래서 이전 계속
맨 처음에 널 (null)와 같습니다.

1094
00:53:03,645 --> 00:53:07,480

1095
00:53:07,480 --> 00:53:10,440
어떻게 우리가 극복 할 수 있습니까?

1096
00:53:10,440 --> 00:53:10,950
그래?

1097
00:53:10,950 --> 00:53:15,280
>> 청중 : 난 당신이 검사를 할 수 있다고 생각합니다
그것의 경우 while 루프를 확인합니다 전에

1098
00:53:15,280 --> 00:53:16,610
빈 목록.

1099
00:53:16,610 --> 00:53:17,000
>> 제이슨 허쉬 호른 : OK.

1100
00:53:17,000 --> 00:53:17,710
그래서 여기에 가자.

1101
00:53:17,710 --> 00:53:18,530
검사를 수행합니다.

1102
00:53:18,530 --> 00:53:19,380
만약 -

1103
00:53:19,380 --> 00:53:20,770
>> 청중 : 그래서 만약 머리
동일은 null 같습니다.

1104
00:53:20,770 --> 00:53:24,300

1105
00:53:24,300 --> 00:53:26,320
>> 제이슨 허쉬 호른 : 만약 머리
동일은 널 (null)과 동일 -

1106
00:53:26,320 --> 00:53:27,790
이 빈 목록의 경우 그것은 우리에게 있습니다.

1107
00:53:27,790 --> 00:53:31,090
>> 다음 당신 : 관객
이렇게 머리가 새와 같습니다.

1108
00:53:31,090 --> 00:53:34,740
>> 제이슨 허쉬 호른 : 머리
new_node 같다?

1109
00:53:34,740 --> 00:53:35,730
그리고 또 우리는 무엇을해야합니까?

1110
00:53:35,730 --> 00:53:37,020
>> 청중 : 그리고 당신은 true를 반환.

1111
00:53:37,020 --> 00:53:37,535
>> 제이슨 허쉬 호른 : 그렇진.

1112
00:53:37,535 --> 00:53:38,785
우리는 한 단계 누락.

1113
00:53:38,785 --> 00:53:41,590

1114
00:53:41,590 --> 00:53:43,710
>> 청중 : New_node 다음
null로 지적한다.

1115
00:53:43,710 --> 00:53:44,570
>> 제이슨 허쉬 호른 : 정확히, 알덴.

1116
00:53:44,570 --> 00:53:46,600
그리고 우리는 true를 반환 할 수 있습니다.

1117
00:53:46,600 --> 00:53:47,560
OK.

1118
00:53:47,560 --> 00:53:51,630
하지만 여전히 일을하는 것이 좋습니다
리스트의 끝에서 오른쪽?

1119
00:53:51,630 --> 00:53:51,950
괜찮아요.

1120
00:53:51,950 --> 00:53:54,450
우리는 여전히 실제로 얻을 수 있습니다
리스트의 끝.

1121
00:53:54,450 --> 00:53:57,870
우리가에있어 경우에 따라서이 코드 벌금입니다
목록의 끝에 몇 가지가 있습니다

1122
00:53:57,870 --> 00:53:59,120
목록에있는 것들?

1123
00:53:59,120 --> 00:54:01,830

1124
00:54:01,830 --> 00:54:02,040
오른쪽?

1125
00:54:02,040 --> 00:54:03,540
우리는 여전히 마커스의 생각을 가지고 있기 때문에.

1126
00:54:03,540 --> 00:54:06,870
우리는이 루프를 종료 할 수 있기 때문에
우리는리스트의 끝에있어.

1127
00:54:06,870 --> 00:54:09,308
그래서 우리는 여전히이 원하는거야
여기에 아래 코드?

1128
00:54:09,308 --> 00:54:10,520
>> 청중 : 네.

1129
00:54:10,520 --> 00:54:11,000
>> 제이슨 허쉬 호른 : 네.

1130
00:54:11,000 --> 00:54:14,190
그리고 우리는이를 변경해야합니까?

1131
00:54:14,190 --> 00:54:15,440
참.

1132
00:54:15,440 --> 00:54:19,580

1133
00:54:19,580 --> 00:54:21,640
않는 좋은 소리
모든 사람이 지금까지?

1134
00:54:21,640 --> 00:54:22,420
누구는이 -

1135
00:54:22,420 --> 00:54:23,480
아비, 당신은 추가 할 수있는 뭔가를해야합니까?

1136
00:54:23,480 --> 00:54:23,920
>> 청중 : 호

1137
00:54:23,920 --> 00:54:25,276
>> 제이슨 허쉬 호른 : OK.

1138
00:54:25,276 --> 00:54:27,010
그래서 우리는 변화의 몇 가지를 만들었습니다.

1139
00:54:27,010 --> 00:54:29,540
우리는 전에이 검사를 만들었어요
빈 목록에 갔다.

1140
00:54:29,540 --> 00:54:31,790
그래서 우리는 빈리스트의 치료를 촬영했습니다.

1141
00:54:31,790 --> 00:54:35,500
그리고 여기에 우리가 삽입 처리했다
리스트의 끝에서 무언가.

1142
00:54:35,500 --> 00:54:38,930
따라서이 while 루프를 가지고가는 것 같아
사이에있는 것들의 관리,

1143
00:54:38,930 --> 00:54:41,920
어딘가에 목록에있는 경우가
상황이 목록에 있습니다.

1144
00:54:41,920 --> 00:54:42,280
>> OK.

1145
00:54:42,280 --> 00:54:44,310
우리는이 프로그램을 다시 실행하자.

1146
00:54:44,310 --> 00:54:50,170

1147
00:54:50,170 --> 00:54:50,755
성공하지.

1148
00:54:50,755 --> 00:54:52,190
>> 청중 : 당신은 그것을하지 않았다.

1149
00:54:52,190 --> 00:54:53,940
>> 제이슨 허쉬 호른 : 아,
나는 그것을하지 않았다.

1150
00:54:53,940 --> 00:54:56,250
좋은 점, 마이클.

1151
00:54:56,250 --> 00:54:57,500
의 연결된 메이크업을 추가 할 수 있습니다.

1152
00:54:57,500 --> 00:55:01,590

1153
00:55:01,590 --> 00:55:04,830
87 행에 오류가있다.

1154
00:55:04,830 --> 00:55:05,420
라인 87.

1155
00:55:05,420 --> 00:55:06,600
알덴이 당신이 내게 준 선이었다.

1156
00:55:06,600 --> 00:55:08,962
무슨 일이야?

1157
00:55:08,962 --> 00:55:10,710
>> 청중 : 그것은 null로 수 있습니다.

1158
00:55:10,710 --> 00:55:11,000
>> 제이슨 허쉬 호른 : 좋음.

1159
00:55:11,000 --> 00:55:11,630
정확히 맞아.

1160
00:55:11,630 --> 00:55:13,290
그것은 NULL이어야합니다.

1161
00:55:13,290 --> 00:55:15,210
다시 한 번 만들어 보자.

1162
00:55:15,210 --> 00:55:17,220
컴파일합니다.

1163
00:55:17,220 --> 00:55:17,890
OK.

1164
00:55:17,890 --> 00:55:19,400
의 세 가지를 삽입 할 수 있습니다.

1165
00:55:19,400 --> 00:55:20,570
삽입에 성공했습니다.

1166
00:55:20,570 --> 00:55:21,660
의 그것을 인쇄 할 수 있습니다.

1167
00:55:21,660 --> 00:55:23,590
아, 단지 우리가 확인할 수 있다면.

1168
00:55:23,590 --> 00:55:25,500
그러나 우리는하지 않은
아직 기능을 인쇄 할 수 있습니다.

1169
00:55:25,500 --> 00:55:27,840
의 다른 뭔가를 입력 할 수 있습니다.

1170
00:55:27,840 --> 00:55:29,090
우리는 무엇을 입력해야합니까?

1171
00:55:29,090 --> 00:55:31,120

1172
00:55:31,120 --> 00:55:31,940
>> 청중 : 세븐.

1173
00:55:31,940 --> 00:55:33,340
>> 제이슨 허쉬 호른 : 세븐?

1174
00:55:33,340 --> 00:55:34,590
>> 청중 : 네.

1175
00:55:34,590 --> 00:55:38,680

1176
00:55:38,680 --> 00:55:39,780
>> 제이슨 허쉬 호른 : 우리는 세그먼트 오류가 있습니다.

1177
00:55:39,780 --> 00:55:43,760
그래서 우리는 하나를 가지고 있지만, 명확하게
두 가지를 얻을 수 없습니다.

1178
00:55:43,760 --> 00:55:45,690
그것은 5:07입니다.

1179
00:55:45,690 --> 00:55:48,370
그래서 우리는이 문제를 디버깅 할 수
3 분.

1180
00:55:48,370 --> 00:55:51,240
하지만 여기에 우리를 떠나려고 해요
와 테이블을 해시로 이동합니다.

1181
00:55:51,240 --> 00:55:54,290
그러나 다시,이 코드에 대한 답변
나는 약간의 당신에게 이메일을 보내드립니다.

1182
00:55:54,290 --> 00:55:55,440
우리는 매우 가까이 있습니다.

1183
00:55:55,440 --> 00:55:58,300
내가보기 엔 파악하는 것이 좋습니다
무슨 일이 일어나고 그것을 해결 있어요.

1184
00:55:58,300 --> 00:56:02,400
그래서 나는 당신에게이 코드를 이메일로 보내 드리겠습니다
플러스 솔루션도 -

1185
00:56:02,400 --> 00:56:03,670
나중에 아마 솔루션입니다.

1186
00:56:03,670 --> 00:56:05,110
우선이 코드.

1187
00:56:05,110 --> 00:56:08,290
>> 나는 우리가 전에하고 싶은 다른 것은
마무리는 우리가 아무것도를 해제하지 않은 것입니다.

1188
00:56:08,290 --> 00:56:10,370
그래서 난 당신을 보여주고 싶은
Valgrind의가처럼 보인다.

1189
00:56:10,370 --> 00:56:14,310
우리는 Valgrind의 경계를 실행하는 경우
우리의 프로그램에. / 링크.

1190
00:56:14,310 --> 00:56:22,540
다시 말하지만,이 슬라이드에 따르면, 우리
어떤 종류의에 Valgrind의 실행해야

1191
00:56:22,540 --> 00:56:26,410
이 경우 옵션,
- 누출 점검 = 전체.

1192
00:56:26,410 --> 00:56:27,660
그럼 Valgrind의를 작성할 수
- 누출 점검 = 전체.

1193
00:56:27,660 --> 00:56:31,910

1194
00:56:31,910 --> 00:56:35,080
그래서이 Valgrind의를 실행합니다
우리의 프로그램에.

1195
00:56:35,080 --> 00:56:37,000
그리고 지금은 프로그램이 실제로 실행됩니다.

1196
00:56:37,000 --> 00:56:40,190
그래서 우리는 단지처럼 실행하는거야
이전에, 안으로 뭔가를 집어

1197
00:56:40,190 --> 00:56:40,830
나는 3에 넣을거야.

1198
00:56:40,830 --> 00:56:41,790
그 작동합니다.

1199
00:56:41,790 --> 00:56:43,202
내가 뭔가에 넣어하려고하지 않을 것이다
우리는 갈거야 다른 사람 때문에

1200
00:56:43,202 --> 00:56:44,710
이 경우 세그먼트의 거짓을 얻을.

1201
00:56:44,710 --> 00:56:46,700
그래서 그만 둘거야.

1202
00:56:46,700 --> 00:56:50,160
>> 그리고 지금 당신은 여기 아래 참조
누출 및 힙 요약.

1203
00:56:50,160 --> 00:56:52,310
이들은 좋은 것들 그
당신은 체크 아웃 할.

1204
00:56:52,310 --> 00:56:56,780
그래서 힙 요약 -이 말한다, 사용
출구에서 - 하나의 블록에 8 바이트.

1205
00:56:56,780 --> 00:56:58,370
즉, 하나의 블록은
노드 우리는 malloc으로 할당.

1206
00:56:58,370 --> 00:57:02,230
마이클, 당신은 노드가 8 개입니다 전에 말했다
그것은 정수가 물기 때문에

1207
00:57:02,230 --> 00:57:02,680
및 포인터.

1208
00:57:02,680 --> 00:57:04,550
그래서 우리의 노드입니다.

1209
00:57:04,550 --> 00:57:08,170
그리고, 그것은 우리의 malloc를 사용 말한다
일곱 번 우리는 해제

1210
00:57:08,170 --> 00:57:08,940
뭔가 여섯 번.

1211
00:57:08,940 --> 00:57:13,680
그러나 우리는 자유로운 호출되지 않습니다, 그래서 나는 아니오
이 얘기를 무슨 생각.

1212
00:57:13,680 --> 00:57:18,490
>> 그러나 말을 충분이 때
프로그램이 실행 때 malloc이 호출되고

1213
00:57:18,490 --> 00:57:20,330
다른 장소에서 우리
에 대해 걱정할 필요가 없습니다.

1214
00:57:20,330 --> 00:57:22,460
그래서 malloc에​​ 아마 불렀다
어떤 장소에서.

1215
00:57:22,460 --> 00:57:24,480
우리는 어디에서 고민 할 필요가 없습니다.

1216
00:57:24,480 --> 00:57:26,240
그러나 이것은 정말 우리입니다.

1217
00:57:26,240 --> 00:57:27,380
첫 번째 라인은 우리입니다.

1218
00:57:27,380 --> 00:57:28,320
우리는 블록을 떠났다.

1219
00:57:28,320 --> 00:57:30,330
그리고 당신은 여기에서 볼 수 있습니다
누출 요약.

1220
00:57:30,330 --> 00:57:31,950
아직도 도달 -

1221
00:57:31,950 --> 00:57:32,930
한 블록에있는 8 바이트.

1222
00:57:32,930 --> 00:57:34,100
즉, 해당 메모리를 의미합니다 -

1223
00:57:34,100 --> 00:57:35,730
우리는 메모리를 유출했다.

1224
00:57:35,730 --> 00:57:37,570
확실히 손실 -

1225
00:57:37,570 --> 00:57:38,770
뭔가가 영원히 손실됩니다.

1226
00:57:38,770 --> 00:57:40,590
일반적으로, 당신은하지 않습니다
거기에 무엇을 참조하십시오.

1227
00:57:40,590 --> 00:57:44,780
아직 도달 일반적이다
당신이 원하는거야 어디 물건을 볼 수 있습니다

1228
00:57:44,780 --> 00:57:48,900
어떤 코드가해야 볼 볼 수 있습니다
해제하지만 당신은 무료로 잊고있다.

1229
00:57:48,900 --> 00:57:53,170
>> 그리고 이것은, 케이스 아니라면
우리는 무료로 모든 것을 한 경우에,

1230
00:57:53,170 --> 00:57:54,360
우리는 그것을 확인할 수 있습니다.

1231
00:57:54,360 --> 00:57:57,330
그냥 프로그램을 실행하자
아무것도 참을 수 없어.

1232
00:57:57,330 --> 00:57:59,800
당신은 출구에 사용 여기에 아래로 볼 수 있습니다 -

1233
00:57:59,800 --> 00:58:01,310
제로 블록에 0 바이트.

1234
00:58:01,310 --> 00:58:06,310
즉, 우리가 아무 것도 남은 것 없음을 의미합니다
이 프로그램은 종료 할 때.

1235
00:58:06,310 --> 00:58:12,090
그래서 pset6에 켜기 전에, Valgrind의 실행
그리고 당신이하지 않아도 확인

1236
00:58:12,090 --> 00:58:15,310
모든 메모리는 프로그램에서 누수.

1237
00:58:15,310 --> 00:58:17,910
당신은 Valgrind의 어떤 질문이 있으면,
다가 주시기 바랍니다.

1238
00:58:17,910 --> 00:58:18,700
그러나 이것은 당신이 그것을 사용하는 방법입니다.

1239
00:58:18,700 --> 00:58:20,890
아주 간단한 - 만약 당신이 있는지 확인
출구에서 사용이 -

1240
00:58:20,890 --> 00:58:22,270
모든 블록의 모든 바이트.

1241
00:58:22,270 --> 00:58:27,890

1242
00:58:27,890 --> 00:58:29,580
>> 그래서 우리는 삽입 노드에서 작업을했다.

1243
00:58:29,580 --> 00:58:33,840
여기 두 개의 다른 기능을 가지고 -
노드와 노드를 무료로 인쇄 할 수 있습니다.

1244
00:58:33,840 --> 00:58:37,780
또, 이들은 함수입니다
연습을 위해 좋은 것

1245
00:58:37,780 --> 00:58:40,990
그들은 당신을뿐만 아니라 도움이 될 것입니다 때문에
이러한 샘플 연습뿐만 아니라,

1246
00:58:40,990 --> 00:58:42,180
문제에 설정합니다.

1247
00:58:42,180 --> 00:58:44,230
그들은 볼거리에 꽤 밀접에 매핑
당신은에해야 할 것입니다

1248
00:58:44,230 --> 00:58:45,010
문제는 설정.

1249
00:58:45,010 --> 00:58:47,640
하지만 확인 하시겠습니까
우리는 모두에 터치합니다.

1250
00:58:47,640 --> 00:58:50,400
해시 테이블은 또한 중요하다
우리는이 부분에서 무슨 일을하는지

1251
00:58:50,400 --> 00:58:51,980
주 - 또는 문제 세트.

1252
00:58:51,980 --> 00:58:55,200
>> 그래서 우리는 부분을 마무리 할거야
해시 테이블에 대해 이야기.

1253
00:58:55,200 --> 00:58:58,140
당신이주의하는 경우에 내가 만든
작은 해시 테이블.

1254
00:58:58,140 --> 00:59:00,020
즉, 우리가 이야기하고있는 것이 아니다
그러나, 약.

1255
00:59:00,020 --> 00:59:03,540
우리는 다른 얘기
해시 테이블의 타입.

1256
00:59:03,540 --> 00:59:07,300
그리고 그 핵심, 해시 테이블에
에 불과하다

1257
00:59:07,300 --> 00:59:08,860
어레이 플러스 해시 함수.

1258
00:59:08,860 --> 00:59:11,150
우리는 단지에 조금만 이야기 할 것입니다
반드시 모두가 무엇을 이해합니다

1259
00:59:11,150 --> 00:59:12,110
해시 기능입니다.

1260
00:59:12,110 --> 00:59:15,420
그리고 나는 것을 지금 말하는거야
두 가지 이상의 아무것도 -

1261
00:59:15,420 --> 00:59:18,590
배열 및 해시 함수.

1262
00:59:18,590 --> 00:59:20,716
그리고 여기 단계까지입니다
어떤이 운영하고 있습니다.

1263
00:59:20,716 --> 00:59:31,560

1264
00:59:31,560 --> 00:59:32,810
>> 우리의 배열이있다.

1265
00:59:32,810 --> 00:59:38,460

1266
00:59:38,460 --> 00:59:39,460
우리의 기능이있다.

1267
00:59:39,460 --> 00:59:43,180
특히, 해쉬 함수가 필요
이와 함께 몇 가지 작업을 수행.

1268
00:59:43,180 --> 00:59:45,040
내가 특별히 말할거야
에 대해이 문제를 설정합니다.

1269
00:59:45,040 --> 00:59:46,450
아마 것
문자열을 가지고.

1270
00:59:46,450 --> 00:59:50,570

1271
00:59:50,570 --> 00:59:51,770
그리고 무엇 반환 할거야?

1272
00:59:51,770 --> 00:59:52,640
데이터 유형을?

1273
00:59:52,640 --> 00:59:54,260
알덴?

1274
00:59:54,260 --> 00:59:55,760
귀하 해시 함수 반환?

1275
00:59:55,760 --> 00:59:58,760
정수입니다.

1276
00:59:58,760 --> 01:00:01,700
그래서 이것은 무엇 해시
테이블의 구성은 -

1277
01:00:01,700 --> 01:00:05,430
어레이의 형태로 나타난
그리고 해시 함수.

1278
01:00:05,430 --> 01:00:06,010
그것은 어떻게 작동?

1279
01:00:06,010 --> 01:00:07,300
그것은 세 단계로 작동합니다.

1280
01:00:07,300 --> 01:00:08,740
우리는 그에게 키를 제공합니다.

1281
01:00:08,740 --> 01:00:11,470
이 경우, 우리는 그것을 문자열을 줄 것이다.

1282
01:00:11,470 --> 01:00:18,140
우리는 단계 당 하나의 해시 함수를 호출
키에 우리는 가치를 얻을.

1283
01:00:18,140 --> 01:00:20,310
>> 특히, 우리는 말할 것
우리는 정수를 얻을.

1284
01:00:20,310 --> 01:00:25,630
즉, 정수, 매우 구체적인있다
그 정수가 될 수있는 한계.

1285
01:00:25,630 --> 01:00:28,880
이 예에서, 우리의 배열
크기 세입니다.

1286
01:00:28,880 --> 01:00:32,330
그래서 정수는 어떤 숫자가 될 수 있습니다.

1287
01:00:32,330 --> 01:00:35,970
유효 값의 범위는 무엇입니까
그 정수, 이것의 반환 형식

1288
01:00:35,970 --> 01:00:37,220
기능을 해시?

1289
01:00:37,220 --> 01:00:40,440

1290
01:00:40,440 --> 01:00:42,110
제로, 하나, 둘.

1291
01:00:42,110 --> 01:00:46,060
해시 함수의 포인트입니다
배열의 위치를​​ 알아낼

1292
01:00:46,060 --> 01:00:47,790
우리의 키는 것입니다.

1293
01:00:47,790 --> 01:00:51,290
만 세 가지가 있습니다
여기에 위치 -

1294
01:00:51,290 --> 01:00:52,130
0, 1, 2.

1295
01:00:52,130 --> 01:00:55,360
따라서이 기능은 더 나은 반환
0, 1, 2.

1296
01:00:55,360 --> 01:00:58,740
이 배열의 일부 유효 indice.

1297
01:00:58,740 --> 01:01:02,770
>> 그리고,이 반환 위치에 따라
당신은 개방이 배열을 볼 수 있습니다

1298
01:01:02,770 --> 01:01:03,730
값을 괄호.

1299
01:01:03,730 --> 01:01:05,800
우리가 키를 넣어 곳이다.

1300
01:01:05,800 --> 01:01:11,280
그래서 우리는 호박을 던져,
우리는 제로를 얻을.

1301
01:01:11,280 --> 01:01:15,540
배열 브래킷 0에서, 우리는 호박을 넣어.

1302
01:01:15,540 --> 01:01:21,070
우리는 우리가 하나를 얻을, 고양이 던져.

1303
01:01:21,070 --> 01:01:24,110
우리는 하나에 고양이를 넣어.

1304
01:01:24,110 --> 01:01:25,480
우리는 거미에 넣어.

1305
01:01:25,480 --> 01:01:26,710
우리는 두 가지를 얻을.

1306
01:01:26,710 --> 01:01:30,200
우리는 배열 브래킷 두 가지에 거미를 넣어.

1307
01:01:30,200 --> 01:01:32,300
너무 좋은 것입니다 경우
그것은 그런 식으로 일했다.

1308
01:01:32,300 --> 01:01:35,570
그러나 불행하게도, 우리는 볼 수 있습니다로
그것은 조금 더 복잡합니다.

1309
01:01:35,570 --> 01:01:37,570
>> 우리는이 질문으로 시작하기 전에
약이 기본

1310
01:01:37,570 --> 01:01:38,820
해시 테이블의 셋업?

1311
01:01:38,820 --> 01:01:49,050

1312
01:01:49,050 --> 01:01:51,940
이것이 바로의 이미지입니다
우리는 보드에 그린 그림을.

1313
01:01:51,940 --> 01:01:55,420
하지만 이후 우리는 내가 그것을 칠판에 그린
또한 그것으로 이동하지 않을거야.

1314
01:01:55,420 --> 01:02:00,430
기본적으로 키, 마법의 블랙 박스 -
또는이 경우, 청록색 상자 -의

1315
01:02:00,430 --> 01:02:02,410
해시 함수는 양동이에 넣습니다.

1316
01:02:02,410 --> 01:02:04,690
이 예에서 우리는있어
이름을 참을 수 없어.

1317
01:02:04,690 --> 01:02:07,880
우리는 관련된 전화를 옮기고
버킷에있는 이름의 수.

1318
01:02:07,880 --> 01:02:10,430
하지만 당신은 잘 할 수 단지
양동이에 이름을 넣어.

1319
01:02:10,430 --> 01:02:12,950
>> 이것은 무엇을 단지 사진입니다
우리는 보드에 그린.

1320
01:02:12,950 --> 01:02:14,460
우리는하지만, 잠재적 인 함정이있다.

1321
01:02:14,460 --> 01:02:17,470
그리고 두 사람은 특히이있다
내가 가서하려는 슬라이드.

1322
01:02:17,470 --> 01:02:20,230
첫 번째에 관한 것입니다
해시 함수.

1323
01:02:20,230 --> 01:02:22,620
그래서, 질문을 어떻게
좋은 해시 함수를 무엇입니까?

1324
01:02:22,620 --> 01:02:24,220
나는 두 개의 답변을 제공합니다.

1325
01:02:24,220 --> 01:02:26,630
첫 번째는 결정의 것입니다.

1326
01:02:26,630 --> 01:02:29,660
해쉬 함수의 문맥에서,
이것은 무엇을 의미합니까?

1327
01:02:29,660 --> 01:02:37,840

1328
01:02:37,840 --> 01:02:39,282
예?

1329
01:02:39,282 --> 01:02:42,850
>> 청중 : 그것은 찾을 수 있습니다
일정 시간의 인덱스?

1330
01:02:42,850 --> 01:02:43,810
>> 제이슨 허쉬 호른 : 그
그것은 무엇을 의미하지 않습니다.

1331
01:02:43,810 --> 01:02:44,725
하지만 그건 좋은 생각입니다.

1332
01:02:44,725 --> 01:02:46,100
다른 사람이 추측이
이 무엇을 의미하는지에?

1333
01:02:46,100 --> 01:02:47,780
즉, 좋은 해시 함수
결정적?

1334
01:02:47,780 --> 01:02:48,280
애니?

1335
01:02:48,280 --> 01:02:51,680
>> AUDIENCE : 키만을 매핑 할 수있는
해시 테이블에있는 하나의 장소에.

1336
01:02:51,680 --> 01:02:53,070
>> 제이슨 허쉬 호른 : 때문입니다
정확히 맞아.

1337
01:02:53,070 --> 01:02:57,430
당신이 호박에 넣어 때마다,
항상 0을 반환합니다.

1338
01:02:57,430 --> 01:03:01,660
당신은 호박과 해시에 넣어 경우
함수는 0을 반환하지만이

1339
01:03:01,660 --> 01:03:06,060
뭔가를 반환 확률
0보다 다른 더 큰 -

1340
01:03:06,060 --> 01:03:09,280
어쩌면 때때로 하나를 반환 할 수 있습니다
또는 두 개의 다른 시간 -

1341
01:03:09,280 --> 01:03:11,100
그건 좋은 해시 함수가 아닙니다.

1342
01:03:11,100 --> 01:03:11,800
당신은 정확히 맞아.

1343
01:03:11,800 --> 01:03:15,680
귀하의 해시 함수를 반환해야합니다
이 경우 똑같은 정수,,

1344
01:03:15,680 --> 01:03:17,780
똑같은 문자열입니다.

1345
01:03:17,780 --> 01:03:22,210
>> 아마 똑같은 정수를 반환
똑같은 문자열

1346
01:03:22,210 --> 01:03:24,430
에 관계없이 총액.

1347
01:03:24,430 --> 01:03:27,980
그러나이 경우는 아직
결정하기 때문에 여러 가지

1348
01:03:27,980 --> 01:03:29,350
같은 값에 매핑됩니다.

1349
01:03:29,350 --> 01:03:30,170
괜찮아요.

1350
01:03:30,170 --> 01:03:32,615
한 사람 만이있는 한
주어진 입력에 대한 출력.

1351
01:03:32,615 --> 01:03:35,630

1352
01:03:35,630 --> 01:03:36,350
>> OK.

1353
01:03:36,350 --> 01:03:38,340
두 번째 문제는 그것이
유효한 인덱스를 반환합니다.

1354
01:03:38,340 --> 01:03:40,220
우리는 일찍왔다.

1355
01:03:40,220 --> 01:03:41,860
이 해시 함수 -

1356
01:03:41,860 --> 01:03:43,710
소년 오 -

1357
01:03:43,710 --> 01:03:46,840
해시 함수는해야
유효한 인덱스를 반환합니다.

1358
01:03:46,840 --> 01:03:47,740
그래서 말 -

1359
01:03:47,740 --> 01:03:48,990
이제 다시이 예제로 돌아가 보자.

1360
01:03:48,990 --> 01:03:52,580

1361
01:03:52,580 --> 01:03:57,540
내 해시 함수는 카운트 업
단어의 문자.

1362
01:03:57,540 --> 01:03:58,380
즉, 해시 함수이다.

1363
01:03:58,380 --> 01:03:59,740
그리고 그 정수를 반환합니다.

1364
01:03:59,740 --> 01:04:04,280
나는 단어가 있다면, 그건
하나를 반환 할 것.

1365
01:04:04,280 --> 01:04:06,900
그리고 바로 여기에 넣어 것입니다.

1366
01:04:06,900 --> 01:04:09,430
내가 단어 박쥐에 넣으면?

1367
01:04:09,430 --> 01:04:11,310
이 세 가지를 반환하는 것입니다.

1368
01:04:11,310 --> 01:04:12,560
어디 박쥐 가는가?

1369
01:04:12,560 --> 01:04:18,730

1370
01:04:18,730 --> 01:04:19,750
>> 그것은 맞지 않습니다.

1371
01:04:19,750 --> 01:04:21,000
그러나 그것은 어디 갈 필요가있다.

1372
01:04:21,000 --> 01:04:23,340
이것은 결국 내 해시 테이블이며,
항상 어딘가로 이동합니다.

1373
01:04:23,340 --> 01:04:24,590
어디 박쥐 가야하나요?

1374
01:04:24,590 --> 01:04:28,020

1375
01:04:28,020 --> 01:04:28,710
어떤 생각을?

1376
01:04:28,710 --> 01:04:29,450
추측?

1377
01:04:29,450 --> 01:04:30,280
좋은 추측?

1378
01:04:30,280 --> 01:04:31,220
>> 청중 : 제로.

1379
01:04:31,220 --> 01:04:32,120
>> 제이슨 허쉬 호른 : 왜 제로?

1380
01:04:32,120 --> 01:04:35,990
>> 청중 : 때문에 세
모듈 세 제로?

1381
01:04:35,990 --> 01:04:38,620
>> 제이슨 허쉬 호른 : 세
모듈 세은 0이다.

1382
01:04:38,620 --> 01:04:40,810
즉, 좋은 생각이다,
그 맞습니다.

1383
01:04:40,810 --> 01:04:43,870
그래서이 경우에는해야
아마 0으로 이동합니다.

1384
01:04:43,870 --> 01:04:51,080
그래서 좋은 방법 보장하는이 해시
기능은 유효한 인덱스를 반환한다

1385
01:04:51,080 --> 01:04:54,580
테이블의 크기로 나눈 나머지하기.

1386
01:04:54,580 --> 01:04:57,360
당신은에 의해 어떤이 반환을 모듈로하는 경우
세 가지, 당신은 항상받을거야

1387
01:04:57,360 --> 01:05:00,930
0, 1, 및 둘 사이의 무언가.

1388
01:05:00,930 --> 01:05:05,160
그리고 이것은 항상 일곱을 반환하고, 경우
당신은 항상 세 가지로 나눈 나머지, 당신이있어

1389
01:05:05,160 --> 01:05:06,030
항상 같은 일을 얻을 것.

1390
01:05:06,030 --> 01:05:09,270
>> 그래서 아직 결정의
당신은 모듈로합니다.

1391
01:05:09,270 --> 01:05:11,420
하지만 그 보장합니다 당신에게 그
무언가를 결코 -

1392
01:05:11,420 --> 01:05:12,940
잘못된 산업.

1393
01:05:12,940 --> 01:05:16,840
일반적으로,이 모듈이 발생한다
당신의 해시 함수 내부.

1394
01:05:16,840 --> 01:05:18,240
그래서 당신은 이것에 대해 걱정할 필요가 없습니다.

1395
01:05:18,240 --> 01:05:20,555
당신은 다음을 확인 할 수 있습니다
이 유효한 indice입니다.

1396
01:05:20,555 --> 01:05:23,700

1397
01:05:23,700 --> 01:05:26,700
여기에 대한 질문
잠재적 인 함정?

1398
01:05:26,700 --> 01:05:36,590

1399
01:05:36,590 --> 01:05:39,060
>> OK.

1400
01:05:39,060 --> 01:05:40,290
그리고 거기에 우리가 간다.

1401
01:05:40,290 --> 01:05:42,890
다음 잠재적 인 함정 및
이것은 큰 문제입니다.

1402
01:05:42,890 --> 01:05:46,880
어떤 경우에는 두 개의 키지도
동일한 값?

1403
01:05:46,880 --> 01:05:49,350
따라서이 문제를 처리하는 방법은 두 가지가 있습니다.

1404
01:05:49,350 --> 01:05:53,140

1405
01:05:53,140 --> 01:05:56,020
첫 번째는 선형이라고
제가하는 프로빙

1406
01:05:56,020 --> 01:05:57,300
이상 갈 수 없습니다.

1407
01:05:57,300 --> 01:06:01,120
하지만 당신은 잘 알고 있어야하는 방법
그 작품과 그 것입니다.

1408
01:06:01,120 --> 01:06:05,610
>> 내가 가서려고 두 번째
그 많은 하나이기 때문에

1409
01:06:05,610 --> 01:06:08,290
사람들은 아마 결정 끝날 것
자신의 문제 세트에 사용할 수 있습니다.

1410
01:06:08,290 --> 01:06:09,820
물론, 당신은 필요가 없습니다.

1411
01:06:09,820 --> 01:06:15,280
그러나 문제 세트, 많은 사람들이
해시 테이블을 생성하기 위해 선택하는 경향

1412
01:06:15,280 --> 01:06:17,950
구현하기 위해 별도의 체인과 함께
그들의 사전.

1413
01:06:17,950 --> 01:06:21,390
그래서 우리는 그것이 무엇을 의미하는지에 갈거야
로 해쉬 테이블을 작성

1414
01:06:21,390 --> 01:06:23,890
별도의 체인.

1415
01:06:23,890 --> 01:06:26,260
>> 그래서 호박에 넣어.

1416
01:06:26,260 --> 01:06:29,560
그것은 0을 반환합니다.

1417
01:06:29,560 --> 01:06:31,410
그리고 여기에 호박을 넣어.

1418
01:06:31,410 --> 01:06:35,880

1419
01:06:35,880 --> 01:06:37,930
그럼 난에 넣어 -

1420
01:06:37,930 --> 01:06:39,922
다른 할로윈 테마 것은 무엇입니까?

1421
01:06:39,922 --> 01:06:42,200
>> 청중 : 사탕.

1422
01:06:42,200 --> 01:06:42,770
>> 제이슨 허쉬 호른 : 사탕!

1423
01:06:42,770 --> 01:06:43,910
즉, 좋은 하나입니다.

1424
01:06:43,910 --> 01:06:47,760
나는 사탕, 사탕에 넣어
또한 저에게 영을 준다.

1425
01:06:47,760 --> 01:06:49,350
어떻게해야합니까?

1426
01:06:49,350 --> 01:06:51,940
어떤 아이디어?

1427
01:06:51,940 --> 01:06:53,940
당신은 모든 종류의 알고 있기 때문에
별도의 무엇 체인입니다.

1428
01:06:53,940 --> 01:06:55,190
그래서 어떤 아이디어가 무엇을 할 수?

1429
01:06:55,190 --> 01:06:58,170

1430
01:06:58,170 --> 01:06:59,110
그래.

1431
01:06:59,110 --> 01:07:03,810
>> 청중 : 문자열을 퍼팅
실제로 해시 테이블.

1432
01:07:03,810 --> 01:07:08,910
>> 제이슨 허쉬 호른 : 그래서 우리가 갈거야
여기에 좋은 생각을 그립니다.

1433
01:07:08,910 --> 01:07:09,340
OK.

1434
01:07:09,340 --> 01:07:12,290
>> 청중 : 해시 테이블에게 있으
[청취]

1435
01:07:12,290 --> 01:07:16,640
를 가리키는 포인터
목록의 시작.

1436
01:07:16,640 --> 01:07:20,930
그리고 호박은 첫 번째 값이 될 수있다
링크 된 목록과 사탕에있을

1437
01:07:20,930 --> 01:07:22,800
링크 된 목록의 두 번째 값입니다.

1438
01:07:22,800 --> 01:07:23,420
>> 제이슨 허쉬 호른 : OK.

1439
01:07:23,420 --> 01:07:24,670
마커스는, 그 뛰어난했다.

1440
01:07:24,670 --> 01:07:26,160
나는 그것을 무너 뜨리는거야.

1441
01:07:26,160 --> 01:07:28,890
마커스는 할 말을하지
호박을 덮어 씁니다.

1442
01:07:28,890 --> 01:07:30,660
즉, 나쁜 것입니다.

1443
01:07:30,660 --> 01:07:33,640
다른 곳에서 사탕을 넣지 마십시오.

1444
01:07:33,640 --> 01:07:35,390
우리는 0에 모두 넣어 것입니다.

1445
01:07:35,390 --> 01:07:37,770
하지만 우리가 다루는거야
제로에 이르렀

1446
01:07:37,770 --> 01:07:39,395
0에서 목록을 작성.

1447
01:07:39,395 --> 01:07:42,430
그리고 우리는 목록을 만들거야
제로에 매핑 된 모든.

1448
01:07:42,430 --> 01:07:47,960
그리고 우리가 만들 배운 가장 좋은 방법
성장하고 축소 할 수 있습니다 목록

1449
01:07:47,960 --> 01:07:49,840
동적 범위가 아닌
또 다른 배열입니다.

1450
01:07:49,840 --> 01:07:51,510
그래서하지 다차원 배열.

1451
01:07:51,510 --> 01:07:54,080
그러나 단지 연결리스트를 만들 수 있습니다.

1452
01:07:54,080 --> 01:07:55,330
>> 그래서 그가 제안 -

1453
01:07:55,330 --> 01:07:57,950

1454
01:07:57,950 --> 01:07:59,200
나는 새를 얻을거야 -

1455
01:07:59,200 --> 01:08:15,380

1456
01:08:15,380 --> 01:08:19,689
포인터와 배열을 만들 수 있습니다
포인터의 배열.

1457
01:08:19,689 --> 01:08:20,580
OK.

1458
01:08:20,580 --> 01:08:24,180
어떤 아이디어 나 힌트 어떤 유형
이 포인터이어야한다?

1459
01:08:24,180 --> 01:08:26,290
마커스?

1460
01:08:26,290 --> 01:08:27,250
>> 청중 :에 대한 포인터 -

1461
01:08:27,250 --> 01:08:28,609
>> 제이슨 허쉬 호른 : 당신 때문에
연결리스트는 이렇게 말했다 -

1462
01:08:28,609 --> 01:08:29,520
>> 청중 : 노드 포인터?

1463
01:08:29,520 --> 01:08:30,670
>> 제이슨 허쉬 호른 : 노드 포인터.

1464
01:08:30,670 --> 01:08:32,830
만약에 우리의 연결에있는 것들
목록 노드는 그들이있다

1465
01:08:32,830 --> 01:08:34,370
노드 포인터이어야한다.

1466
01:08:34,370 --> 01:08:35,939
그리고 그들은 처음에 어떻게 같을 수 있습니까?

1467
01:08:35,939 --> 01:08:36,990
>> 청중 : 널.

1468
01:08:36,990 --> 01:08:38,240
>> 제이슨 허쉬 호른 : 널.

1469
01:08:38,240 --> 01:08:44,540

1470
01:08:44,540 --> 01:08:46,080
그래서 우리의 비어있는 일이있다.

1471
01:08:46,080 --> 01:08:47,170
호박 0을 반환합니다.

1472
01:08:47,170 --> 01:08:48,569
우리는 무엇을해야합니까?

1473
01:08:48,569 --> 01:08:49,609
그것을 통해 저를 걸어?

1474
01:08:49,609 --> 01:08:50,810
사실, 마커스는 이미 준.

1475
01:08:50,810 --> 01:08:52,439
다른 사람은 그것을 통해 저를 걷는다.

1476
01:08:52,439 --> 01:08:54,760
우리는 무엇을 할 때 우리 -

1477
01:08:54,760 --> 01:08:56,609
이것은 매우 유사
우리는 그냥 뭘하고 있었는지.

1478
01:08:56,609 --> 01:08:57,396
아비.

1479
01:08:57,396 --> 01:08:59,090
>> 청중 : 나는 생각을하는거야.

1480
01:08:59,090 --> 01:09:01,250
그래서 당신은 사탕을 얻을 때.

1481
01:09:01,250 --> 01:09:01,640
>> 제이슨 허쉬 호른 : 네.

1482
01:09:01,640 --> 01:09:03,120
음, 우리는 호박을 얻었다.

1483
01:09:03,120 --> 01:09:03,870
이제 우리의 첫 번째를 얻을 수 있습니다.

1484
01:09:03,870 --> 01:09:04,324
우리는 호박을 얻었다.

1485
01:09:04,324 --> 01:09:04,779
>> 청중 : OK.

1486
01:09:04,779 --> 01:09:05,880
호박 0을 반환합니다.

1487
01:09:05,880 --> 01:09:08,770
그래서 당신은에 넣어.

1488
01:09:08,770 --> 01:09:10,810
아니면 실제로, 당신은 넣어
링크 된 목록.

1489
01:09:10,810 --> 01:09:13,550
>> 제이슨 허쉬 호른 : 우리는 어떻게 할
연결리스트에 넣어?

1490
01:09:13,550 --> 01:09:15,479
>> 청중 : 아, 실제 구문?

1491
01:09:15,479 --> 01:09:16,240
>> 제이슨 허쉬 호른 : 그냥 산책 -

1492
01:09:16,240 --> 01:09:16,740
더 이상 말을.

1493
01:09:16,740 --> 01:09:19,310
우리는 무엇을해야합니까?

1494
01:09:19,310 --> 01:09:22,100
>> 청중 : 당신은 단지 삽입
그 첫 번째 노드로.

1495
01:09:22,100 --> 01:09:22,675
>> 제이슨 허쉬 호른 : OK.

1496
01:09:22,675 --> 01:09:29,069
그래서 우리는 우리의 노드, 호박이 있습니다.

1497
01:09:29,069 --> 01:09:31,560
그리고 지금 내가 어떻게 삽입합니까?

1498
01:09:31,560 --> 01:09:34,590

1499
01:09:34,590 --> 01:09:37,090
>> 청중 : 당신은 지정
포인터에 그것.

1500
01:09:37,090 --> 01:09:37,970
>> 제이슨 허쉬 호른 : 어떤 포인터?

1501
01:09:37,970 --> 01:09:39,620
>> 청중 : 제로의 포인터.

1502
01:09:39,620 --> 01:09:41,420
>> 제이슨 허쉬 호른 : 어디
이 점은 무엇입니까?

1503
01:09:41,420 --> 01:09:42,810
>> 청중 : 지금 NULL로.

1504
01:09:42,810 --> 01:09:43,529
>> 제이슨 허쉬 호른 : 음,
NULL을 가리키는 것.

1505
01:09:43,529 --> 01:09:44,499
하지만 호박에 걸었습니다.

1506
01:09:44,499 --> 01:09:46,053
어디 그것을 가리켜 야?

1507
01:09:46,053 --> 01:09:46,880
>> 청중 : 호박합니다.

1508
01:09:46,880 --> 01:09:47,399
>> 제이슨 허쉬 호른 : 호박에.

1509
01:09:47,399 --> 01:09:48,760
정확히.

1510
01:09:48,760 --> 01:09:50,010
그래서이 호박을 가리 킵니다.

1511
01:09:50,010 --> 01:09:52,500

1512
01:09:52,500 --> 01:09:54,250
어디이 포인터는 않습니다
호박 포인트?

1513
01:09:54,250 --> 01:09:57,986

1514
01:09:57,986 --> 01:09:58,340
에

1515
01:09:58,340 --> 01:09:58,590
>> 청중 : 널.

1516
01:09:58,590 --> 01:09:59,210
>> 제이슨 허쉬 호른 : null로.

1517
01:09:59,210 --> 01:10:00,460
정확히.

1518
01:10:00,460 --> 01:10:03,570

1519
01:10:03,570 --> 01:10:05,140
그래서 우리는 뭔가를 삽입
링크 된 목록에.

1520
01:10:05,140 --> 01:10:07,210
우리는 단지이 작업을 수행하기 위해이 코드를 썼다.

1521
01:10:07,210 --> 01:10:09,520
거의 우리는 거의 그것을 가지고
완전히 금이.

1522
01:10:09,520 --> 01:10:10,790
이제 우리는 사탕을 삽입합니다.

1523
01:10:10,790 --> 01:10:13,480
우리의 캔디는 0이.

1524
01:10:13,480 --> 01:10:16,100
그래서 우리는 사탕과 함께 무엇을해야합니까?

1525
01:10:16,100 --> 01:10:18,790
>> 청중 : 그것은 여부에 따라 달라집니다
우리는 그것을 정렬 할 노력하고 있지.

1526
01:10:18,790 --> 01:10:19,640
>> 제이슨 허쉬 호른 : 때문입니다
정확히 맞아.

1527
01:10:19,640 --> 01:10:21,070
이에 따라 달라집니다 여부
우리는 그것을 정렬 할 노력 중입니다.

1528
01:10:21,070 --> 01:10:22,660
의 우리가하지 않은 가정하자
그것을 정렬 할 것.

1529
01:10:22,660 --> 01:10:24,880
>> 청중 : 그럼, 우리가 설명하고있는 바와 같이
전에, 그것은 그냥 넣어 간단한 것

1530
01:10:24,880 --> 01:10:28,590
바로 처음에 너무 포인터
사탕 제로 지점에서.

1531
01:10:28,590 --> 01:10:29,020
>> 제이슨 허쉬 호른 : OK.

1532
01:10:29,020 --> 01:10:29,380
잠깐만.

1533
01:10:29,380 --> 01:10:30,630
내가 바로 여기에 사탕을 만들 수 있습니다.

1534
01:10:30,630 --> 01:10:34,030

1535
01:10:34,030 --> 01:10:35,150
그래서이 포인터 -

1536
01:10:35,150 --> 01:10:37,590
>> 청중 : 네, 지금해야
사탕을 가리키는 될 수있다.

1537
01:10:37,590 --> 01:10:40,580
그런 다음 포인터에서이
호박에 사탕 포인트.

1538
01:10:40,580 --> 01:10:43,140

1539
01:10:43,140 --> 01:10:44,560
>> 제이슨 허쉬 호른 : 그 마음에 드 셨나요?

1540
01:10:44,560 --> 01:10:47,380
그리고 우리는 또 다른 났다고
제로로 매핑하는 것은?

1541
01:10:47,380 --> 01:10:48,660
>> 청중 : 음, 그냥
같은 일을?

1542
01:10:48,660 --> 01:10:50,290
>> 제이슨 허쉬 호른 : 같은 일을한다.

1543
01:10:50,290 --> 01:10:53,700
따라서이 경우, 우리는 그렇게하지 ​​않으면
그것을 정렬 유지하려면

1544
01:10:53,700 --> 01:10:55,270
오히려 간단한 소리.

1545
01:10:55,270 --> 01:10:59,920
우리는 indice의 포인터를 가지고
우리의 해시 함수에 의해 주어진다.

1546
01:10:59,920 --> 01:11:03,830
우리는 우리의 새로운 노드에 그 지점이 있습니다.

1547
01:11:03,830 --> 01:11:07,830
그리고, 그것은 지적 된대로
이전에 -

1548
01:11:07,830 --> 01:11:10,620
이 경우의 널 (null),에
두 번째의 경우 호박 -

1549
01:11:10,620 --> 01:11:15,310
그것이 가리키는 뭐든간에, 그
이전에, 우리는 다음에 추가

1550
01:11:15,310 --> 01:11:17,810
우리의 새로운 노드.

1551
01:11:17,810 --> 01:11:19,650
우리는 무언가를 삽입하고
처음에.

1552
01:11:19,650 --> 01:11:22,900
사실이보다 훨씬 간단합니다
정렬 된 목록을 유지하려고합니다.

1553
01:11:22,900 --> 01:11:25,340
그러나 다시, 검색이 될 것입니다
자세한 내용은 여기에 복잡.

1554
01:11:25,340 --> 01:11:28,300
우리는 항상 끝으로 이동해야합니다.

1555
01:11:28,300 --> 01:11:29,650
>> OK.

1556
01:11:29,650 --> 01:11:32,750
별도의 체인에 대한 질문?

1557
01:11:32,750 --> 01:11:34,690
그게 어떻게 작동?

1558
01:11:34,690 --> 01:11:35,820
지금 문의하십시오.

1559
01:11:35,820 --> 01:11:39,260
정말 여러분 모두 확인하려면
우리는 밖으로 머리를하기 전에이 작업을 이해합니다.

1560
01:11:39,260 --> 01:11:48,410

1561
01:11:48,410 --> 01:11:52,060
>> 청중 : 왜 호박을 넣을까요
및 동일로 사탕

1562
01:11:52,060 --> 01:11:54,108
해시 테이블의 일부?

1563
01:11:54,108 --> 01:11:55,860
>> 제이슨 허쉬 호른 : 좋은 질문입니다.

1564
01:11:55,860 --> 01:11:59,140
왜 우리는 같은에 넣어 않는다
해시 테이블의 일부?

1565
01:11:59,140 --> 01:12:03,200
음,이 경우 우리의 해시 함수
반환 둘 다 제로.

1566
01:12:03,200 --> 01:12:05,310
그래서 그들은 indice 제로에 갈 필요가
우리가가는 곳 그 때문에

1567
01:12:05,310 --> 01:12:07,420
그들을 보면 우리는 지금
그들을보고 싶어.

1568
01:12:07,420 --> 01:12:11,750
또, 선형 프로빙 접근법
우리는 0에서 그들을 모두 넣어하지 않을 것입니다.

1569
01:12:11,750 --> 01:12:13,900
그러나 별도의 체인 방식에서,
우리는 0에 모두 넣어거야

1570
01:12:13,900 --> 01:12:16,620
다음 제로의 해제 목록을 만들 수 있습니다.

1571
01:12:16,620 --> 01:12:20,140
>> 그리고 우리는 호박을 덮어 쓰지 않으려는
단순히 그것에 대해 우리는 것이기 때문에

1572
01:12:20,140 --> 01:12:21,860
호박이되었다고 가정
삽입되지 않습니다.

1573
01:12:21,860 --> 01:12:25,230
우리는 단지 한 가지를 유지하는 경우
나쁜 것 위치.

1574
01:12:25,230 --> 01:12:28,590
그런 다음이있을 것 없음
지금 우리의 기회 -

1575
01:12:28,590 --> 01:12:31,660
우리가 이제까지 중복이 있다면, 우리
다만 우리의 초기 값을 삭제합니다.

1576
01:12:31,660 --> 01:12:34,090
우리는이 방법을 수행 것도 그런 이유입니다.

1577
01:12:34,090 --> 01:12:36,580
우리가 선택한 이유 또는 그 -하지만 다시, 우리
별도의 체인 방식을 선택했다,

1578
01:12:36,580 --> 01:12:39,670
많은 다른 접근 방법이되는
하나를 선택할 수 있습니다.

1579
01:12:39,670 --> 01:12:41,185
그 질문에 대한 답변을합니까?

1580
01:12:41,185 --> 01:12:41,660
>> OK.

1581
01:12:41,660 --> 01:12:42,910
카를로스.

1582
01:12:42,910 --> 01:12:46,130

1583
01:12:46,130 --> 01:12:47,720
선형 프로브는 포함합니다 -

1584
01:12:47,720 --> 01:12:51,913
우리는 0에서 충돌을 발견하는 경우에, 우리
볼 옆 자리에 보일 것입니다 경우

1585
01:12:51,913 --> 01:12:54,310
그것은 열려 거기에 넣어.

1586
01:12:54,310 --> 01:12:57,320
그리고 우리는 다음 스포츠에서보고
즉 열려 있는지 확인하고 거기에 넣어.

1587
01:12:57,320 --> 01:12:59,780
그래서 우리는 가능한 다음를 찾으십시오
개방 장소와 거기에 넣어.

1588
01:12:59,780 --> 01:13:02,580

1589
01:13:02,580 --> 01:13:03,890
다른 질문?

1590
01:13:03,890 --> 01:13:05,370
그래, 아비.

1591
01:13:05,370 --> 01:13:07,490
>> 청중 : 그 후속으로,
옆 자리에 무엇을 의미합니까?

1592
01:13:07,490 --> 01:13:10,250
해시 테이블 또는 링크 된 목록.

1593
01:13:10,250 --> 01:13:12,100
>> 제이슨 허쉬 호른 : 선형에 대한
프로그래밍, 아니 연결리스트.

1594
01:13:12,100 --> 01:13:13,400
해시 테이블에 다음 자리.

1595
01:13:13,400 --> 01:13:13,820
>> 청중 : OK.

1596
01:13:13,820 --> 01:13:17,570
그래서 해시 테이블 것
크기로 초기화 -

1597
01:13:17,570 --> 01:13:19,560
문자열의 수와 같은
당신이 삽입되었는지?

1598
01:13:19,560 --> 01:13:22,170
>> 제이슨 허쉬 호른 : 당신은 것
정말 큰되고 싶어요.

1599
01:13:22,170 --> 01:13:23,910
예.

1600
01:13:23,910 --> 01:13:27,900
여기에 우리의 사진입니다
그냥 보드에 그린.

1601
01:13:27,900 --> 01:13:29,470
다시 말하지만, 우리는 바로 여기에 충돌이 있습니다.

1602
01:13:29,470 --> 01:13:30,710
152.

1603
01:13:30,710 --> 01:13:33,570
그리고 당신은 우리가 만든 볼 수 있습니다
그것의 전원 연결리스트.

1604
01:13:33,570 --> 01:13:38,200

1605
01:13:38,200 --> 01:13:41,850
다시, 해시 테이블 별도 체이닝
방법은 하나의 당신이 아닙니다

1606
01:13:41,850 --> 01:13:45,590
문제 설정을 위해 수행해야
여섯하지만 하나입니다 많은

1607
01:13:45,590 --> 01:13:47,100
학생들이 수행하는 경향이있다.

1608
01:13:47,100 --> 01:13:51,140
그래서 주에, 우리는 간단하게 이야기하자
우리는 문제를 약 6 밖으로 머리를하기 전에

1609
01:13:51,140 --> 01:13:52,160
그리고 난 당신과 함께 이야기를 공유 할 수 있습니다.

1610
01:13:52,160 --> 01:13:55,120
우리는 3 분있다.

1611
01:13:55,120 --> 01:13:55,750
>> 문제는 여섯을 설정합니다.

1612
01:13:55,750 --> 01:13:57,790
당신은 네 가지 기능을 가지고 있습니다 -

1613
01:13:57,790 --> 01:14:02,430
로드, 크기 및 언로드 확인합니다.

1614
01:14:02,430 --> 01:14:03,380
로드 -

1615
01:14:03,380 --> 01:14:07,120
물론, 우리는 가고 있었어요
지금 과부하.

1616
01:14:07,120 --> 01:14:09,330
우리는 보드에 부하를 받았다.

1617
01:14:09,330 --> 01:14:13,230
그리고 우리는 심지어 많은 코딩 시작
연결리스트에 삽입.

1618
01:14:13,230 --> 01:14:18,020
그래서 부하보다 훨씬 더 많은 수 없습니다
우리는 그냥 뭘했는지.

1619
01:14:18,020 --> 01:14:21,070
>> 당신이 한 번 확인입니다
뭔가로드.

1620
01:14:21,070 --> 01:14:22,580
그것은이 같은 프로세스이다.

1621
01:14:22,580 --> 01:14:26,845
당신이 던져 같은 첫 두 부분
해시 함수에 뭔가

1622
01:14:26,845 --> 01:14:29,190
그 값을 얻을.

1623
01:14:29,190 --> 01:14:30,700
하지만 지금 우리는 그것을 삽입 아닙니다.

1624
01:14:30,700 --> 01:14:33,350
이제 우리는을 찾고 있습니다.

1625
01:14:33,350 --> 01:14:37,130
나는 샘플 코드를 찾기 위해 작성한
연결리스트에서 뭔가.

1626
01:14:37,130 --> 01:14:38,250
그 연습을하는 것이 좋습니다.

1627
01:14:38,250 --> 01:14:43,000
하지만 직관적으로 뭔가를 찾는 것은
뭔가를 삽입하는 것과 비슷.

1628
01:14:43,000 --> 01:14:46,540
사실, 우리는 발견의 그림을 그렸습니다
연결리스트에서 뭔가 움직이는

1629
01:14:46,540 --> 01:14:48,910
당신이 마지막에 도착할 때까지 통해.

1630
01:14:48,910 --> 01:14:52,430
그리고 당신은 결국에 도착하고없는 경우
그것을 발견, 다음이 아니다.

1631
01:14:52,430 --> 01:14:55,400
그래서 본질적으로, 체크합니다.

1632
01:14:55,400 --> 01:14:57,030
>> 다음 크기입니다.

1633
01:14:57,030 --> 01:14:57,910
의 크기를 건너 보자.

1634
01:14:57,910 --> 01:15:00,040
마지막으로 언로드했다.

1635
01:15:00,040 --> 01:15:02,890
언로드 우리가 그려지지 않은 하나입니다
보드에 아직 코딩.

1636
01:15:02,890 --> 01:15:05,990
그러나 나는 당신이 그것을 코딩을 시도하는 것이 좋습니다
샘플 링크리스트의 예에.

1637
01:15:05,990 --> 01:15:11,440
하지만 직관적으로 언로드
무료 비슷합니다 -

1638
01:15:11,440 --> 01:15:14,010
또는 내 말은 확인 비슷합니다.

1639
01:15:14,010 --> 01:15:17,350
당신이려고 지금마다 제외
를 통해, 당신은 단순히 점검하지 않을

1640
01:15:17,350 --> 01:15:19,090
당신이 거기에 값이있는 경우를 참조하십시오.

1641
01:15:19,090 --> 01:15:22,490
하지만 당신은 그 노드를 복용하고있어
본질적으로, 그것을 해제.

1642
01:15:22,490 --> 01:15:23,610
즉, 언로드 할을 요청거야.

1643
01:15:23,610 --> 01:15:24,670
당신이 malloc으로 할당 한 무료 다.

1644
01:15:24,670 --> 01:15:27,480
그래서 당신은 전체 목록을거야
또, 전체의 해시 통하지

1645
01:15:27,480 --> 01:15:27,760
테이블을 다시.

1646
01:15:27,760 --> 01:15:29,240
이 시간은 확인하지 않습니다
거기에 무엇을 볼 수 있습니다.

1647
01:15:29,240 --> 01:15:31,080
그냥 거기에 어떤 무료.

1648
01:15:31,080 --> 01:15:33,260
>> 그리고 마지막으로 크기.

1649
01:15:33,260 --> 01:15:34,350
크기는 구현해야합니다.

1650
01:15:34,350 --> 01:15:35,590
당신은 크기를 구현하지 않는 경우 -

1651
01:15:35,590 --> 01:15:36,250
나는 이런 식으로 말을합니다.

1652
01:15:36,250 --> 01:15:39,740
정확히 사이즈를 구현하지 않는 경우
를 포함하여 한 줄의 코드

1653
01:15:39,740 --> 01:15:43,760
문을 반환, 당신은
잘못의 크기를하고.

1654
01:15:43,760 --> 01:15:47,170
그래서 전체 디자인을 위해, 반드시 크기를 확인
점, 당신은 정확히 하나의 일을하고있어

1655
01:15:47,170 --> 01:15:49,970
등의 코드 라인,
return 문.

1656
01:15:49,970 --> 01:15:52,450
>> 그리고, 아직 Akchar을 포장하지 않습니다.

1657
01:15:52,450 --> 01:15:53,700
열망 비버.

1658
01:15:53,700 --> 01:15:55,820

1659
01:15:55,820 --> 01:16:01,300
너희들 고맙다는 말을하고 싶었
절을 주셔서.

1660
01:16:01,300 --> 01:16:02,550
해피 할로윈 있습니다.

1661
01:16:02,550 --> 01:16:05,300

1662
01:16:05,300 --> 01:16:05,960
이것은 내 의상입니다.

1663
01:16:05,960 --> 01:16:08,850
나는 목요일에이를 착용 할
나는 근무 시간에 당신을보고합니다.

1664
01:16:08,850 --> 01:16:14,640
그리고 당신은 좀 더에 대한 호기심이 있다면
배경이 복장에 같은 느낌

1665
01:16:14,640 --> 01:16:19,135
2011 섹션을 체크 아웃 무료
난 이유에 대한 이야기

1666
01:16:19,135 --> 01:16:20,900
호박 의상을 입고.

1667
01:16:20,900 --> 01:16:23,680
그리고 그것은 슬픈 이야기입니다.

1668
01:16:23,680 --> 01:16:27,050
그래서되어 있는지 확인하십시오
근처의 일부 조직.

1669
01:16:27,050 --> 01:16:28,680
그러나에, 당신은 어떤이있는 경우
내가있을께요 질문

1670
01:16:28,680 --> 01:16:29,960
외부 섹션 후.

1671
01:16:29,960 --> 01:16:31,510
행운을 빌어 문제에 6을 설정합니다.

1672
01:16:31,510 --> 01:16:33,540
그리고 언제나처럼, 당신은 어떤이있는 경우
질문, 알려주세요.

1673
01:16:33,540 --> 01:16:35,584