1
00:00:00,000 --> 00:00:03,423
>> [음악 재생]

2
00:00:03,423 --> 00:00:05,380

3
00:00:05,380 --> 00:00:08,210
>> ANDI 펭 : 섹션의 6 주에 오신 것을 환영합니다.

4
00:00:08,210 --> 00:00:11,620
우리는 우리의 표준에서 이탈
화요일 부분 시간

5
00:00:11,620 --> 00:00:14,130
이 아름다운 일요일 아침에 오후.

6
00:00:14,130 --> 00:00:17,330
모든 주셔서 감사합니다 그
오늘, 그러나 진지하게 나를 합류

7
00:00:17,330 --> 00:00:18,170
박수.

8
00:00:18,170 --> 00:00:20,600
>> 그것은 꽤 큰 노력이다.

9
00:00:20,600 --> 00:00:23,600
나는 거의 심지어 그것을하지 않았다
시간에,하지만 그것은 확인했다.

10
00:00:23,600 --> 00:00:27,520
그래서 나는 당신의 모든 것을 알고있다
단지 퀴즈로 만들었습니다.

11
00:00:27,520 --> 00:00:30,370
우선,에 오신 것을 환영합니다
그 레코드의 B면.

12
00:00:30,370 --> 00:00:32,917
>> 둘째, 우리는 그것에 대해 이야기 할 것이다.

13
00:00:32,917 --> 00:00:34,000
우리는 퀴즈에 대해 이야기 할 것입니다.

14
00:00:34,000 --> 00:00:35,700
우리는 방법에 대해 얘기하자
당신은 클래스에서 일을하고 있습니다.

15
00:00:35,700 --> 00:00:36,550
당신은 괜찮을거야.

16
00:00:36,550 --> 00:00:39,080
나는 당신의 퀴즈에 대한이
여기의 끝에 당신,

17
00:00:39,080 --> 00:00:42,120
그래서 너희들은 수행하려는 경우
, 그것을 완전히 좋아 보이는데.

18
00:00:42,120 --> 00:00:46,590
>> 이렇게 빨리 우리가를 시작하기 전에
다음과 같이 오늘의 일정입니다.

19
00:00:46,590 --> 00:00:48,430
당신이 볼 수 있듯이, 우리는있어
기본적으로 빠른 발사

20
00:00:48,430 --> 00:00:52,120
데이터 구조의 모두를 통해
정말, 정말, 정말 빨리.

21
00:00:52,120 --> 00:00:54,380
같은 그래서, 그것은되지 않습니다
슈퍼 인터랙티브 오늘.

22
00:00:54,380 --> 00:00:59,620
그것은 단지 나 종류의 소리가 될 것이다
이것은 당신, 내가 당신을 혼동하는 경우,

23
00:00:59,620 --> 00:01:02,680
내가 너무 빨리거야 경우, 알려주세요.

24
00:01:02,680 --> 00:01:05,200
그들은 단지 다양한 데이터이야
구조 및 일부로

25
00:01:05,200 --> 00:01:07,070
이에 대한 당신의 PSET의
이번 주, 당신은거야

26
00:01:07,070 --> 00:01:10,340
그들 중 하나를 구현하도록 요청,
아마도 두 그들의 them-- 두

27
00:01:10,340 --> 00:01:12,319
당신의 PSET에서.

28
00:01:12,319 --> 00:01:14,610
좋아, 그럼 난 그냥에 갈거야
일부 발표로 시작합니다.

29
00:01:14,610 --> 00:01:19,070
우리는 스택 및 더 많은 큐를 통해 갈거야
우리는 퀴즈 전에했던 것보다 깊이.

30
00:01:19,070 --> 00:01:20,990
우리는 가서 연결합니다
다시, 한번 나열

31
00:01:20,990 --> 00:01:23,899
보다 깊이에서 더 많은 것을
우리는 퀴즈 전에했다.

32
00:01:23,899 --> 00:01:26,440
그리고 우리는 해시에 대해 얘기하자
테이블, 나무와 시도, 어떤

33
00:01:26,440 --> 00:01:28,890
모든 PSET을 위해 매우 필요하다.

34
00:01:28,890 --> 00:01:32,925
그리고 우리는 몇 가지를 통해 갈거야
pset5에 대한 유용한 정보.

35
00:01:32,925 --> 00:01:37,360
>> 좋아, 그럼 퀴즈 0.

36
00:01:37,360 --> 00:01:41,090
평균은 58 %였다.

37
00:01:41,090 --> 00:01:45,370
그것은 매우 낮은, 그래서 너희들 모두
에 따라 매우 잘했다

38
00:01:45,370 --> 00:01:46,510
그것으로.

39
00:01:46,510 --> 00:01:49,970
>> 당신이 있다면 꽤 많이, 엄지 손가락의 규칙은
평균으로부터 표준 편차 이내

40
00:01:49,970 --> 00:01:52,990
우리는 더 적은에있어 특히 이후
편안한 섹션, 당신은 완전히 괜찮아요.

41
00:01:52,990 --> 00:01:54,120
당신은 트랙에있어.

42
00:01:54,120 --> 00:01:55,190
인생은 좋은 것입니다.

43
00:01:55,190 --> 00:01:58,952
>> 나는 생각하는 무서운 알고
나는이 퀴즈의 40 %처럼되었다.

44
00:01:58,952 --> 00:02:00,160
나는이 클래스를 실패 할거야.

45
00:02:00,160 --> 00:02:02,243
내가 당신을 약속, 당신은 아니에요
클래스를 실패 할 것.

46
00:02:02,243 --> 00:02:03,680
당신은 완전히 괜찮아요.

47
00:02:03,680 --> 00:02:06,850
>> 이상 가지고 사람들을 위해
평균, 감동, 감동,

48
00:02:06,850 --> 00:02:08,780
같은, 심각하게 잘.

49
00:02:08,780 --> 00:02:09,689
나는 나와 함께 그들을있다.

50
00:02:09,689 --> 00:02:11,730
그들을 데리러 주시기 바랍니다
섹션의 끝에.

51
00:02:11,730 --> 00:02:14,520
당신은 어떤이있는 경우 알려주세요
문제, 그들과 함께 질문.

52
00:02:14,520 --> 00:02:17,204
우리는 당신의 점수를 추가하는 경우
잘못 알려.

53
00:02:17,204 --> 00:02:21,240
>> 확인, pset5 그래서,이 정말이다
의미에서 예일에 대한 이상한 주

54
00:02:21,240 --> 00:02:24,240
우리의 PSET이 때문이라고
포함 정오 수요일

55
00:02:24,240 --> 00:02:27,317
늦은 날은, 그래서 사실이다
정오 화요일 이론적으로 인해.

56
00:02:27,317 --> 00:02:29,150
아마 아무도 완료하지
정오 화요일에.

57
00:02:29,150 --> 00:02:30,830
즉 완전히 괜찮아요.

58
00:02:30,830 --> 00:02:33,700
우리는 근무 시간을 할거야
오늘 밤뿐만 아니라 월요일 밤.

59
00:02:33,700 --> 00:02:36,810
그리고 모든 섹션이 주는 것
실제로 워크숍으로 전환 될,

60
00:02:36,810 --> 00:02:38,800
그래서에서 팝업 주시기
원하는 섹션,

61
00:02:38,800 --> 00:02:42,810
그들은 종류의 미니 PSET 수 있습니다
그에 도움 워크숍.

62
00:02:42,810 --> 00:02:45,620
그래서 같은 이것은 유일한 부분이다
여기서 우리가 자료를 교육하고 있습니다.

63
00:02:45,620 --> 00:02:49,220
다른 모든 부분은 집중 될 것이다
전용 PSET에 대한 도움말에.

64
00:02:49,220 --> 00:02:50,146
네?

65
00:02:50,146 --> 00:02:52,000
>> 청중 : 어디에 근무 시간은?

66
00:02:52,000 --> 00:02:56,120
>> ANDI 펭 : 영업 시간
오, 좋은 질문을 tonight--.

67
00:02:56,120 --> 00:03:00,580
생각 근무 시간 오늘 밤
청록이나 풍경에 있습니다.

68
00:03:00,580 --> 00:03:02,984
온라인 CS50을 선택하면
당신은, 근무 시간에 이동

69
00:03:02,984 --> 00:03:05,650
스케줄이 있어야 그
그들 모두가 당신을 알려줍니다.

70
00:03:05,650 --> 00:03:07,954
>> 오늘 밤 중 하나를 알고
또는 내일 청록색이며,

71
00:03:07,954 --> 00:03:10,120
그리고 나는 우리가 가질 수있는 생각
다른 밤 풍경.

72
00:03:10,120 --> 00:03:11,020
잘 모르겠 는데요.

73
00:03:11,020 --> 00:03:11,700
좋은 질문.

74
00:03:11,700 --> 00:03:14,430
CS50에 확인합니다.

75
00:03:14,430 --> 00:03:18,780
>> 관련 쿨, 질문
삼일 같은 다음에 대한 일정?

76
00:03:18,780 --> 00:03:21,690
나는 다윗 같은 너희들을 약속
이 언덕의 정상입니다 말했다.

77
00:03:21,690 --> 00:03:23,050
너희들은 거의있다.

78
00:03:23,050 --> 00:03:24,644
그냥 세 일 이상.

79
00:03:24,644 --> 00:03:26,310
거기에 도착하고 우리는 내려합니다.

80
00:03:26,310 --> 00:03:28,114
우리는 좋은 CS-무료 휴식을해야합니다.

81
00:03:28,114 --> 00:03:28,780
우리는 다시 올 것이다.

82
00:03:28,780 --> 00:03:30,779
우리는 웹에 뛰어 것
프로그래밍 및 개발,

83
00:03:30,779 --> 00:03:35,150
매우 재미있는 것들을 비교
다른하여 pset의 일부.

84
00:03:35,150 --> 00:03:37,974
그리고 그것은 진정, 그리고 것
우리는 재미를 많이해야합니다.

85
00:03:37,974 --> 00:03:38,890
우리는 더 많은 사탕을해야합니다.

86
00:03:38,890 --> 00:03:39,730
사탕 죄송합니다.

87
00:03:39,730 --> 00:03:40,945
나는 사탕을 잊어 버렸습니다.

88
00:03:40,945 --> 00:03:43,310
그것은 거친 아침이었다.

89
00:03:43,310 --> 00:03:46,340
그래서 사람들은 거의가
나는 너희들 정말 자랑 스럽습니다.

90
00:03:46,340 --> 00:03:49,570
>> 좋아, 그럼 스택.

91
00:03:49,570 --> 00:03:53,331
누가 잭에 대한 질문을 사랑
퀴즈에 자신의 옷?

92
00:03:53,331 --> 00:03:53,830
아무도?

93
00:03:53,830 --> 00:03:56,500
좋아, 괜찮아요.

94
00:03:56,500 --> 00:04:00,200
>> 그래서 기본적으로 당신이 할 수
사진 잭, 여기이 사람,

95
00:04:00,200 --> 00:04:03,350
옷을 사랑
스택의 상단에서,

96
00:04:03,350 --> 00:04:05,750
그는에 그것을 다시 넣습니다
그 후 스택은 이루어집니다.

97
00:04:05,750 --> 00:04:07,600
이런 식으로 그래서 그는 결코
지고있는 것 같다

98
00:04:07,600 --> 00:04:10,090
하단에
그의 옷에 스택.

99
00:04:10,090 --> 00:04:12,600
그래서이 종류의 설명
기본적인 데이터 구조

100
00:04:12,600 --> 00:04:16,610
스택이 구현되는 방법.

101
00:04:16,610 --> 00:04:20,060
>> 기본적으로, 생각
개체의 스택으로 스택

102
00:04:20,060 --> 00:04:24,900
당신은 상단에 물건을 넣어, 어디
당신은 정상에서 그들을 팝업.

103
00:04:24,900 --> 00:04:28,600
그래서 LIFO는 우리가 좋아하는 글자입니다
마지막으로, 첫 번째 아웃 use--합니다.

104
00:04:28,600 --> 00:04:32,480
그리고 상단에 지속
스택 나오는 첫 번째입니다.

105
00:04:32,480 --> 00:04:34,260
그리고 두 용어
우리는 연결하려면

106
00:04:34,260 --> 00:04:36,190
그와 푸시와 팝이라고합니다.

107
00:04:36,190 --> 00:04:39,790
때에 뭔가를 밀어
스택, 당신은 다시 그것을 팝업.

108
00:04:39,790 --> 00:04:43,422
>> 그래서 나는이 가지 추측
당신의 사람들을 위해 추상적 인 개념

109
00:04:43,422 --> 00:04:45,630
사람처럼보고 싶​​어
이것의 실제 구현

110
00:04:45,630 --> 00:04:46,740
현실 세계에서.

111
00:04:46,740 --> 00:04:50,170
얼마나 많은 당신이 에세이를 작성했습니다
아마 한 시간처럼 인해 전에

112
00:04:50,170 --> 00:04:54,510
당신은 실수로 거대한 삭제
실수로 같은 그것의 덩어리?

113
00:04:54,510 --> 00:04:58,560
그리고 무엇을 제어 할
우리는 그것을 다시 넣어 사용할 수 있습니까?

114
00:04:58,560 --> 00:05:00,030
제어-Z, 그래?

115
00:05:00,030 --> 00:05:03,640
제어 Z 때문에 배의 양
제어-Z는 나의 생명을 구했다고,

116
00:05:03,640 --> 00:05:08,820
모든 시간을 내 엉덩이를 저장하고있다
즉 스택을 통해 구현입니다.

117
00:05:08,820 --> 00:05:13,020
>> 본질적으로 모든 정보
즉, Word 문서에의

118
00:05:13,020 --> 00:05:15,080
그것은 밀어 의지에 튀어됩니다.

119
00:05:15,080 --> 00:05:19,460
그래서 기본적으로 때마다를
아무것도 삭제, 당신은 위로를 다시 팝.

120
00:05:19,460 --> 00:05:22,820
그리고 다음에 다시해야하는 경우를
제어-C가 무엇 인 밀어 넣습니다.

121
00:05:22,820 --> 00:05:26,770
그리고 실제 기능
방법 간단한 데이터 구조

122
00:05:26,770 --> 00:05:28,690
일상 생활에 도움이 될 수 있습니다.

123
00:05:28,690 --> 00:05:31,710

124
00:05:31,710 --> 00:05:40,150
>> 그래서 구조체는 방법입니다
우리가 실제로 스택을 만들 수 있습니다.

125
00:05:40,150 --> 00:05:44,720
우리는 다음 구조체를 정의 입력
우리는 아래에서 호출 스택.

126
00:05:44,720 --> 00:05:47,440
그리고 스택 내에서,
우리는 두 개의 매개 변수를 가지고

127
00:05:47,440 --> 00:05:51,580
우리는 본질적으로 조작 할 수
그래서 우리는 문자 스타 문자열 능력을 가지고있다.

128
00:05:51,580 --> 00:05:55,150
>> 이하고있는 모든 것을
배열을 생성한다

129
00:05:55,150 --> 00:05:58,835
우리는 당신이 원하는대로 저장할 수
이는 우리가 용량을 확인할 수 있습니다.

130
00:05:58,835 --> 00:06:01,990
용량은 단지 최대 금액입니다
항목 우리는이 배열에 넣을 수 있습니다.

131
00:06:01,990 --> 00:06:05,660
INT 크기는 유지 카운터
얼마나 많은 항목의 트랙은 현재

132
00:06:05,660 --> 00:06:07,850
스택.

133
00:06:07,850 --> 00:06:11,860
그러므로 우리는, 추적 할 수 있습니다
두 스택 실제가 얼마나 큰

134
00:06:11,860 --> 00:06:14,850
와, B, 어떻게 스택의 많은
우리가 원하지 않기 때문에 우리는 가득

135
00:06:14,850 --> 00:06:18,800
우리의 능력이 무엇인지를 통해 오버 플로우.

136
00:06:18,800 --> 00:06:24,340
>> 예를 들어,이 사랑스러운 그래서
문제는 퀴즈에 있었다.

137
00:06:24,340 --> 00:06:28,160
기본적으로 우리가 어떻게 추진 할
스택의 맨 위에.

138
00:06:28,160 --> 00:06:28,830
매우 간단하다.

139
00:06:28,830 --> 00:06:30,621
당신이 그것을 보면,
우리는이를 통해 걸을 것이다.

140
00:06:30,621 --> 00:06:32,640
[들림] size-- 경우
때마다, 기억

141
00:06:32,640 --> 00:06:35,300
에 액세스 할
구조체 내에서 매개 변수,

142
00:06:35,300 --> 00:06:40,320
당신은 struct.parameter의 이름을.

143
00:06:40,320 --> 00:06:42,720
>> 이 경우, S는
우리의 스택의 이름입니다.

144
00:06:42,720 --> 00:06:46,230
우리는 크기에 액세스하려면
그것을, 그래서 우리는 s.size을한다.

145
00:06:46,230 --> 00:06:50,280
크기가 아니기 때문에 너무 오래
용량 또는 한 동일

146
00:06:50,280 --> 00:06:52,940
이 용량보다 적은 것에 따라,
하나 여기에 작동합니다.

147
00:06:52,940 --> 00:06:57,180
>> 당신은 내부에 액세스하려면
스택의, s.strings 때문에,

148
00:06:57,180 --> 00:07:00,790
당신은 그 새 번호를 넣어거야
당신은 거기에 삽입 할 것을.

149
00:07:00,790 --> 00:07:05,030
그냥 우리가 원하는 것입니다 가정 해 봅시다
스택에 INT n을 삽입,

150
00:07:05,030 --> 00:07:08,905
우리는 s.strings을 할 수
브래킷, s.size는 N 같습니다.

151
00:07:08,905 --> 00:07:11,030
크기는 곳이기 때문에 우리
현재 스택에

152
00:07:11,030 --> 00:07:14,590
우리는 밀어려고하는 경우에
거기에, 우리는 단지 액세스

153
00:07:14,590 --> 00:07:17,370
크기가 어디에 있든,
스택의 현재의 충만,

154
00:07:17,370 --> 00:07:21,729
우리는 그것에 INT의 N을 누릅니다.

155
00:07:21,729 --> 00:07:24,770
그리고 우리는이 있는지 확인하려면
또한, N의 크기를 증가시키는 것

156
00:07:24,770 --> 00:07:27,436
우리는했습니다의 그래서 우리는 추적 할 수 있습니다
스택에 추가로 일을했다.

157
00:07:27,436 --> 00:07:29,660
이제 우리는 더 큰 크기를 가지고있다.

158
00:07:29,660 --> 00:07:33,196
이 여기에 의미가 있는가
모두, 어떻게 논리적으로 작동?

159
00:07:33,196 --> 00:07:34,160
그것은 종류의 빨랐다.

160
00:07:34,160 --> 00:07:39,535

161
00:07:39,535 --> 00:07:42,160
청중 : 당신은 가서 수
s.stringss.strings [s.size] 다시?

162
00:07:42,160 --> 00:07:45,808
ANDI 펭 : 물론, 그래서 무엇을 수행
우리에게 현재 s.size?

163
00:07:45,808 --> 00:07:47,440
청중 : 그것은 현재 크기입니다.

164
00:07:47,440 --> 00:07:50,890
ANDI 펭 : 정확히, 그래서
우리의 크기에있다 현재 인덱스,

165
00:07:50,890 --> 00:07:57,780
그래서 우리는 새로운 정수를 넣을
우리는 s.size에 삽입 할 것을.

166
00:07:57,780 --> 00:07:58,760
말이 돼?

167
00:07:58,760 --> 00:08:01,110
s.strings 때문에, 모든
인은 어레이의 이름이다.

168
00:08:01,110 --> 00:08:03,510
그것이 모든 액세스이며
우리의 구조체 내의 배열,

169
00:08:03,510 --> 00:08:06,030
그래서 우리는 원하는 경우
그 인덱스로 N을 배치,

170
00:08:06,030 --> 00:08:09,651
우리는 단지 그것을 액세스 할 수 있습니다
사용 브래킷 s.size.

171
00:08:09,651 --> 00:08:10,150
시원한.

172
00:08:10,150 --> 00:08:13,580

173
00:08:13,580 --> 00:08:18,916
>> 좋아, 팝, 나는 그것을 밖으로 의사
너희들,하지만 비슷한 개념.

174
00:08:18,916 --> 00:08:19,790
말이 돼?

175
00:08:19,790 --> 00:08:22,310
크기가 크면
다음 제로보다 당신

176
00:08:22,310 --> 00:08:25,350
당신이 뭔가를 먹고 싶어 알고
아웃 크기가 아닌 경우 때문에

177
00:08:25,350 --> 00:08:27,620
제로보다 큰, 당신은
스택에 아무​​것도 없다.

178
00:08:27,620 --> 00:08:29,840
>> 그래서 당신은 단지 실행할
이 코드는, 단지 수

179
00:08:29,840 --> 00:08:32,320
갑자기 뭔가가있는 경우 팝업.

180
00:08:32,320 --> 00:08:35,830
크기가 너무 크면
0이 아닌, 우리를 뺀 크기입니다.

181
00:08:35,830 --> 00:08:40,020
우리는 크기를 감소 후 반환
그것 때문에 내부에 어떤입니다

182
00:08:40,020 --> 00:08:42,710
터지는으로, 우리는 원하는
저장되어있는 어떤 액세스

183
00:08:42,710 --> 00:08:45,694
스택 상부의 인덱스.

184
00:08:45,694 --> 00:08:46,610
모든 것이 이해가?

185
00:08:46,610 --> 00:08:49,693
내가 만든 경우 너희들은 이것을 쓰기
너희들은 그것을 쓸 수 있을까?

186
00:08:49,693 --> 00:08:52,029

187
00:08:52,029 --> 00:08:53,570
좋아, 너희들은 주위를 재생할 수 있습니다.

188
00:08:53,570 --> 00:08:55,252
걱정은 당신이 그것을 얻을하지 않는 경우.

189
00:08:55,252 --> 00:08:57,460
우리는 코드에 시간이 없어
그것을 밖으로 오늘 우리가했습니다 때문에

190
00:08:57,460 --> 00:08:59,959
이러한 구조를 많이 가지고
통과하지만, 본질적으로합니다

191
00:08:59,959 --> 00:09:02,214
의사, 매우, 매우 유사 밀어.

192
00:09:02,214 --> 00:09:03,380
그냥 논리를 따라.

193
00:09:03,380 --> 00:09:06,092
당신은 모든에 액세스하고 있는지 확인
제대로 구조체의 기능을 제공합니다.

194
00:09:06,092 --> 00:09:06,574
네?

195
00:09:06,574 --> 00:09:09,282
>> 청중 : 윌이 슬라이드와
이 모든 것은 오늘까지 흉내 수?

196
00:09:09,282 --> 00:09:11,586
ANDI 펭 : 항상, 네.

197
00:09:11,586 --> 00:09:13,710
내가 넣어하려고거야
이 업 후 시간 등을들 수있다.

198
00:09:13,710 --> 00:09:16,626
내가 다윗을 이메일로 보내 드리겠습니다, 다윗을 시도합니다
이 후 한 시간처럼졌습니다.

199
00:09:16,626 --> 00:09:20,040

200
00:09:20,040 --> 00:09:25,470
>> 좋아, 그럼 우리는이 다른로 이동
스러운 데이터 구조는 큐라고.

201
00:09:25,470 --> 00:09:30,140
너희들은 여기에서 볼 수 있듯이,
큐, 우리 사이에 영국에 대한,

202
00:09:30,140 --> 00:09:32,010
그것이 모든 라인입니다.

203
00:09:32,010 --> 00:09:34,680
그렇게 반대 무엇
당신은 스택이 생각

204
00:09:34,680 --> 00:09:37,750
큐가 정확히 무엇이다
논리적으로 당신은 그것이라고 생각합니다.

205
00:09:37,750 --> 00:09:41,914
또, FIFO의 규칙에 의해 열리는
이는, 가장 먼저입니다.

206
00:09:41,914 --> 00:09:43,705
첫 번째 인 경우
라인에 하나, 당신이있어

207
00:09:43,705 --> 00:09:46,230
그 첫 번째
라인 나옵니다.

208
00:09:46,230 --> 00:09:49,680
>> 그래서 우리는이 전화를 좋아하는지
dequeueing과가 대기 상태입니다.

209
00:09:49,680 --> 00:09:52,380
우리는 무언가를 추가하려면
우리의 큐에, 우리는 대기열에.

210
00:09:52,380 --> 00:09:55,690
우리가 원하는 경우 대기열에서 제외, 또는 취할
뭔가 멀리, 우리는 큐에서.

211
00:09:55,690 --> 00:10:03,350
>> 우리가 가지있어 그래서 같은 의미
고정 된 크기의 요소를 생성하는 우리

212
00:10:03,350 --> 00:10:06,500
특정 저장할 수 있습니다
일, 그러나 우리는 또한 수

213
00:10:06,500 --> 00:10:10,100
우리는 배치하고 위치를 변경
그들 내부의 매개 변수

214
00:10:10,100 --> 00:10:13,140
어떤 유형에 따라
기능을 우리는 할 수 있습니다.

215
00:10:13,140 --> 00:10:16,700
스택 그래서, 우리는 마지막을 원했다
하나는, N은 첫 번째 아웃합니다.

216
00:10:16,700 --> 00:10:19,800
큐는 우리가 처음 일을 할 것입니다
에서 첫 일이 될 수 있습니다.

217
00:10:19,800 --> 00:10:22,510

218
00:10:22,510 --> 00:10:26,710
>> 구조체 형 그래서
당신이 볼 수 있듯이, 정의,

219
00:10:26,710 --> 00:10:29,470
그것은 조금 다르다
스택이 무엇에서

220
00:10:29,470 --> 00:10:33,120
단지 우리가 계속해야하지 때문에
크기가 현재 위치를 추적,

221
00:10:33,120 --> 00:10:37,420
또한 머리를 추적 할
뿐만 아니라 곳으로 우리는 현재.

222
00:10:37,420 --> 00:10:39,580
그래서 쉽게 생각
나는이를 작성합니다.

223
00:10:39,580 --> 00:10:53,270
그래서 우리가 큐를 가지고 가정 해 봅시다,
그래서 머리가 바로 여기 가정 해 봅시다.

224
00:10:53,270 --> 00:10:55,811

225
00:10:55,811 --> 00:10:58,310
라인의 머리하자
다만, 그가 현재의 말

226
00:10:58,310 --> 00:11:01,809
우리는 삽입 할
큐에 뭔가.

227
00:11:01,809 --> 00:11:04,350
나는 기본적으로 크기를 호출하는거야
꼬리와 같은 일이며,

228
00:11:04,350 --> 00:11:06,314
대기열이 곳의 끝.

229
00:11:06,314 --> 00:11:07,730
그냥 크기가 바로 여기에 있다고 가정 해 봅시다.

230
00:11:07,730 --> 00:11:14,380

231
00:11:14,380 --> 00:11:18,400
>> 그럼 어떻게 하나 실행 가능하게합니까
큐에 뭔가입니까?

232
00:11:18,400 --> 00:11:21,000

233
00:11:21,000 --> 00:11:24,130
무엇 인덱스 우리가 배치 할 할
여기서 우리는에 삽입 할.

234
00:11:24,130 --> 00:11:29,320
이의 시작입니다 경우
이 큐는 그것의 끝

235
00:11:29,320 --> 00:11:31,860
또는 그것의 크기, 어디까지 할
다음 개체를 추가하려면?

236
00:11:31,860 --> 00:11:32,920
>> 청중 : [들리지]

237
00:11:32,920 --> 00:11:35,920
ANDI 펭 : 정확히, 당신은 추가 할
에 따라 당신은 그것을 작성했습니다.

238
00:11:35,920 --> 00:11:37,840
어느 쪽이 비어 있거나 비어 있습니다.

239
00:11:37,840 --> 00:11:42,630
그래서 당신은 아마 그것을 추가 할
여기에 있기 때문에 크기가 말한 데로라면

240
00:11:42,630 --> 00:11:50,540
이 모든 전체 경우, 당신이 원하는
바로, 바로 여기에 추가하는 방법?

241
00:11:50,540 --> 00:11:57,150
>> 그래서 즉,이다 아주, 아주 잠시
간단한, 꽤 항상 올바른

242
00:11:57,150 --> 00:12:00,690
주요 차이점 때문에
큐와 스택 사이

243
00:12:00,690 --> 00:12:04,350
그 큐 수있다
실제로 조작 할 수

244
00:12:04,350 --> 00:12:06,980
그 때문에, 헤드 변경
당신이 원하는 위치에 따라

245
00:12:06,980 --> 00:12:08,650
당신의 큐의 시작은 시작합니다.

246
00:12:08,650 --> 00:12:11,900
그 결과로, 꼬리
또한 바꿀 것입니다.

247
00:12:11,900 --> 00:12:14,770
그래서 좀 봐
지금이 코드.

248
00:12:14,770 --> 00:12:18,620
너희들도에했다으로
대기열, 퀴즈에 써.

249
00:12:18,620 --> 00:12:22,580
어쩌면 우리는 그 이유를 얘기하자
대답은 그것이 무엇이었다.

250
00:12:22,580 --> 00:12:26,790
>> 나는 아주, 하나이 줄을 맞지 않을 수 있습니다
코드 그러나 기본적으로이 작품

251
00:12:26,790 --> 00:12:29,030
한 줄에 있어야합니다.

252
00:12:29,030 --> 00:12:30,140
30초처럼 보내십시오.

253
00:12:30,140 --> 00:12:33,000
봐, 왜 참조
이것은 인 방법이다.

254
00:12:33,000 --> 00:12:50,030

255
00:12:50,030 --> 00:12:55,420
>> 아주, 아주 유사한 구조체, 아주, 아주
이전과 유사한 구조

256
00:12:55,420 --> 00:12:58,090
아마도 제외 스택
한 줄의 코드.

257
00:12:58,090 --> 00:13:01,190
그리고 한 줄의 코드가
기능을 결정합니다.

258
00:13:01,190 --> 00:13:03,900
그리고 그것은 정말 차별화
스택에서 큐.

259
00:13:03,900 --> 00:13:18,510

260
00:13:18,510 --> 00:13:22,010
>> 누군가는 자상을 먹고 싶어
당신이했습니다 이유를 설명에서

261
00:13:22,010 --> 00:13:24,980
여기에서이 복잡한 일이있어?

262
00:13:24,980 --> 00:13:27,845
우리의 반환을 볼 우리의
멋진 친구 계수.

263
00:13:27,845 --> 00:13:31,020
너희들은 곧 올 것이다으로
프로그램에서 인식하는,

264
00:13:31,020 --> 00:13:34,910
거의 언제 당신이 뭔가를 필요
아무것도 주위에 포장하기,

265
00:13:34,910 --> 00:13:36,850
계수는 그것을 할 수있는 방법이 될 것입니다.

266
00:13:36,850 --> 00:13:40,510
그래서를 알고, 사람이 원하는 않습니다
코드의 라인을 설명하는 시도?

267
00:13:40,510 --> 00:13:44,060

268
00:13:44,060 --> 00:13:47,507
그래, 모든 대답은
허용과에 오신 것을 환영합니다.

269
00:13:47,507 --> 00:13:48,840
청중 : 당신이 나에게 말을하는거야?

270
00:13:48,840 --> 00:13:49,506
ANDI 펭 : 네.

271
00:13:49,506 --> 00:13:56,200
청중 : 아, 아니 죄송합니다.

272
00:13:56,200 --> 00:14:00,250
ANDI 펭 : 좋아, 그럼하자
이 코드를 통해 도보.

273
00:14:00,250 --> 00:14:03,642
그래서 때 당신이 노력하고
큐에 무언가를 추가,

274
00:14:03,642 --> 00:14:08,510
머리가 발생하는 사랑스러운 경우
바로 여기에, 그것은 우리에게 매우 쉽다

275
00:14:08,510 --> 00:14:10,960
다만 끝으로 이동
바로 뭔가를 삽입?

276
00:14:10,960 --> 00:14:14,690
그러나 큐의 전체 지점입니다
그 수 실제로 동적 헤드

277
00:14:14,690 --> 00:14:17,280
위치에 따라 변경 우리
우리의 Q의 시작이 원하는,

278
00:14:17,280 --> 00:14:19,880
와 같은, 꼬리 등
또한 바꿀 것입니다.

279
00:14:19,880 --> 00:14:31,100
>> 그리고이없는 것을 상상
큐, 오히려이 큐이었다.

280
00:14:31,100 --> 00:14:37,900

281
00:14:37,900 --> 00:14:39,330
의 머리가 바로 여기에 있다고 가정 해 봅시다.

282
00:14:39,330 --> 00:14:54,900

283
00:14:54,900 --> 00:14:56,980
의 우리의 큐는이처럼 보였다 가정 해 봅시다.

284
00:14:56,980 --> 00:15:00,190
우리는 어디로 이동하고 싶었다면
라인의 시작이고,

285
00:15:00,190 --> 00:15:03,400
의 우리가 머리를 옮겨 봅시다
이런 식으로 여기에 크기.

286
00:15:03,400 --> 00:15:07,100
>> 이제 우리는 뭔가를 추가 할
이 큐,하지만 너희들이 볼 수 있듯이,

287
00:15:07,100 --> 00:15:11,150
그냥 할 수 있도록 간단하지
크기 이후 어떤 추가

288
00:15:11,150 --> 00:15:13,630
우리가 부족하기 때문에
우리의 실제 배열의 경계입니다.

289
00:15:13,630 --> 00:15:16,190
우리가 정말 추가 할 경우 여기에있다.

290
00:15:16,190 --> 00:15:18,610
즉, 큐의 아름다움
즉, 시각적으로, 우리에게있다

291
00:15:18,610 --> 00:15:22,380
라인이 이렇게 가고처럼 보이는
그러나, 데이터 구조에 저장 될 때,

292
00:15:22,380 --> 00:15:29,370
그들은주기 등을 제공합니다.

293
00:15:29,370 --> 00:15:32,360
그것은 종류의 주위에 래핑
전면 동일한 방법으로

294
00:15:32,360 --> 00:15:34,780
또한 줄 수있는 래핑
주변 어디든지 당신을에 따라

295
00:15:34,780 --> 00:15:36,279
할 줄의 시작 부분으로합니다.

296
00:15:36,279 --> 00:15:38,630
그래서 우리는이 걸릴 경우
여기에 내려다 볼,하자

297
00:15:38,630 --> 00:15:40,880
우리를 만들고 싶었 말
기능은 대기열을했다.

298
00:15:40,880 --> 00:15:43,980
우리는 그 질문에 INT의 N을 추가하고 싶었다.

299
00:15:43,980 --> 00:15:49,250
q.size 우리는 우리의 데이터를한다는 전화 할게 q-- 경우
우리의 queue.size하지 않는 경우는 structure--

300
00:15:49,250 --> 00:15:52,520
용량 또는 경우와 동일
그것은 용량보다 적은이다

301
00:15:52,520 --> 00:15:55,120
q.strings은 우리의 Q 내에서 배열입니다.

302
00:15:55,120 --> 00:15:58,380
우리는 설정하는거야
그 q.heads 동일,

303
00:15:58,380 --> 00:16:02,730
이는 바로 여기, 플러스 q.size
용량에 의해 계수하는

304
00:16:02,730 --> 00:16:04,290
여기 우리를 다시 포장.

305
00:16:04,290 --> 00:16:08,040
>> 이 예를 들어, 인덱스에 따라서
머리의 오른쪽 1?

306
00:16:08,040 --> 00:16:11,480
크기의 인덱스 0, 1, 2, 3, 4이다.

307
00:16:11,480 --> 00:16:19,500
그래서 우리는 1 플러스 4 계수 작업을 수행 할 수 있습니다
5 우리의 능력에 의해.

308
00:16:19,500 --> 00:16:20,920
무슨 우리를 주는가?

309
00:16:20,920 --> 00:16:23,270
인덱스는 무엇인가 그
이 나온다?

310
00:16:23,270 --> 00:16:24,080
>> 청중 : 0.

311
00:16:24,080 --> 00:16:27,870
>> ANDI 펭 : 0, 어떤
여기 될 일이,

312
00:16:27,870 --> 00:16:30,640
그래서 우리가 할 수 있도록하려면
여기에 삽입합니다.

313
00:16:30,640 --> 00:16:34,730
그리고이 방정식 여기 종류
단지 어떤 숫자와 함께 작동

314
00:16:34,730 --> 00:16:36,750
위치에 따라 당신의
머리와 당신의 크기입니다.

315
00:16:36,750 --> 00:16:38,541
당신은 어떤 사람들을 알고있는 경우
일이 당신이 알고있는이다

316
00:16:38,541 --> 00:16:43,170
정확히 삽입 할 위치
무엇이든은 큐 후입니다.

317
00:16:43,170 --> 00:16:44,640
그 모두에게 의미가 있습니까?

318
00:16:44,640 --> 00:16:48,560
>> 나는 뇌의 종류를 알고
티저 특히 이후이

319
00:16:48,560 --> 00:16:50,512
퀴즈의 여파로했다.

320
00:16:50,512 --> 00:16:52,220
그러나 희망이 모두
지금 이해할 수

321
00:16:52,220 --> 00:16:57,800
왜이 솔루션 또는이
함수는 인 방법이다.

322
00:16:57,800 --> 00:16:59,840
누구나 약간은 명확하지?

323
00:16:59,840 --> 00:17:03,471

324
00:17:03,471 --> 00:17:03,970
그래.

325
00:17:03,970 --> 00:17:07,109

326
00:17:07,109 --> 00:17:09,970
>> 그리고 지금, 당신의 경우
이 작업을 대기열에서 제외하고 싶어

327
00:17:09,970 --> 00:17:15,240
우리의 머리가 이동 될 곳이다
우리가 대기열에서 제외한다면, 때문에

328
00:17:15,240 --> 00:17:17,030
우리는 Q의 말을하지 않습니다.

329
00:17:17,030 --> 00:17:19,130
우리는 오른쪽 머리 벗고 싶어?

330
00:17:19,130 --> 00:17:24,260
그래서 그 결과로, 머리를 바꿀 것입니다,
당신이 대기열에 때 왜, 즉,

331
00:17:24,260 --> 00:17:26,800
당신은 추적 할 수있어
여기서 당신의 머리와 크기

332
00:17:26,800 --> 00:17:29,450
삽입 할 수 있습니다
올바른 위치에.

333
00:17:29,450 --> 00:17:32,740
>> 그리고 당신이 대기열에서 제외 할 때,
나는 또한 그것을 의사.

334
00:17:32,740 --> 00:17:35,480
당신이 원한다면 언제든지
이것을 코딩을 시도한다.

335
00:17:35,480 --> 00:17:36,980
당신이 바로, 머리를 이동하려면?

336
00:17:36,980 --> 00:17:39,320
나는 큐에서 제거하고 싶었다면, 나는
머리를 통해 이동합니다.

337
00:17:39,320 --> 00:17:40,800
이것은 머리가 될 것입니다.

338
00:17:40,800 --> 00:17:45,617
>> 그리고 우리의 현재 크기는 것
빼기 때문에 우리는 더 이상

339
00:17:45,617 --> 00:17:46,950
배열의 네 가지 요소가있다.

340
00:17:46,950 --> 00:17:51,370
우리는 세 가지가 있고, 우리는 원하는
내부에 저장된대로 돌아갑니다

341
00:17:51,370 --> 00:17:56,260
머리의 우리는 이것을 먹고 싶어하기 때문에
스택에 이렇게 아주 유사한 값 아웃.

342
00:17:56,260 --> 00:17:58,010
그냥 당신이 복용하고
다른 장소에서,

343
00:17:58,010 --> 00:18:01,770
당신은 당신의 포인터를 재 할당해야
그 결과로 다른 장소.

344
00:18:01,770 --> 00:18:03,890
논리적으로, 모두가 따라?

345
00:18:03,890 --> 00:18:05,690
큰.

346
00:18:05,690 --> 00:18:10,156
>> 좋아, 그래서 우리는 조금 이야기거야
연결리스트에 대한 깊이 더

347
00:18:10,156 --> 00:18:13,280
그들은 매우, 매우 도움이 될 것이기 때문에
금주의 과정에서 당신을 위해

348
00:18:13,280 --> 00:18:14,964
psets를.

349
00:18:14,964 --> 00:18:17,130
연결리스트, 같은 너희들
그들은 모두, 기억

350
00:18:17,130 --> 00:18:22,570
특정의 노드입니다 노드는
값과 포인터의 값 양쪽

351
00:18:22,570 --> 00:18:26,290
즉, 서로 연결되어
그 포인터에 의해.

352
00:18:26,290 --> 00:18:29,880
방법에 대한 그래서 구조체
우리는 여기에 노드가 우리입니다 만들

353
00:18:29,880 --> 00:18:33,569
인 INT의 N이 어떤
상점 또는 문자열 N의 값

354
00:18:33,569 --> 00:18:35,610
또는 당신이 원하는 무엇이든
문자 스타 N, 호출.

355
00:18:35,610 --> 00:18:41,482
포인터가 구조체 노드 스타,
각 노드에있는 것인지,

356
00:18:41,482 --> 00:18:43,690
당신은이 겁니다
다음으로 포인터 포인트.

357
00:18:43,690 --> 00:18:48,207

358
00:18:48,207 --> 00:18:50,040
당신은 머리를해야합니다
의 연결리스트의

359
00:18:50,040 --> 00:18:53,140
나머지 가리 예정
등등 등등 값

360
00:18:53,140 --> 00:18:55,290
당신은 결국 끝에 도달 할 때까지.

361
00:18:55,290 --> 00:18:58,040
그리고이 마지막 노드는 그냥
포인터가없는 것.

362
00:18:58,040 --> 00:18:59,952
그것은 가리 것
null의 경우, 그 때의

363
00:18:59,952 --> 00:19:01,910
당신은 당신을 공격 한 알
당신의 연결리스트의 끝

364
00:19:01,910 --> 00:19:04,076
때 마지막 포인터
아무것도 가리 키지 않습니다.

365
00:19:04,076 --> 00:19:06,670

366
00:19:06,670 --> 00:19:10,990
>> 그래서 우리는 더에 조금 갈거야
에 대한 깊이 어떻게 가능성 것

367
00:19:10,990 --> 00:19:12,400
링크 된 목록을 검색 할 수 있습니다.

368
00:19:12,400 --> 00:19:15,460
의 일부를 어떤 기억
연결리스트의 단점

369
00:19:15,460 --> 00:19:19,340
검색에 대한 배열을 구절.

370
00:19:19,340 --> 00:19:22,565
배열 할 수 있습니다 이진 검색하지만,
왜 연결리스트에서 그렇게 할 수 있습니까?

371
00:19:22,565 --> 00:19:26,834

372
00:19:26,834 --> 00:19:30,320
>> 청중 : 그들은 모두 연결되어 있기 때문에,
하지만 당신은 아주 어디 모른다

373
00:19:30,320 --> 00:19:31,330
[알아들을 수 없는].

374
00:19:31,330 --> 00:19:34,600
>> ANDI 펭 : 네, 정확히 그렇게 기억
그 배열의 광채

375
00:19:34,600 --> 00:19:37,190
우리가 가지고 있었던 사실이었다
랜덤 액세스 메모리 어디에

376
00:19:37,190 --> 00:19:41,580
나는 인덱스의 값을 원하는 경우
여섯, 난 그냥, 인덱스 여섯 말할 수

377
00:19:41,580 --> 00:19:42,407
나에게 그 값을 제공합니다.

378
00:19:42,407 --> 00:19:45,240
배열이 분류되어 있기 때문에 그건
메모리의 연속 된 공간에서

379
00:19:45,240 --> 00:19:48,020
한 곳에서 반면,
연결리스트 가지

380
00:19:48,020 --> 00:19:52,820
있습니다 무작위로, 주변의 모든 산재
유일한 방법은 당신이 하나를 찾을 수 있습니다

381
00:19:52,820 --> 00:19:56,890
를 알려주는 포인터를 통해입니다
그 다음 노드가 어디의 주소.

382
00:19:56,890 --> 00:20:00,290
>> 그리고 그 결과, 유일한 방법
링크 된 목록을 검색 할 수

383
00:20:00,290 --> 00:20:01,560
선형 탐색이다.

384
00:20:01,560 --> 00:20:05,890
나는 정확히 알 수 없기 때문에
링크 된 목록에서 12 값이며,

385
00:20:05,890 --> 00:20:08,780
나는 전체를 통과해야
링크 된 목록을 하나의

386
00:20:08,780 --> 00:20:12,450
첫 번째 노드에 머리에서 하나,
제 2 노드에 상기 제 3 노드에,

387
00:20:12,450 --> 00:20:17,690
나는 마침내 얻을 때까지 모든 방법
내가 찾고 해당 노드는 곳.

388
00:20:17,690 --> 00:20:22,110
그리고 이러한 의미에서, 검색
연결리스트에 항상 n은.

389
00:20:22,110 --> 00:20:23,040
항상 N입니다.

390
00:20:23,040 --> 00:20:25,690
그것은 선형 시간에 항상.

391
00:20:25,690 --> 00:20:28,470
>> 그래서 코드하는
우리는이를 구현하고,이

392
00:20:28,470 --> 00:20:32,620
당신 이후 너희들을위한 약간의 새로운
사람은 정말 대해 또는 이제까지 이야기하지 않은

393
00:20:32,620 --> 00:20:35,000
방법에서 볼 포인터
포인터를 검색,

394
00:20:35,000 --> 00:20:37,670
그래서 우리는 걸을 것이다
이 아주, 아주 천천히.

395
00:20:37,670 --> 00:20:40,200
그래서 부울 검색, 오른쪽,
의 우리가 원하는 가정 해 봅시다

396
00:20:40,200 --> 00:20:42,820
라는 함수를 만드는 방법
true를 돌려 검색

397
00:20:42,820 --> 00:20:46,820
링크 된 내부 가치를 발견하는 경우
나열하고, 그렇지 않으면 false를 반환합니다.

398
00:20:46,820 --> 00:20:50,030
노드 별 목록입니다
현재 단지 포인터

399
00:20:50,030 --> 00:20:52,960
당신의 연결리스트의 첫 번째 항목에.

400
00:20:52,960 --> 00:20:56,700
INT n을 당신이있어 값이다
그 목록을 검색.

401
00:20:56,700 --> 00:20:58,770
>> 그래서 노드 스타 포인터는 목록 같습니다.

402
00:20:58,770 --> 00:21:00,970
그것은 우리가 설정하는 의미
및 포인터를 만드는

403
00:21:00,970 --> 00:21:03,592
목록의 내부에 첫 번째 노드.

404
00:21:03,592 --> 00:21:04,300
나와 함께 모두?

405
00:21:04,300 --> 00:21:06,530
우리가 갈 것 인 경우에 따라서
다시 여기에, 나는 것

406
00:21:06,530 --> 00:21:13,850
가리키는 포인터를 초기화
머리는 무엇의 목록입니다.

407
00:21:13,850 --> 00:21:18,600
>> 그리고 당신은, 여기로 일단
포인터가 동일한 null을하지 않지만,

408
00:21:18,600 --> 00:21:22,160
그래서 우리가되는 루프입니다
통과 이후가 될 것

409
00:21:22,160 --> 00:21:25,940
무엇 때문에 우리의 목록의 나머지
포인터가 null 같을 때 어떻게됩니까?

410
00:21:25,940 --> 00:21:27,550
우리는 우리가 잔 마셔요 것을 알고있다

411
00:21:27,550 --> 00:21:28,450
>> 청중 : [들리지]

412
00:21:28,450 --> 00:21:31,491
>> ANDI 펭 : 정확히, 그래서 우리는 알고
우리는 오른쪽 목록의 끝에 도달했습니다?

413
00:21:31,491 --> 00:21:34,470
여기에 다시 갈 경우, 각 노드
다른 노드를 가리키는해야

414
00:21:34,470 --> 00:21:36,550
등 등
당신은 결국 히트까지

415
00:21:36,550 --> 00:21:41,589
당신의 연결리스트의 꼬리,
이는 포인터를 갖는다 단지

416
00:21:41,589 --> 00:21:43,130
더 이상 아무 곳이나 가리 키지 않습니다.

417
00:21:43,130 --> 00:21:47,510
그래서 당신은 기본적으로 알고
목록은 여전히​​를하다

418
00:21:47,510 --> 00:21:50,900
포인터가 동일하지 않을 때까지
널 (null)이 널 (null)에 해당하면 때문에,

419
00:21:50,900 --> 00:21:53,310
당신은 더 이상 물건이 없다는 것을 알고있다.

420
00:21:53,310 --> 00:21:56,930
>> 그래서 우리가있어하는 루프입니다
실제 검색을해야 할 것.

421
00:21:56,930 --> 00:22:01,690
그리고 pointer--는 참조 할 경우
이 화살표 기능의 종류?

422
00:22:01,690 --> 00:22:06,930
그래서 포인터 포인트 경우 N에, 경우
N과 동일 같음 N에서 포인터

423
00:22:06,930 --> 00:22:09,180
그래서 의미하는 경우 그
당신이있어 포인터

424
00:22:09,180 --> 00:22:13,420
각각의 단부에 대한 검색
노드 값과 실제로 동일하다

425
00:22:13,420 --> 00:22:15,990
그런 다음, 찾고
당신은 true를 반환하고 싶습니다.

426
00:22:15,990 --> 00:22:19,280
그러니까 기본적으로, 당신은 노드에서라면 그
, 당신이 찾고있는 값을 갖는다

427
00:22:19,280 --> 00:22:23,550
당신은 당신이 있었던 것을 알고있다
성공적으로 검색 할 수.

428
00:22:23,550 --> 00:22:27,150
>> 그렇지 않으면, 당신은 설정하려면
다음 노드에 대한 포인터.

429
00:22:27,150 --> 00:22:28,850
즉, 여기에 라인이하고있는 것입니다.

430
00:22:28,850 --> 00:22:31,750
포인터는 다음 포인터 같습니다.

431
00:22:31,750 --> 00:22:33,360
그 작업을 어떻게 모든 사람이 볼 수?

432
00:22:33,360 --> 00:22:36,580
>> 그리고 기본적으로 당신은거야 단지
목록의 전체를 횡단

433
00:22:36,580 --> 00:22:41,920
포인터 각 때까지 재설정
결국에는리스트의 끝을 쳤다.

434
00:22:41,920 --> 00:22:45,030
그리고 당신은이 있음을 알 수 없다
더 많은 노드를 통해 검색 할 수

435
00:22:45,030 --> 00:22:47,999
그리고 당신은 거짓을 반환 할 수 있습니다
당신이 알고 있기 때문에, 그 아니라, 오,

436
00:22:47,999 --> 00:22:50,540
나는 검색 할 수있었습니다 경우
리스트의 전체 관통.

437
00:22:50,540 --> 00:22:54,530
이 예제의 경우, 내가 원하는 경우
10의 값을 찾아,

438
00:22:54,530 --> 00:22:57,250
나는 머리에서 시작하고,
나는 끝까지 검색

439
00:22:57,250 --> 00:23:00,550
나는 결국,이에 도착하는
null로 가리키는 포인터,

440
00:23:00,550 --> 00:23:04,415
내가 아닌, 쓰레기, 나는 10를 추측 것을 알고있다
이 목록 나는 그것을 찾을 수 없습니다 때문입니다.

441
00:23:04,415 --> 00:23:06,520
그리고리스트의 마지막에 있어요.

442
00:23:06,520 --> 00:23:11,040
그리고이 경우 당신은 알고있다
나는 false를 반환거야.

443
00:23:11,040 --> 00:23:12,900
>> 그 조금을 위해에 흠뻑 젖어 보자.

444
00:23:12,900 --> 00:23:17,350
이 꽤 될 것입니다
당신의 PSET 중요.

445
00:23:17,350 --> 00:23:21,140
그 로직은 아마도 매우 간단
구문 그냥 구현.

446
00:23:21,140 --> 00:23:23,365
너희들은 만들고 싶어
당신이 이해하고 있는지 확인하십시오.

447
00:23:23,365 --> 00:23:25,870

448
00:23:25,870 --> 00:23:27,650
시원한.

449
00:23:27,650 --> 00:23:32,560
>> 좋아, 그럼 우리는 어떻게 될 것
오른쪽 노드를 삽입,

450
00:23:32,560 --> 00:23:35,380
리스트로 인해 기억
어떤 혜택 무엇인가

451
00:23:35,380 --> 00:23:39,230
의 연결리스트 대를 가진
저장소의 측면에서 배열?

452
00:23:39,230 --> 00:23:41,110
>> 청중 : 그것은 동적이다,
그래서 쉽게 이러시면

453
00:23:41,110 --> 00:23:43,180
>> ANDI 펭 : 정확히,
그래서, 동적이다하는

454
00:23:43,180 --> 00:23:46,880
그것을 확장하고 축소 할 수 있음을 의미합니다
사용자의 필요에 따라.

455
00:23:46,880 --> 00:23:56,570
그리고, 이러한 의미에서, 우리는 필요하지 않습니다
불필요한 메모리를 낭비하는 나는 때문에

456
00:23:56,570 --> 00:24:00,850
내가 원하는 얼마나 많은 값을 모르는 경우
가게에, 나를 위해 이해가되지 않습니다

457
00:24:00,850 --> 00:24:04,310
배열 때문에를 만들려면
나는 10의 값을 저장하려면

458
00:24:04,310 --> 00:24:08,380
나는 1000의 배열, 그건 생성
낭비 많은 메모리, 할당.

459
00:24:08,380 --> 00:24:11,180
우리가 링크 사용하려는 이유
목록은 동적으로 할 수 있도록

460
00:24:11,180 --> 00:24:13,860
변경하거나 크기를 축소.

461
00:24:13,860 --> 00:24:17,040
>> 그리고 그 삽입한다
조금 더 복잡합니다.

462
00:24:17,040 --> 00:24:20,810
우리는 랜덤 요소에 액세스 할 수 없기 때문에
우리가 배열의 것이 방법.

463
00:24:20,810 --> 00:24:24,270
나는 요소를 삽입 할 경우
일곱 번째 인덱스로,

464
00:24:24,270 --> 00:24:26,930
난 그냥 삽입 할 수 있습니다
일곱 번째 인덱스에.

465
00:24:26,930 --> 00:24:30,020
연결리스트, 그것은하지 않습니다
아주 쉽게 작동,

466
00:24:30,020 --> 00:24:34,947
그래서 우리는 삽입하기를 원한다면
링크 된 목록에 여기에 하나,

467
00:24:34,947 --> 00:24:36,280
시각적으로, 그것을보고 매우 간단합니다.

468
00:24:36,280 --> 00:24:39,363
우리는, 바로 거기를 삽입 할
오른쪽 목록의 시작 부분에서,

469
00:24:39,363 --> 00:24:40,840
바로 머리 후.

470
00:24:40,840 --> 00:24:44,579
>> 그러나 우리가하는 방식은 재 할당하기
포인터는 약간 선상됩니다

471
00:24:44,579 --> 00:24:47,620
또는, 논리적으로는, 의미가 있지만,
당신은 당신이 그것을 가지고 있는지 확인하려면

472
00:24:47,620 --> 00:24:50,250
완전히 때문에
당신이 원하는 마지막 일

473
00:24:50,250 --> 00:24:52,990
포인터를 재 할당하는 것입니다
우리가 여기에서하고있는 방법입니다.

474
00:24:52,990 --> 00:24:58,170
당신이 만약 역 참조
(1) 머리에서 포인터,

475
00:24:58,170 --> 00:25:01,086
다음 갑자기 모든
당신의 연결리스트의 나머지

476
00:25:01,086 --> 00:25:04,680
당신이 실제로 있기 때문에 손실
임시 아무것도를 만들었습니다.

477
00:25:04,680 --> 00:25:06,220
즉이 지적입니다.

478
00:25:06,220 --> 00:25:10,080
그런 다음 포인터를 재 할당하는 경우
목록의 나머지는 완전히 없어집니다.

479
00:25:10,080 --> 00:25:13,310
그래서 당신이되고 싶어
여기에 매우, 매우 조심

480
00:25:13,310 --> 00:25:17,010
먼저를 지정하려면
당신이 어떤에서 포인터

481
00:25:17,010 --> 00:25:20,150
어디든지에 삽입 할
당신이 원하는, 다음을

482
00:25:20,150 --> 00:25:22,710
목록의 나머지 반 참조 할 수 있습니다.

483
00:25:22,710 --> 00:25:25,250
>> 그래서 이것은 어디든지 적용
당신은에 삽입하려는.

484
00:25:25,250 --> 00:25:27,520
당신은에 삽입 할 경우
머리, 여기에 응답 할 경우,

485
00:25:27,520 --> 00:25:29,455
당신은에 삽입 할 경우
결국, 잘, 최종 I

486
00:25:29,455 --> 00:25:30,910
추측 당신은 단지 것
어떤 포인터가 없지만,

487
00:25:30,910 --> 00:25:33,830
그렇게하지 ​​있는지 확인하려면
목록의 나머지 부분을 잃게됩니다.

488
00:25:33,830 --> 00:25:36,640
당신은 항상 있는지 확인하려면
새 노드가 가리키는

489
00:25:36,640 --> 00:25:39,330
무엇으로 당신
에 삽입 할,

490
00:25:39,330 --> 00:25:42,170
다음은 체인에 추가 할 수 있습니다.

491
00:25:42,170 --> 00:25:43,330
모두 명확한?

492
00:25:43,330 --> 00:25:45,427
>> 이 될 것입니다
진짜 문제 중 하나.

493
00:25:45,427 --> 00:25:48,010
대부분의 주요 문제 중 하나
당신은 당신의 PSET에 할거야

494
00:25:48,010 --> 00:25:51,340
당신이 만들려고하는거야 것입니다
링크 된 목록과 삽입 것들

495
00:25:51,340 --> 00:25:53,340
그러나 단지를 잃을
당신의 연결리스트의 나머지.

496
00:25:53,340 --> 00:25:54,900
그리고 당신처럼 될거야, 내가
이런 일이 왜 몰라?

497
00:25:54,900 --> 00:25:58,040
그리고 그것은 통과하는 고통
및 포인터를 모두 검색 할 수 있습니다.

498
00:25:58,040 --> 00:26:02,100
>> 그리고 나는이 PSET에 당신을 보장,
이러한 노드를 작성하고 그리기

499
00:26:02,100 --> 00:26:03,344
매우 도움이 될 것입니다.

500
00:26:03,344 --> 00:26:06,010
그래서 당신은 완벽하게 추적 할 수 있습니다
모든 포인터가있는 곳의,

501
00:26:06,010 --> 00:26:08,540
무슨 잘못이야
모든 노드가있는 곳,

502
00:26:08,540 --> 00:26:12,660
당신이 액세스 할 수 무엇을해야하는지 또는
삽입 또는 삭제하거나의.

503
00:26:12,660 --> 00:26:14,550
그 좋은 모두?

504
00:26:14,550 --> 00:26:15,050
시원한.

505
00:26:15,050 --> 00:26:19,300

506
00:26:19,300 --> 00:26:22,600
>> 우리는 코드를보고 싶어한다면?

507
00:26:22,600 --> 00:26:24,470
아, 알 수없는 경우 우리
그래서, 짓이야 확인을 볼 수 있습니다

508
00:26:24,470 --> 00:26:27,940
상단 그것이 모든 함수이다
우리가 원하는 이름을 삽입

509
00:26:27,940 --> 00:26:31,365
연결리스트로 INT의 N을 삽입합니다.

510
00:26:31,365 --> 00:26:32,740
우리는이를 통해 걸을 것입니다.

511
00:26:32,740 --> 00:26:34,770
그것은 코드의 많은 새로운 구문을 많이합니다.

512
00:26:34,770 --> 00:26:36,220
우리는 확인을 할 수 있습니다.

513
00:26:36,220 --> 00:26:39,120
>> 상단마다에서 최대 그래서
우리는 무엇을 만들려면

514
00:26:39,120 --> 00:26:42,380
우리는 무엇을해야합니까 특히 경우
그것은 스택에 저장되지 할

515
00:26:42,380 --> 00:26:43,920
하지만 힙?

516
00:26:43,920 --> 00:26:45,460
우리는 오른쪽의 malloc로 이동?

517
00:26:45,460 --> 00:26:48,240
그래서 우리는 포인터를 만들 것입니다.

518
00:26:48,240 --> 00:26:52,074
노드, 포인터, 새로운 같음
노드의 크기의 malloc

519
00:26:52,074 --> 00:26:53,740
우리가 원하기 때문에 해당 노드가 생성된다.

520
00:26:53,740 --> 00:26:56,720
우리는의 양을 원하는
노드가 차지하는 메모리

521
00:26:56,720 --> 00:26:59,300
에 할당 할
새 노드의 생성.

522
00:26:59,300 --> 00:27:02,270
>> 그리고 우리는 확인거야
새로운 등호가 null 동일한 경우를 참조하십시오.

523
00:27:02,270 --> 00:27:03,370
우리가 말을 기억 하는가?

524
00:27:03,370 --> 00:27:06,470
malloc에​​ 무엇이든을,
당신은 항상 무엇을해야 하는가?

525
00:27:06,470 --> 00:27:09,490
당신은 항상 확인해야합니다
여부를 그 null입니다.

526
00:27:09,490 --> 00:27:13,620
>> 예를 들어, 운영
시스템은 완전히 가득했다

527
00:27:13,620 --> 00:27:17,060
당신은에서 더 이상 메모리가 있다면
모든 당신이 malloc을 시도,

528
00:27:17,060 --> 00:27:18,410
당신을 위해 null을 반환합니다.

529
00:27:18,410 --> 00:27:21,094
그리고 당신은 그것을 사용하려고하면
이 null로 지적 할 때,

530
00:27:21,094 --> 00:27:23,260
당신은 할 수 않을거야
해당 정보에 액세스 할 수 있습니다.

531
00:27:23,260 --> 00:27:27,010
그리고 같은, 우리는 확인하고 싶었
때마다 mallocing하고 있는지,

532
00:27:27,010 --> 00:27:30,500
당신은 항상 있는지 확인하고
당신에게 주어진 메모리는 null입니다.

533
00:27:30,500 --> 00:27:33,670
그렇지 않은 경우에, 우리는 이동할 수 있습니다
우리의 코드의 나머지에.

534
00:27:33,670 --> 00:27:36,140
>> 그래서 우리는 갈거야
새 노드를 초기화합니다.

535
00:27:36,140 --> 00:27:39,050
우리는 새로운 n은 N과 동일 할 것입니다.

536
00:27:39,050 --> 00:27:42,390
그리고 우리가 할거야
새로운 새로운 포인터를 설정

537
00:27:42,390 --> 00:27:46,900
null로 지금 우리는하지 않기 때문에
그것을 가리 키도록 아무것도 할 수 있습니다.

538
00:27:46,900 --> 00:27:48,755
우리는 아무 생각이 곳이 없다
그것은 당신을 넣어 것

539
00:27:48,755 --> 00:27:50,630
그리고 우리가 원하는 경우
머리에 삽입,

540
00:27:50,630 --> 00:27:53,820
우리는 다시 할당 할 수 있습니다
머리에 대한 포인터.

541
00:27:53,820 --> 00:27:58,530
모든 사람이 논리를 따라 하는가
여기서의 그 일이야?

542
00:27:58,530 --> 00:28:02,502
>> 우리가하고있는 모든 새를 만드는 것입니다
노드 null에 포인터를 설정하는,

543
00:28:02,502 --> 00:28:04,210
다음 재 할당
그것은 머리에 우리의 경우

544
00:28:04,210 --> 00:28:06,320
우리가 머리를 삽입 할 알고있다.

545
00:28:06,320 --> 00:28:09,420
그리고 머리에 것입니다
그 새로운 노드를 향해 가리 킵니다.

546
00:28:09,420 --> 00:28:11,060
그와 확인을 모두?

547
00:28:11,060 --> 00:28:12,380
>> 그래서 두 단계 프로세스이다.

548
00:28:12,380 --> 00:28:14,760
먼저 할당 할 수있어
당신이 무엇을 만들고있어.

549
00:28:14,760 --> 00:28:18,260
해당 포인터를 설정
당신을 참조하고

550
00:28:18,260 --> 00:28:21,400
수 역 참조 가지
첫 번째 포인터

551
00:28:21,400 --> 00:28:22,972
새로운 노드쪽으로 가리 킵니다.

552
00:28:22,972 --> 00:28:25,680
당신이 그것을 삽입하여 원하는 목적지,
그 논리는 성립 할 것이다.

553
00:28:25,680 --> 00:28:27,530
>> 그것은 할당과 같은 종류의
임시 변수.

554
00:28:27,530 --> 00:28:28,700
기억, 당신은있어
확인하는 그

555
00:28:28,700 --> 00:28:30,346
당신이 교환하는 경우의 트랙을 잃지 않습니다.

556
00:28:30,346 --> 00:28:33,470
당신은 당신이 있는지 확인하려면
종류의 유지 임시 변수

557
00:28:33,470 --> 00:28:35,620
여기서 그 일을 추적
그래서 저장 당신

558
00:28:35,620 --> 00:28:41,190
과정에서 어떤 값을 잃지 말고
의 그것으로 장난처럼.

559
00:28:41,190 --> 00:28:42,710
>> 좋아, 그럼 코드는 여기에있을 것입니다.

560
00:28:42,710 --> 00:28:45,020
너희들은 섹션 다음에 보자.

561
00:28:45,020 --> 00:28:48,060
그것은있을 것입니다.

562
00:28:48,060 --> 00:28:50,280
>> 그래서 내가 어떻게하는지 추측
우리가 원하는 경우이 다를

563
00:28:50,280 --> 00:28:52,300
중간이나 끝 부분에 삽입하는 방법?

564
00:28:52,300 --> 00:28:57,892
사람은 무엇의 아이디어가 있습니까
논리적 기준으로 의사

565
00:28:57,892 --> 00:29:00,350
우리가 원하는 경우에 우리가 수행하게
중간에 삽입하는 방법?

566
00:29:00,350 --> 00:29:03,391
그래서 만약 우리가 그것을 삽입하고 싶어
헤드는, 우리가 모든 새로운 노드를 생성하는 것이다.

567
00:29:03,391 --> 00:29:06,311
우리는 그 포인터를 설정
어떤 머리에 새 노드,

568
00:29:06,311 --> 00:29:08,310
그리고, 우리는 머리를 설정
새 노드에, 오른쪽?

569
00:29:08,310 --> 00:29:11,560
우리는 중간에 삽입하고 싶었다면
목록으로, 우리는 무엇을해야 할 것인가?

570
00:29:11,560 --> 00:29:14,108

571
00:29:14,108 --> 00:29:16,110
>> 청중 : 그것은 아직도 것
유사한 과정이 될

572
00:29:16,110 --> 00:29:19,114
의 포인터를 할당 추천하고
다음, 그 포인터를 할당

573
00:29:19,114 --> 00:29:20,530
그러나 우리는이 위치해야 할 것입니다.

574
00:29:20,530 --> 00:29:23,560
>> ANDI 펭 : 정확히, 정확하게 그래서
만약 제외한 동일한 공정

575
00:29:23,560 --> 00:29:27,820
정확히 어디를 찾을 수있는 당신
그 새로운 포인터에 가고 싶어,

576
00:29:27,820 --> 00:29:44,790
내가 삽입 할 경우 이렇게
확인 list-- 링크의 중간,

577
00:29:44,790 --> 00:29:46,370
의가 우리의 연결리스트 말할 수 있습니다.

578
00:29:46,370 --> 00:29:49,500
우리가 여기를 삽입 할 경우,
우리는 새로운 노드를 만들 것입니다.

579
00:29:49,500 --> 00:29:50,520
우리는 malloc을 것입니다.

580
00:29:50,520 --> 00:29:52,220
우리는 새로운 노드를 만들 것입니다.

581
00:29:52,220 --> 00:29:55,940
우리는을 할당 할거야
여기에이 노드의 포인터.

582
00:29:55,940 --> 00:29:58,335
>> 그러나 문제는 그 상이
머리가 어디에서

583
00:29:58,335 --> 00:30:00,490
우리가 정확히 알고 있다는 것입니다
여기서 헤드이다.

584
00:30:00,490 --> 00:30:01,930
그것은 바로, 처음 옳았다?

585
00:30:01,930 --> 00:30:04,870
그러나 여기에서 우리는 추적 할 수있어
여기서의 우리는 그것을에 삽입하고 있습니다.

586
00:30:04,870 --> 00:30:07,930
우리가 삽입하는 경우 우리의
여기에 노드, 우리는있어

587
00:30:07,930 --> 00:30:12,270
확인하는 그
이 노드로 이전

588
00:30:12,270 --> 00:30:14,172
포인터를 재 할당입니다.

589
00:30:14,172 --> 00:30:16,380
그럼 당신은 가지를해야합니다
두 가지의 추적합니다.

590
00:30:16,380 --> 00:30:19,420
당신이있는 곳을 추적하는 경우
노드는 현재에 삽입된다.

591
00:30:19,420 --> 00:30:23,280
또한 추적 할
당신이보고있는 이전 노드

592
00:30:23,280 --> 00:30:24,340
또한 거기에 있었다.

593
00:30:24,340 --> 00:30:25,830
그 좋은 모두?

594
00:30:25,830 --> 00:30:26,500
그래.

595
00:30:26,500 --> 00:30:28,000
>> 어떻게 끝 부분에 삽입하는 방법에 대한?

596
00:30:28,000 --> 00:30:34,220
내가 원한다면 나는 here-- 추가하고 싶다면
목록의 마지막에 새로운 노드를 추가,

597
00:30:34,220 --> 00:30:37,009
나는 그 일에 대해 어떻게 갈 수 있는가?

598
00:30:37,009 --> 00:30:39,300
청중 : 그래서 현재,
마지막의 널을 지적했다.

599
00:30:39,300 --> 00:30:40,960
ANDI 펭 : 네.

600
00:30:40,960 --> 00:30:43,560
정확히, 그래서이 하나
현재 알고 지적이다,

601
00:30:43,560 --> 00:30:46,720
그래서 나는이 점에서, 그것의 추측
리스트의 마지막에 추가하는 것은 매우 쉽습니다.

602
00:30:46,720 --> 00:30:51,810
당신이 할 일은 그것을 설정
널 (null) 다음 붐과 동일.

603
00:30:51,810 --> 00:30:53,070
바로 거기, 매우 간단합니다.

604
00:30:53,070 --> 00:30:53,960
매우 간단합니다.

605
00:30:53,960 --> 00:30:56,430
>> 매우 유사
당신 머리,하지만 논리적으로

606
00:30:56,430 --> 00:30:59,690
단계가 있는지 확인하려면
당신은이 중 하나를 수행하기 위해 취해야

607
00:30:59,690 --> 00:31:01,500
당신은 함께 다음과 같은 것입니다.

608
00:31:01,500 --> 00:31:04,420
그것은 중간에, 아주 쉽게
코드의,에 휘말리고

609
00:31:04,420 --> 00:31:05,671
아, 나는 너무 많은 포인터를 가지고있다.

610
00:31:05,671 --> 00:31:07,461
어디서 몰라
아무것도 가리키는.

611
00:31:07,461 --> 00:31:09,170
나는 심지어 내가에있어 어느 노드 모른다.

612
00:31:09,170 --> 00:31:11,490
무슨 일이야?

613
00:31:11,490 --> 00:31:13,620
>> 심호흡을, 진정, 휴식을 취하십시오.

614
00:31:13,620 --> 00:31:15,530
당신의 연결 목록을 그립니다.

615
00:31:15,530 --> 00:31:18,800
당신이 말하는 경우에, 나는 어디에 정확히 알고
나는이 점을 삽입해야

616
00:31:18,800 --> 00:31:22,970
그리고 내 재 할당하는 방법을 정확히 알고
포인터는, 훨씬, 훨씬 더 쉽게 사진합니다

617
00:31:22,970 --> 00:31:27,200
out-- 훨씬, 훨씬 더 쉽게하지
코드의 버그에서 분실.

618
00:31:27,200 --> 00:31:29,410
그와 확인을 모두?

619
00:31:29,410 --> 00:31:31,380
그래.

620
00:31:31,380 --> 00:31:35,120
>> 그래서 나는 우리가하지 않은 개념을 생각한다
정말, 지금은 전에 이야기

621
00:31:35,120 --> 00:31:38,131
나는 아마 당신을 추측
많은 yet--가 발생하지 않습니다

622
00:31:38,131 --> 00:31:40,880
그것은 고급 concept-- 가지의
우리가 실제로 데이터를 가지고있다

623
00:31:40,880 --> 00:31:43,900
구조는 이중 연결리스트라고합니다.

624
00:31:43,900 --> 00:31:46,390
너희들이 볼 수 그래서,
우리가하고있는 모든 만들고있다

625
00:31:46,390 --> 00:31:50,400
실제 값, 추가
우리의 각 노드에 대한 포인터

626
00:31:50,400 --> 00:31:52,660
그 또한 이전 노드를 가리 킵니다.

627
00:31:52,660 --> 00:31:58,170
그래서뿐만 아니라 우리는 우리가 할
노드는 다음 중 하나를 가리 킵니다.

628
00:31:58,170 --> 00:32:01,430
또한 이전에 가리.

629
00:32:01,430 --> 00:32:04,310
지금은이 두 가지를 무시하는거야.

630
00:32:04,310 --> 00:32:06,740
>> 그럼 당신은 체인을 가지고
그 두 가지를 이동할 수 있습니다,

631
00:32:06,740 --> 00:32:09,630
다음은 조금 더 쉽다
논리적으로 따라 할 수 있습니다.

632
00:32:09,630 --> 00:32:11,896
여기 같은 대신
오, 추적을 유지, 나는

633
00:32:11,896 --> 00:32:14,520
이 노드가 있음을 알고있다
내가 다시 할당해야 하나,

634
00:32:14,520 --> 00:32:17,532
난 그냥 여기와 있습니다
단지 앞 당깁니다.

635
00:32:17,532 --> 00:32:19,490
그럼 정확히 알고
즉, 다음을

636
00:32:19,490 --> 00:32:21,130
를 통과 할 필요가 없습니다
연결리스트의 전체.

637
00:32:21,130 --> 00:32:22,180
그것은 조금 더 쉽다.

638
00:32:22,180 --> 00:32:24,960
>> 그러나 같은, 당신은 이중이
포인터의 양

639
00:32:24,960 --> 00:32:26,960
즉, 메모리의 두 배입니다.

640
00:32:26,960 --> 00:32:28,950
또한 추적 할 포인터 많이있다.

641
00:32:28,950 --> 00:32:32,140
그것은 조금 더 복잡하지만, 그건
사용자 친화적 따라 조금 더

642
00:32:32,140 --> 00:32:34,080
당신이 달성하기 위해 노력하고 무엇에.

643
00:32:34,080 --> 00:32:36,910
>> 따라서 이러한 유형의 데이터
구조는 완전히 존재

644
00:32:36,910 --> 00:32:40,280
과에 대한 구조는 매우이다
당신이 가지고있는 모든이를 제외하고 단순,

645
00:32:40,280 --> 00:32:43,850
대신 다음에 그냥 포인터,
당신은 또한 이전에 대한 포인터를 가지고있다.

646
00:32:43,850 --> 00:32:45,940
즉, 모든 차이했다입니다.

647
00:32:45,940 --> 00:32:47,740
그 좋은 모두?

648
00:32:47,740 --> 00:32:48,240
시원한.

649
00:32:48,240 --> 00:32:50,940

650
00:32:50,940 --> 00:32:53,280
>> 좋아, 그래서 지금은 해요
정말 아마 지출

651
00:32:53,280 --> 00:32:56,870
15~20분 또는 대량 등
섹션의 나머지 시간의

652
00:32:56,870 --> 00:32:58,360
해시 테이블에 대해 얘기.

653
00:32:58,360 --> 00:33:02,590
어떻게 사람의 많은
pset5 사양을 읽고?

654
00:33:02,590 --> 00:33:03,620
좋아, 좋아.

655
00:33:03,620 --> 00:33:06,160
즉 보통의 50 % 이상이다.

656
00:33:06,160 --> 00:33:07,560
괜찮아요.

657
00:33:07,560 --> 00:33:10,345
>> 너희들이 볼 수 그래서,
당신은 pset5에 도전있어

658
00:33:10,345 --> 00:33:16,790
사전을 구현하는 것입니다
당신은 14 만 단어를 통해로드 어디에

659
00:33:16,790 --> 00:33:20,610
우리는 및 맞춤법 검사에게 당신에게 있음을
모든 텍스트에 대한 그것.

660
00:33:20,610 --> 00:33:22,580
우리는 당신에게 무작위주지
문학의 조각.

661
00:33:22,580 --> 00:33:23,520
우리는 당신에게 오디세이을 줄 것이다.

662
00:33:23,520 --> 00:33:24,561
우리는 당신에게 일리아드를 줄 것이다.

663
00:33:24,561 --> 00:33:26,350
우리는 당신에게 오스틴 파워를 줄 것이다.

664
00:33:26,350 --> 00:33:28,220
>> 그리고 당신의 도전
체크를 주문하는 것입니다

665
00:33:28,220 --> 00:33:31,760
모두의 모든 하나의 단어
그 사전

666
00:33:31,760 --> 00:33:34,960
기본적으로 우리의 맞춤법 검사기와.

667
00:33:34,960 --> 00:33:38,620
그리고 몇 부분있다
이 PSET를 생성,

668
00:33:38,620 --> 00:33:41,970
먼저이되고 싶어
실제로로드 할 수

669
00:33:41,970 --> 00:33:43,970
에 모든 단어 당신의
사전, 다음을

670
00:33:43,970 --> 00:33:45,530
할 수 있도록하려면
그들 모두를 맞춤법 검사.

671
00:33:45,530 --> 00:33:48,780
그리고 같은, 당신이 필요로하는거야
이 빠르게 수행 할 수있는 데이터 구조

672
00:33:48,780 --> 00:33:50,790
효율적 동적.

673
00:33:50,790 --> 00:33:52,900
>> 그래서 가장 쉬운 가정
이 작업을 수행하는 방법을

674
00:33:52,900 --> 00:33:55,010
아마 오른쪽 배열을 만들까요?

675
00:33:55,010 --> 00:33:58,910
저장하는 가장 쉬운 방법은 당신입니다
140,000 단어의 배열을 만들 수있다

676
00:33:58,910 --> 00:34:03,400
그냥 거기에 그들 모두를 배치하고
이진 검색에 의해 그들을 통과

677
00:34:03,400 --> 00:34:06,780
또는 선택하거나 싫든
죄송합니다 그 정렬입니다.

678
00:34:06,780 --> 00:34:10,729
당신은 그 (것)를 정렬 한 다음를 통과 할 수
이진 검색하거나 선형 검색

679
00:34:10,729 --> 00:34:13,730
그냥 마지막 단어,하지만
메모리의 엄청난 금액을 소요

680
00:34:13,730 --> 00:34:15,190
그리고 그것은 매우 비효율적이다.

681
00:34:15,190 --> 00:34:18,350
>> 그래서 우리는 시작하는거야
만드는 방법에 대해 이야기

682
00:34:18,350 --> 00:34:20,110
우리의 실행 시간이 더 효율적입니다.

683
00:34:20,110 --> 00:34:23,190
그리고 우리의 목표는 얻을 것입니다
일정 시간 곳

684
00:34:23,190 --> 00:34:25,810
거의 배열처럼
당신은 즉시 액세스 할 수 있습니다.

685
00:34:25,810 --> 00:34:28,560
난 아무것도를 검색하고 싶다면,
나는 단지 할 수 있도록하려면

686
00:34:28,560 --> 00:34:30,810
붐, 정확하게 그것을 발견하고 잡아 당깁니다.

687
00:34:30,810 --> 00:34:34,100
그리고 구조하는
우리는 매우 가까이되는거야

688
00:34:34,100 --> 00:34:37,569
일정에 액세스 할 수
시간이 성배

689
00:34:37,569 --> 00:34:41,370
상수의 프로그래밍
시간은 해시 테이블이라고합니다.

690
00:34:41,370 --> 00:34:45,370
그래서 다윗은 앞서 언급 한
[들림] 강의에 조금,

691
00:34:45,370 --> 00:34:49,100
하지만 우리가 정말거야
깊은 이번 주에 다이빙

692
00:34:49,100 --> 00:34:51,780
에 관한 것 조각에
어떻게 해시 테이블 작동합니다.

693
00:34:51,780 --> 00:34:53,949
>> 그 길을 따라서 해시
테이블 작업, 예를 들면,

694
00:34:53,949 --> 00:35:00,230
나는 단어의 무리를 저장하기를 원한다면,
영어 단어의 무리,

695
00:35:00,230 --> 00:35:02,940
나는 이론적으로 넣을 수
바나나, 사과, 키위, 망고, 쌍,

696
00:35:02,940 --> 00:35:04,980
모든 단지 배열에 멜론.

697
00:35:04,980 --> 00:35:07,044
그들은 모두에 맞게 수 있고 찾을 수.

698
00:35:07,044 --> 00:35:09,210
그것은에 통증 종류의 것
액세스를 검색,

699
00:35:09,210 --> 00:35:12,920
하지만 이렇게 쉬운 방법은
우리는 구조를 실제로 만들 수 있습니다

700
00:35:12,920 --> 00:35:15,680
우리는 해시 해시 테이블이라고합니다.

701
00:35:15,680 --> 00:35:19,880
우리는을 통해 우리의 키를 모두 실행
해시 함수, 방정식

702
00:35:19,880 --> 00:35:22,600
그로 모두 전환
값의 일종

703
00:35:22,600 --> 00:35:28,740
우리는에 저장할 수
연결리스트의 본질적으로 배열.

704
00:35:28,740 --> 00:35:32,570
>> 그래서 여기에 우리가 원하는 경우
영어 단어를 저장하기 위해,

705
00:35:32,570 --> 00:35:37,250
우리는 잠재적으로 단지 수, 나는하지 않습니다
알다시피, 모든 첫 글자를 켜

706
00:35:37,250 --> 00:35:39,630
다수의 일종으로.

707
00:35:39,630 --> 00:35:43,140
그래서, 예를 들어, 내가 원
이 apple--과 동의어가 될

708
00:35:43,140 --> 00:35:47,460
0의 인덱스, 및
B는 1과 동의어가 될

709
00:35:47,460 --> 00:35:51,030
우리는 26 항목을 가질 수 있습니다
그건 그냥 저장할 수 있습니다

710
00:35:51,030 --> 00:35:53,610
의 모든 문자
우리가 시작합니다 알파벳입니다.

711
00:35:53,610 --> 00:35:56,130
그리고 우리는 할 수 있습니다
0의 인덱스에 사과.

712
00:35:56,130 --> 00:35:59,160
우리의 인덱스에 바나나를 가질 수있다
1, 2의 인덱스 멜론,

713
00:35:59,160 --> 00:36:00,540
등 등.

714
00:36:00,540 --> 00:36:04,460
그리고 이렇게 내가 검색하기를 원한다면
내 해시 테이블 및 액세스 사과,

715
00:36:04,460 --> 00:36:07,560
나는 사과로 시작 알고
그리고 나는 정확하게 알고

716
00:36:07,560 --> 00:36:10,860
그것은하고 해시해야
인덱스 0 때문에에 테이블

717
00:36:10,860 --> 00:36:13,620
기능의 이전에 할당.

718
00:36:13,620 --> 00:36:16,572
>> 나도 몰라 그래서, 우리는
사용자 프로그램 어디에

719
00:36:16,572 --> 00:36:18,780
당신과 함께 청구됩니다
임의하지 arbitrarily--,

720
00:36:18,780 --> 00:36:22,530
신중에 노력과
좋은 식의 생각

721
00:36:22,530 --> 00:36:25,460
확산 할 수 있도록
당신의 가치를 모두 밖으로

722
00:36:25,460 --> 00:36:29,370
방법들은 쉽게 접근 할 수
그것은 나중에와 방정식 등

723
00:36:29,370 --> 00:36:31,130
당신 것을 자신은 알고있다.

724
00:36:31,130 --> 00:36:35,210
나는에 가고 싶은지 의미에서 이렇게
망고, 나는 아, M로 시작, 알고있다.

725
00:36:35,210 --> 00:36:37,134
그것은 12의 인덱스에 있어야합니다.

726
00:36:37,134 --> 00:36:38,800
난 아무것도를 검색 할 필요가 없습니다.

727
00:36:38,800 --> 00:36:42,080
난 그냥 갈 수 exactly-- 나는 알고있다
12의 인덱스는 빼냅니다.

728
00:36:42,080 --> 00:36:45,520
>> 방법에 모두 클리어
해시 테이블의 기능이 작동?

729
00:36:45,520 --> 00:36:48,380
그것은 단지 더 복잡한 배열 가지입니다.

730
00:36:48,380 --> 00:36:50,010
즉, 모든이다.

731
00:36:50,010 --> 00:36:51,630
그래.

732
00:36:51,630 --> 00:36:57,690
>> 그래서 나는 우리가로 실행 같아요
이 문제를 어떻게

733
00:36:57,690 --> 00:37:06,390
여러 가지가있는 경우 발생
그것은 당신에게 같은 인덱스를 제공?

734
00:37:06,390 --> 00:37:10,570
그래서 모두에게, 그것을 우리의 기능을 말한다
한 첫 번째 편지를 가지고 있었다

735
00:37:10,570 --> 00:37:14,490
과에 그 설정
0 인덱스 (25)를 통해 각각의.

736
00:37:14,490 --> 00:37:17,137
그 경우 완전히 괜찮아요
당신은 각각 하나 있습니다.

737
00:37:17,137 --> 00:37:18,970
그러나 두 번째는 당신이 시작
더 가지고, 당신이있어

738
00:37:18,970 --> 00:37:20,910
충돌라고 무엇을해야 할 것.

739
00:37:20,910 --> 00:37:25,580
>> 내가 삽입하려고하면 해시에 묻어 그래서
이미에 바나나를 가지고 테이블,

740
00:37:25,580 --> 00:37:27,870
무엇을 할 때 일어날
당신은을 삽입하려고?

741
00:37:27,870 --> 00:37:30,930
나쁜 일 때문에 바나나
이미 인덱스 내에 존재

742
00:37:30,930 --> 00:37:33,800
당신은에 저장하려는.

743
00:37:33,800 --> 00:37:35,560
베리 종류의 나는 무엇을해야합니까, 아, 같은입니까?

744
00:37:35,560 --> 00:37:37,080
나는 어디로 가야 모르겠어요.

745
00:37:37,080 --> 00:37:38,410
나는이 문제를 어떻게 해결합니까?

746
00:37:38,410 --> 00:37:41,150
>> 그래서 너희들 것이다 가지
우리는이 어려운 일을 참조

747
00:37:41,150 --> 00:37:44,810
여기서 우리는 종류의 실제로 수
우리의 배열에 연결된 목록을 만들 수 있습니다.

748
00:37:44,810 --> 00:37:46,840
그래서 가장 쉬운 방법
이것에 대해 생각하는,

749
00:37:46,840 --> 00:37:50,830
모든 해시 테이블 인
연결리스트의 배열입니다.

750
00:37:50,830 --> 00:37:55,670
그리고, 그런 의미에서, 당신은
포인터의이 아름다운 배열,

751
00:37:55,670 --> 00:37:58,740
다음 각 포인터에
그 값, 해당 인덱스에,

752
00:37:58,740 --> 00:38:00,740
실제로 다른 일을 가리킬 수 있습니다.

753
00:38:00,740 --> 00:38:05,720
그래서 당신은 모든 개별이
하나의 큰 배열의 떨어져오고 체인.

754
00:38:05,720 --> 00:38:07,960
>> 그래서 여기에, 나는 경우
베리를 삽입하고 싶었다,

755
00:38:07,960 --> 00:38:11,220
내가 좋아, 내가 입력에 갈거야, 알
그것은 내 해시 함수를 통해.

756
00:38:11,220 --> 00:38:15,070
나는의 인덱스로 끝날거야
1을 입력 한 다음 내가 가질 수있을거야

757
00:38:15,070 --> 00:38:20,410
이 단지 작은 부분 집합
거대한 140,000 단어 사전.

758
00:38:20,410 --> 00:38:24,220
그리고 난 그냥 볼 수 있습니다
그것의 1/26을 통해.

759
00:38:24,220 --> 00:38:27,910
>> 그리고 그럼 난 그냥 삽입 할 수 있습니다
전이나 바나나 후 두 베리

760
00:38:27,910 --> 00:38:28,820
이 경우?

761
00:38:28,820 --> 00:38:29,700
후, 오른쪽?

762
00:38:29,700 --> 00:38:33,920
그래서 당신이 원하는거야
바나나 후이 노드를 삽입,

763
00:38:33,920 --> 00:38:36,667
그래서 당신은 삽입 할거야
그 연결리스트의 꼬리에서.

764
00:38:36,667 --> 00:38:38,500
나는 돌아갈거야
이 이전 슬라이드로,

765
00:38:38,500 --> 00:38:40,680
그래서 너희들은 어떻게 볼 수 있습니다
해시 기능이 작동합니다.

766
00:38:40,680 --> 00:38:43,980
>> 그래서 해시 함수는이 방정식은
당신은 당신의 입력의 종류를 실행하는 것을

767
00:38:43,980 --> 00:38:46,940
얻을 수있는 어떤 색인을 통해
당신은 방향을 지정하려면.

768
00:38:46,940 --> 00:38:51,130
그래서,이 예제에서는, 우리는 원
수행은 첫 글자를 가지고 있었다

769
00:38:51,130 --> 00:38:55,890
우리는 그 다음 인덱스로 그 설정
우리의 해시 함수에 그 저장할 수 있습니다.

770
00:38:55,890 --> 00:39:00,160
우리가 여기서하고있는 모든 우리가있어입니다
첫 글자를 변환.

771
00:39:00,160 --> 00:39:04,770
그래서 keykey [0] 단지 첫 글자
어떤 문자열 우리는 데있어,

772
00:39:04,770 --> 00:39:05,720
우리가 전달하고 있습니다.

773
00:39:05,720 --> 00:39:09,740
우리는 상부에 그 변환하고있어
우리는 대문자로 차감하고

774
00:39:09,740 --> 00:39:11,740
이렇게되는 모든
우리에게 번호를주고있다

775
00:39:11,740 --> 00:39:13,670
있는 우리는 우리의 가치를에 해시 수 있습니다.

776
00:39:13,670 --> 00:39:16,550
>> 그리고 우리는 갈거야
해시 계수의 크기를 반환합니다.

777
00:39:16,550 --> 00:39:19,340
아주, 아주 조심
이론적으로, 여기에, 때문에

778
00:39:19,340 --> 00:39:21,870
당신의 해시 값은 무한 될 수 있습니다.

779
00:39:21,870 --> 00:39:23,660
그것은 단지에와 계속적으로 갈 수 있었다.

780
00:39:23,660 --> 00:39:26,080
그것은 정말 일부가 될 수
정말 큰 값,

781
00:39:26,080 --> 00:39:29,849
하지만 해시 테이블 때문에 그
사용자가 만든 만 26 인덱스가,

782
00:39:29,849 --> 00:39:31,890
당신이 있는지 확인하려면 당신의
modulusing 있도록

783
00:39:31,890 --> 00:39:33,848
이 같은입니다 run--하지 않습니다
당신의 queue-- 같은 일이

784
00:39:33,848 --> 00:39:36,320
그래서 당신은 떨어져 실행하지 않는 것이
당신의 해시 함수의 바닥.

785
00:39:36,320 --> 00:39:39,210
>> 당신은 주위를 다시 포장 할
[들리지] 경우에 같은 방법으로

786
00:39:39,210 --> 00:39:41,750
당신은 아주 좋아했다
매우 큰 편지, 당신

787
00:39:41,750 --> 00:39:43,740
에 그것을 원하지 않았다
다만 끝을 실행합니다.

788
00:39:43,740 --> 00:39:46,948
여기에 같은 일이, 당신이 있는지 확인하려면
그것은 포장으로 끝을 실행하지 않습니다

789
00:39:46,948 --> 00:39:48,330
주위 테이블의 상단에.

790
00:39:48,330 --> 00:39:50,530
그래서이 그냥 아주
간단한 해시 함수.

791
00:39:50,530 --> 00:39:56,570
했던 그 모든 걸릴 처음
무엇이든 우리의 입력의 편지였다

792
00:39:56,570 --> 00:40:01,660
그리고 인덱스로 그를 설정하는 것이
우리는 우리의 해시 테이블에 넣을 수 있습니다.

793
00:40:01,660 --> 00:40:05,450
>> 그래, 그래서 내가 전에 말했듯이
우리가 충돌을 해결하는 방법

794
00:40:05,450 --> 00:40:09,330
우리의 해시 테이블을 가지고있다,
우리는 체인, 무엇을 호출합니다.

795
00:40:09,330 --> 00:40:13,860
여러 삽입하려고한다면
같은 일 시작하는 단어,

796
00:40:13,860 --> 00:40:16,145
당신은 하나의 해시 값을 가질 것입니다.

797
00:40:16,145 --> 00:40:18,770
아보카도와 사과, 당신이 한 경우
우리의 해시 함수를 통해 실행,

798
00:40:18,770 --> 00:40:21,450
당신에게 줄거야
같은 수의 0의 수.

799
00:40:21,450 --> 00:40:24,550
그래서 방법은 우리가 즉 해결
우리는 실제로 가지를 연결 할 수있는

800
00:40:24,550 --> 00:40:27,010
함께 연결리스트를 통해.

801
00:40:27,010 --> 00:40:29,600
>> 그리고 이러한 의미에서,
너희들은 종류 볼 수 있습니다

802
00:40:29,600 --> 00:40:32,640
방법의 데이터 구조 그
우리는 이전에 설정했습니다

803
00:40:32,640 --> 00:40:35,870
건포도 연결리스트의 종류 등
중 하나에 함께 올 수 있습니다.

804
00:40:35,870 --> 00:40:38,860
그리고 당신은 지금까지 생성 할 수 있습니다
보다 효율적인 데이터 구조

805
00:40:38,860 --> 00:40:43,350
즉, 더 많은 양을 처리 할 수​​ 있습니다
데이터, 즉 동적으로 따라 크기를 조정

806
00:40:43,350 --> 00:40:44,870
사용자의 요구에.

807
00:40:44,870 --> 00:40:45,620
모두 명확한?

808
00:40:45,620 --> 00:40:47,580
클리어의 모든 종류
여기에 무슨 일에?

809
00:40:47,580 --> 00:40:52,110
>> 내가 insert--하고 싶다면 무엇
나도 몰라, 시작 과일,

810
00:40:52,110 --> 00:40:54,726
베리 이외의 B, 바나나.

811
00:40:54,726 --> 00:40:55,710
>> 청중 : 블랙 베리.

812
00:40:55,710 --> 00:40:57,910
>> ANDI 펭 : 블랙 베리, 블랙 베리.

813
00:40:57,910 --> 00:41:00,530
어디에서 블랙 베리는 여기입니까?

814
00:41:00,530 --> 00:41:04,251
글쎄, 우리가 실제로 분류되지 않은
이 아직 있지만, 이론적으로

815
00:41:04,251 --> 00:41:06,250
우리는이를 원한다면
알파벳 순서로,

816
00:41:06,250 --> 00:41:07,944
어디로 가야 블랙 베리해야합니까?

817
00:41:07,944 --> 00:41:09,210
>> 청중 : [들리지]

818
00:41:09,210 --> 00:41:11,100
>> ANDI 펭 : 정확히, 여기에 후, 오른쪽?

819
00:41:11,100 --> 00:41:14,950
그러나 그것은 매우 어려운 이후
reorder-- 나는 너희들에게 달려 같아요.

820
00:41:14,950 --> 00:41:17,920
너희들 완전히 수
당신이 원하는대로 구현합니다.

821
00:41:17,920 --> 00:41:20,730
보다 효율적인 방법
아마도이 일을

822
00:41:20,730 --> 00:41:24,570
당신의 링크를 정렬하는 것입니다
알파벳 순서로 나열

823
00:41:24,570 --> 00:41:26,520
그래서 당신이있을 때
물건을 삽입, 당신이 원하는

824
00:41:26,520 --> 00:41:28,632
를 삽입해야합니다
알파벳 순서로

825
00:41:28,632 --> 00:41:30,590
그래서 당신이있을 때
를 검색하려고,

826
00:41:30,590 --> 00:41:32,410
당신은 모든 것을 통과 할 필요가 없습니다.

827
00:41:32,410 --> 00:41:35,290
당신은 정확히 알고
그것은이며 쉽다.

828
00:41:35,290 --> 00:41:39,100
>> 하지만 당신은 가지가있는 경우
일이 무작위로 산재

829
00:41:39,100 --> 00:41:41,420
당신은 여전히​​ 할 겁니다
어쨌든 그것을 통과한다.

830
00:41:41,420 --> 00:41:44,990
그래서 내가 원한다면 단지
블랙 베리 여기에 삽입

831
00:41:44,990 --> 00:41:47,470
내가 검색 싶어
그것은, 내가 오, 알고, 블랙 베리

832
00:41:47,470 --> 00:41:52,012
1의 인덱스로 시작, 그래서해야한다
순간적으로 단지 1 검색 알고있다.

833
00:41:52,012 --> 00:41:53,970
그리고 나는 종류의 수
연결리스트를 순회

834
00:41:53,970 --> 00:41:56,120
내가 블랙 베리에 도달 할 때까지,
그리고 그래 then--?

835
00:41:56,120 --> 00:41:59,550
>> 청중 : 당신은 create--하려는 경우
이것은 매우 간단한 해시처럼 같아요

836
00:41:59,550 --> 00:42:00,050
기능.

837
00:42:00,050 --> 00:42:02,835
그리고 우리는 무엇을 원하는 경우
그런 여러 계층,

838
00:42:02,835 --> 00:42:05,870
확인, 우리는로 구분합니다
모든 알파벳 문자 등

839
00:42:05,870 --> 00:42:09,040
다시 또 다른 세트를 좋아합니다
그 내에서 알파벳 문자,

840
00:42:09,040 --> 00:42:11,715
우리는 해시처럼 퍼팅
해시 테이블 내의 테이블,

841
00:42:11,715 --> 00:42:13,256
또는 함수 내에서 함수처럼?

842
00:42:13,256 --> 00:42:14,880
아니면 that--입니다

843
00:42:14,880 --> 00:42:17,510
>> ANDI 펭 : 당신의 해시 그래서
당신의 해시 테이블을 function--

844
00:42:17,510 --> 00:42:19,360
당신이 원하는만큼 커질 수있다.

845
00:42:19,360 --> 00:42:21,930
그래서 이런 의미에서, 나는 생각했다
그것은 매우 쉬웠다

846
00:42:21,930 --> 00:42:25,320
나를 위해 간단한 단지 종류를 기반으로하는
첫 번째 단어의 문자에.

847
00:42:25,320 --> 00:42:28,690
그리고 만 26 옵션이있다.

848
00:42:28,690 --> 00:42:32,650
난 단지 26 옵션을 얻을 수 있습니다
0-25 때문에 그들은 단지 수

849
00:42:32,650 --> 00:42:36,510
에서 (Z)로 시작하지만, 당신이 원하는 경우
아마도 더 복잡성을 추가하는

850
00:42:36,510 --> 00:42:39,260
또는 빠른 시간을 실행하여
해시 테이블, 당신이 절대적으로

851
00:42:39,260 --> 00:42:40,760
모든 종류의 것들을 할 수 있습니다.

852
00:42:40,760 --> 00:42:43,330
당신은 당신의 자신의 수
당신을 제공 방정식

853
00:42:43,330 --> 00:42:48,000
더 많은 분배하여
말은, 당신은, 검색 할 때

854
00:42:48,000 --> 00:42:49,300
더 빨리 될 것.

855
00:42:49,300 --> 00:42:52,100
>> 그것은 완전히 너희들에게 달려
당신은 어떻게 그것을 구현하려는.

856
00:42:52,100 --> 00:42:55,140
단지 버킷이라고 생각.

857
00:42:55,140 --> 00:42:57,376
내가하고 싶어하는 경우
26 양동이, 내가 갈거야

858
00:42:57,376 --> 00:42:59,420
그 양동이에 물건을 정렬 할 수 있습니다.

859
00:42:59,420 --> 00:43:02,980
하지만 무리가 갈거야
각 버킷의 물건,

860
00:43:02,980 --> 00:43:05,890
당신이 그것을 만들고 싶어 이렇게
더 빠르고 더 효율적인

861
00:43:05,890 --> 00:43:07,190
나 백 버킷을 보자.

862
00:43:07,190 --> 00:43:09,290
>> 하지만 당신은을 파악해야
그들이 있도록 방법은 일을 정렬하려면

863
00:43:09,290 --> 00:43:11,040
적절한 양동이에 그들에 있어야합니다.

864
00:43:11,040 --> 00:43:13,331
그러나 때 실제로
그 통에보고 싶은,

865
00:43:13,331 --> 00:43:16,410
거기에 있기 때문에 훨씬 빠릅니다
각 양동이에 작은 물건.

866
00:43:16,410 --> 00:43:20,250
그리고, 네, 사실입니다
pset5에서 너희들을위한 트릭

867
00:43:20,250 --> 00:43:22,360
당신이 될 것이다
바로 만들 수 도전

868
00:43:22,360 --> 00:43:26,170
가장 효율적인 무엇이다
당신이 생각할 수있는 기능을 할 수

869
00:43:26,170 --> 00:43:28,520
저장하고이 값을 확인할 수.

870
00:43:28,520 --> 00:43:30,840
>> 완전히 너희들까지
그러나 당신이 그것을하고 싶은,

871
00:43:30,840 --> 00:43:32,229
하지만 그건 정말 좋은 점이다.

872
00:43:32,229 --> 00:43:34,520
그 논리의 종류의
에 대해 생각을 시작하려는

873
00:43:34,520 --> 00:43:37,236
물론, 내가 왜 더 버킷을하지 않는 것입니다.

874
00:43:37,236 --> 00:43:39,527
그리고 내가 검색해야
적은 것, 그리고 아마 내가

875
00:43:39,527 --> 00:43:41,640
서로 다른 해시 함수를 갖는다.

876
00:43:41,640 --> 00:43:45,500
>> 그래,이 작업을 수행하는 방법은 여러가지가있다
PSET, 일부는 다른 사람보다 더 빠르다.

877
00:43:45,500 --> 00:43:50,630
나는 완전히 얼마나 볼거야
빠른 가장 빠른 너희들 것이었다

878
00:43:50,630 --> 00:43:55,170
당신의 기능을 작동시킬 수 있습니다.

879
00:43:55,170 --> 00:43:58,176
확인, 모두 좋은에
체인 및 해시 테이블?

880
00:43:58,176 --> 00:44:00,800
그것은 매우 간단한처럼 사실이다
당신은 그것에 대해 개념을 생각하면.

881
00:44:00,800 --> 00:44:05,160
그것이 모두 분리 무엇이든
당신의 입력은 버킷에 있습니다,

882
00:44:05,160 --> 00:44:10,670
그들을 정렬하고 찾고
거기 연관된 것을 보여줍니다.

883
00:44:10,670 --> 00:44:11,852
>> 시원한.

884
00:44:11,852 --> 00:44:18,160
자, 이제 우리는 다른 종류가
데이터 구조의 트리라고있다.

885
00:44:18,160 --> 00:44:20,850
의가 가자와 시도에 대해 이야기
이는, 분명히 다르다

886
00:44:20,850 --> 00:44:22,330
하지만 같은 범주에.

887
00:44:22,330 --> 00:44:29,010
기본적으로 모든 나무 대신하다
선형의 방식으로 데이터를 조직

888
00:44:29,010 --> 00:44:32,560
해시 테이블을 does-- 있음
그것은 상단과 하단을 가지고 알고

889
00:44:32,560 --> 00:44:37,900
그리고 당신은 가지 그건 ... 떨어져 링크
나무는, 루트를 호출하는 상단이

890
00:44:37,900 --> 00:44:40,220
다음 모든 주위 잎을 가지고있다.

891
00:44:40,220 --> 00:44:42,390
>> 그리고 모든 당신은 여기에있다
다만 최상위 노드입니다

892
00:44:42,390 --> 00:44:45,980
즉, 다른 노드에, 가리 포인트
더 많은 노드들, 및 등등 등등.

893
00:44:45,980 --> 00:44:48,130
그래서 당신은 분할 지점을 가지고.

894
00:44:48,130 --> 00:44:53,255
그것은 조직의 단지 다른 방법
데이터, 우리가 나무 호출하기 때문에,

895
00:44:53,255 --> 00:44:56,270
너희들은 그냥 그냥 ...
나무처럼 밖으로 모델.

896
00:44:56,270 --> 00:44:57,670
우리가 나무를 호출하는 이유입니다.

897
00:44:57,670 --> 00:44:59,370
>> 해시 테이블은 테이블처럼 보인다.

898
00:44:59,370 --> 00:45:01,310
나무는 나무처럼 보인다.

899
00:45:01,310 --> 00:45:03,300
그것이 전부 별도
노드를 조직하는 방법

900
00:45:03,300 --> 00:45:06,020
사용자의 요구가 무엇인지에 따라 달라집니다.

901
00:45:06,020 --> 00:45:11,810
>> 그래서 당신은 루트를 가지고
당신은 잎이있다.

902
00:45:11,810 --> 00:45:15,380
방법이 우리가 특히 수
이 이진 트리입니다 생각,

903
00:45:15,380 --> 00:45:18,150
이진 트리 단지입니다
나무의 특정 유형

904
00:45:18,150 --> 00:45:22,450
여기서 각 노드는 포인트
에, 최대의, 두 개의 다른 노드.

905
00:45:22,450 --> 00:45:25,434
그래서 여기에 당신은 별개의이
당신의 나무에 대칭

906
00:45:25,434 --> 00:45:28,600
즉, 쉽게 가지 볼 수 있습니다
값 무엇 당신은 당신 때문입니다

907
00:45:28,600 --> 00:45:30,150
항상 왼쪽 또는 오른쪽 있습니다.

908
00:45:30,150 --> 00:45:33,150
에서 왼쪽 세 번째처럼 결코 없다
왼쪽 또는 왼쪽에서 네 번째.

909
00:45:33,150 --> 00:45:36,358
그것은 당신이 왼쪽과 오른쪽이 단지
당신은 그 두 가지 중 하나를 검색 할 수 있습니다.

910
00:45:36,358 --> 00:45:38,980
그리고 왜이 유용합니다?

911
00:45:38,980 --> 00:45:40,980
이되는 방법
당신이 찾고있는 경우에 유용입니다

912
00:45:40,980 --> 00:45:42,890
오른쪽 값을 검색하는 방법?

913
00:45:42,890 --> 00:45:45,640
오히려 바이너리를 구현하는 것보다
오류 배열 검색

914
00:45:45,640 --> 00:45:49,260
당신은 노드를 삽입 할 수 원한다면
마음대로 또한 노드를 빼앗아

915
00:45:49,260 --> 00:45:52,185
검색을 보존
이진 검색의 용량.

916
00:45:52,185 --> 00:45:54,560
그래서이 방법으로, 우리는 종류의 것
때 기억 tricking--

917
00:45:54,560 --> 00:45:56,530
연결리스트는 이진 검색을 할 수 없습니다했다?

918
00:45:56,530 --> 00:46:01,700
우리는 가지 데이터 구조를 만드는
트릭 작업에 그 것이다.

919
00:46:01,700 --> 00:46:05,034
>> 그래서 때문에 연결리스트는, 선형
그들은 단지 차례로 연결한다.

920
00:46:05,034 --> 00:46:06,950
우리는 종류의 수 있습니다
포인터의 다른 종류

921
00:46:06,950 --> 00:46:09,408
서로 다른 노드를 가리키는
즉, 검색으로 우리를 도울 수있다.

922
00:46:09,408 --> 00:46:12,590
그리고 여기, 경우 내가 원한
이진 검색 트리를 가지고,

923
00:46:12,590 --> 00:46:14,090
나도 내 중간 그 (55)의 경우.

924
00:46:14,090 --> 00:46:18,280
나는 단지를 만들거야
내 중간으로, 내 루트로,

925
00:46:18,280 --> 00:46:20,770
다음 내가 가진거야
값은 그것의 스핀 오프.

926
00:46:20,770 --> 00:46:25,610
>> 그래서 여기, 내가 검색거야 경우
(66)의 값은, 나는 55에서 시작할 수 있습니다.

927
00:46:25,610 --> 00:46:27,310
그것은 55 이상 66 이상입니까?

928
00:46:27,310 --> 00:46:30,970
네, 그것은, 그래서 내가 검색 뮤스 알고
나는 N이 트리의 오른쪽 포인터.

929
00:46:30,970 --> 00:46:32,440
나는 77로 이동합니다.

930
00:46:32,440 --> 00:46:35,367
OK보다 작거나 77보다 66?

931
00:46:35,367 --> 00:46:37,950
오, 그것보다, 그래서 당신이 알고,
즉, 왼쪽 노드 수있다.

932
00:46:37,950 --> 00:46:41,410
>> 그래서 여기에 우리가 가지 보존하고
배열에 대한 중대한 것의 모든,

933
00:46:41,410 --> 00:46:44,420
그래서 동적 크기 조정 등
객체로, 인

934
00:46:44,420 --> 00:46:49,530
삽입하고 마음대로 삭제할 수,
고정에 대해 걱정할 필요없이

935
00:46:49,530 --> 00:46:50,370
공간의 양.

936
00:46:50,370 --> 00:46:52,820
우리는 여전히 모든 보존
그 놀라운 일들

937
00:46:52,820 --> 00:46:57,140
또한 보존 할 수있는 동안
로그인 이진 검색의 시간을 검색

938
00:46:57,140 --> 00:47:00,450
우리가 이전 만 있다고
문구를 얻을 수.

939
00:47:00,450 --> 00:47:06,310
>> 쿨 데이터 구조, 종류의
복합체는, 노드를 구현하는 방법.

940
00:47:06,310 --> 00:47:08,311
당신은 모든 것을 볼 수 있듯이
노드의 구조체이다

941
00:47:08,311 --> 00:47:10,143
당신이 왼쪽을 가지고있다
그리고 오른쪽 포인터.

942
00:47:10,143 --> 00:47:11,044
즉, 모든이다.

943
00:47:11,044 --> 00:47:12,960
그래서 오히려 단지보다
X 또는 이전을 가진.

944
00:47:12,960 --> 00:47:15,920
그런 다음 왼쪽 또는 오른쪽, 그리고이
당신은 가지를 함께 연결할 수 있습니다

945
00:47:15,920 --> 00:47:16,836
그러나 그렇게 선택합니다.

946
00:47:16,836 --> 00:47:21,080

947
00:47:21,080 --> 00:47:24,270
>> 확인, 우리가 실제로거야
몇 분 정도 걸릴.

948
00:47:24,270 --> 00:47:25,790
그래서 우리는 여기에 다시 갈 것입니다.

949
00:47:25,790 --> 00:47:28,270
나는 이전에 말했듯이,
나는 종류의 설명

950
00:47:28,270 --> 00:47:31,520
우리 방법 뒤에 논리
이를 통해 검색 할 것입니다.

951
00:47:31,520 --> 00:47:33,860
우리는 시도 할거야
이 아웃 pseudocoding하면 볼 수

952
00:47:33,860 --> 00:47:38,000
우리는 가지를 적용 할 수있는 경우
이진 검색의 같은 논리

953
00:47:38,000 --> 00:47:40,055
데이터 구조의 다른 타입.

954
00:47:40,055 --> 00:47:45,049
너희들은 몇처럼 먹고 싶어하는 경우
분은이에 대해 생각합니다.

955
00:47:45,049 --> 00:48:45,927

956
00:48:45,927 --> 00:48:46,925
그래.

957
00:48:46,925 --> 00:48:51,407
좋아, 내가 갈거야
실제로 당신이 어떤을 가까이 대고주지,

958
00:48:51,407 --> 00:48:52,990
우리는 먼저 의사에 대해 이야기 할 것입니다.

959
00:48:52,990 --> 00:48:56,580
그래서 사람이 원하는 않습니다
에 자상을주고 무엇을

960
00:48:56,580 --> 00:49:02,100
당신이 때 수행 할 첫 번째 일
당신은 검색이 밖으로 시작하는거야?

961
00:49:02,100 --> 00:49:04,460
우리는을 찾고 있다면
(66)의 값은, 무엇이다

962
00:49:04,460 --> 00:49:07,940
우리가 경우 수행 할 첫 번째 일
우리는이 트리를 검색 이진 싶어?

963
00:49:07,940 --> 00:49:10,760
>> 청중 : 당신이 바로보고 싶어
및 [들리지]을 왼쪽을보고 참조

964
00:49:10,760 --> 00:49:11,230
더 많은 수의.

965
00:49:11,230 --> 00:49:12,271
>> ANDI 펭 : 네, 정확히.

966
00:49:12,271 --> 00:49:15,350
그래서 당신은 루트 볼 것입니다.

967
00:49:15,350 --> 00:49:18,180
당신이 호출 할 수있는 많은 방법이있다
그것은 당신의 부모 노드 사람들은 말한다.

968
00:49:18,180 --> 00:49:21,317
나는 때문에 루트를 말씀 드리고
이는 트리의 루트 같다.

969
00:49:21,317 --> 00:49:23,400
당신은 볼거야
루트 노드, 당신은있어

970
00:49:23,400 --> 00:49:26,940
볼가는 66 크다
이상 또는 55 미만.

971
00:49:26,940 --> 00:49:30,360
그리고 물론, 그것이보다 큰 있다면
보다 큰, 우리는 어디에서 볼 하시겠습니까?

972
00:49:30,360 --> 00:49:32,000
어디 우리가 바로 지금 검색 하시겠습니까?

973
00:49:32,000 --> 00:49:34,340
우리는을 검색 할
이 나무의 오른쪽 절반.

974
00:49:34,340 --> 00:49:38,390
>> 그래서 우리가 편리하게,
오른쪽을 가리키는 포인터.

975
00:49:38,390 --> 00:49:44,325
그래서 우리는 설정할 수 있습니다
우리의 새로운 루트 77합니다.

976
00:49:44,325 --> 00:49:46,450
우리는 어디든지 갈 수
포인터가 가리키는.

977
00:49:46,450 --> 00:49:49,100
음, 아, 우리가 시작하고
77, 우리는 할 수

978
00:49:49,100 --> 00:49:51,172
반복적으로 또 다시 이렇게.

979
00:49:51,172 --> 00:49:52,880
이러한 방법으로, 당신 종류
의 기능을 갖는다.

980
00:49:52,880 --> 00:49:57,430
당신은 당신이 있는지 검색하는 방법이
단지 이상 이상 이상 반복 할 수 있습니다,

981
00:49:57,430 --> 00:50:02,720
당신이보고 싶은 위치에 따라
당신은 결국 값에 도달 할 때까지

982
00:50:02,720 --> 00:50:04,730
당신이 검색하는 그.

983
00:50:04,730 --> 00:50:05,230
이해가?

984
00:50:05,230 --> 00:50:07,800
>> 나는 당신에게 실제를 보여 주려고
코드, 그리고 많은 코드이다.

985
00:50:07,800 --> 00:50:08,674
필요가 흥분 없습니다.

986
00:50:08,674 --> 00:50:09,910
우리는 그것을 통해 이야기 할 것이다.

987
00:50:09,910 --> 00:50:13,410

988
00:50:13,410 --> 00:50:14,020
>> 사실, 아니.

989
00:50:14,020 --> 00:50:15,061
그건 그냥 의사였다.

990
00:50:15,061 --> 00:50:17,860
좋아, 그냥 의사이었다
이는 조금 복잡,

991
00:50:17,860 --> 00:50:19,751
하지만 완전히 괜찮아요.

992
00:50:19,751 --> 00:50:21,000
여기에 모든 사람을 따라 다음?

993
00:50:21,000 --> 00:50:24,260
루트가 null의 경우, 반환
거짓 그 의미하기 때문에

994
00:50:24,260 --> 00:50:26,850
당신도 거기에 아무것도하지 않습니다.

995
00:50:26,850 --> 00:50:31,376
>> 루트 N은 그렇다면 값이되어 있으면
당신이보고있는 하나 될 일이,

996
00:50:31,376 --> 00:50:34,000
당신은 true를 돌려거야
당신이 알고 있기 때문에 당신은 그것을 발견했다.

997
00:50:34,000 --> 00:50:36,250
하지만, 값이 작 으면
N의 루트가 아닌, 당신이있어

998
00:50:36,250 --> 00:50:38,332
왼쪽을 검색 할 것
아이 또는 왼쪽 잎,

999
00:50:38,332 --> 00:50:39,540
당신은 전화를 원하는대로.

1000
00:50:39,540 --> 00:50:41,750
및 루트 값보다 크면,
당신은 바로 트리를 검색 할거야,

1001
00:50:41,750 --> 00:50:44,610
다음 단지 기능을 실행할
검색을 통해 다시.

1002
00:50:44,610 --> 00:50:48,037
>> 그리고 루트는 널 (null)입니다 그 경우
당신은 끝에 도달 한 것을 의미?

1003
00:50:48,037 --> 00:50:50,120
즉, 더 당신이 가지고있는 의미
더 많은 잎을 검색하려면

1004
00:50:50,120 --> 00:50:52,230
당신은 나는, 오, 알고
그것은 여기에없는 것 같아요

1005
00:50:52,230 --> 00:50:55,063
내가 통해 검토 한 후 때문에
그것은 여기 없어 모든 일,

1006
00:50:55,063 --> 00:50:56,930
그냥 여기되지 않을 수 있습니다.

1007
00:50:56,930 --> 00:50:58,350
>> 그 모두에게 의미가 있습니까?

1008
00:50:58,350 --> 00:51:03,230
그래서 보존 이진 검색처럼
연결리스트의 기능을 제공합니다.

1009
00:51:03,230 --> 00:51:09,200
쿨, 그래서 제 2 타입
데이터 구조 너희들의

1010
00:51:09,200 --> 00:51:13,180
당신의 PSET에 구현하는 시도 할 수 있습니다,
당신은 단지 하나의 방법을 선택해야합니다.

1011
00:51:13,180 --> 00:51:19,430
그러나 아마 다른 방법에
해시 테이블은 우리가 트라이를 호출 할 것입니다.

1012
00:51:19,430 --> 00:51:24,080
>> 모든 트라이 인
나무의 특정 유형이

1013
00:51:24,080 --> 00:51:28,600
다른 값에 가서 값을 가지고있다.

1014
00:51:28,600 --> 00:51:31,450
그래서 대신에 바이너리를 갖는
의미에서 나무 하나 그

1015
00:51:31,450 --> 00:51:35,940
일이 두 가지를 가리킬 수 있습니다, 당신은 할 수 있습니다
많은, 많은 일을 한 가지 포인트.

1016
00:51:35,940 --> 00:51:39,450
당신은 본질적으로 배열을 가지고
그 중 당신이 저장 내부

1017
00:51:39,450 --> 00:51:41,790
다른 배열을 가리 포인터.

1018
00:51:41,790 --> 00:51:45,210

1019
00:51:45,210 --> 00:51:49,460
>> 그래서 우리는 방법의 노드
트라이을 정의하는 것

1020
00:51:49,460 --> 00:51:52,590
우리가 가지고 싶은 것입니다
부울, C 단어, 오른쪽?

1021
00:51:52,590 --> 00:51:54,920
따라서 노드는 부울
, 참 또는 거짓 같은

1022
00:51:54,920 --> 00:51:58,490
의 머리에 먼저
그 배열이 단어는?

1023
00:51:58,490 --> 00:52:03,620
둘째, 당신은 포인터를 갖고 싶어
무엇에 나머지입니다.

1024
00:52:03,620 --> 00:52:07,470
비트 단지, 비트 추상,하지만
나는 무엇을 모든 수단을 설명합니다.

1025
00:52:07,470 --> 00:52:13,800
>> 그래서 여기, 상단에, 당신의 경우
배열 이미 선언 한,

1026
00:52:13,800 --> 00:52:17,040
부울이 노드
전면에 저장된 값

1027
00:52:17,040 --> 00:52:19,490
즉,이 단어는 이야기?

1028
00:52:19,490 --> 00:52:20,520
이되지는 말씀인가요?

1029
00:52:20,520 --> 00:52:23,240
그리고 당신은이
배열의 나머지 그

1030
00:52:23,240 --> 00:52:26,040
실제로 저장 모든
그것이 될 수 있는지의 가능성.

1031
00:52:26,040 --> 00:52:28,660
따라서, 예를 들어, 추천
상단에, 당신은

1032
00:52:28,660 --> 00:52:32,140
true 또는 말한다 먼저
거짓, 예 또는 아니오,이 단어입니다.

1033
00:52:32,140 --> 00:52:38,130
>> 그리고 당신은 26을 통해 0이
당신이 저장할 수있는 문자.

1034
00:52:38,130 --> 00:52:42,790
나는 검색하고 싶다면
박쥐, 나는 상단으로 이동

1035
00:52:42,790 --> 00:52:49,200
그리고 내가에서 B를 찾을 B. 찾아 내
배열, 그래서 나는 알고있다, 확인, B는 말씀입니까?

1036
00:52:49,200 --> 00:52:53,010
B 정도로 따라서, 워드 아니다
나는 검색을 유지해야합니다.

1037
00:52:53,010 --> 00:52:56,410
나는 B에서 이동하고 난에 보면
B쪽으로 가리키는 포인터

1038
00:52:56,410 --> 00:53:00,900
나는, 정보의 또 다른 배열을 참조
우리가 전에했던 동일한 구조.

1039
00:53:00,900 --> 00:53:05,240
>> 그리고, 오 다음을 here--
[들림]에 편지 A.입니다

1040
00:53:05,240 --> 00:53:07,210
그래서 우리는 그 배열에 봐.

1041
00:53:07,210 --> 00:53:10,860
우리는 여덟 번째 값을 찾아,
그리고, 우리는, 아,보고보고

1042
00:53:10,860 --> 00:53:12,840
이봐,하는 말 것을, B-은 단어인가?

1043
00:53:12,840 --> 00:53:13,807
이 단어가 아닙니다.

1044
00:53:13,807 --> 00:53:14,890
우리는 계속 찾고있어.

1045
00:53:14,890 --> 00:53:17,850
>> 그래서 우리는 어디에보고
포인트 포인터

1046
00:53:17,850 --> 00:53:21,130
그리고 다른 방법을 가리키는
이는 우리가 더 많은 값을 저장해야합니다.

1047
00:53:21,130 --> 00:53:24,150
그리고 결국, 우리는 도착
단어 B-A-T,.

1048
00:53:24,150 --> 00:53:25,970
그래서 다음 번에
당신이 보면, 당신은거야

1049
00:53:25,970 --> 00:53:30,850
예,의 확인을 가지고,
이 부울 함수는 사실이다.

1050
00:53:30,850 --> 00:53:35,450
그래서 의미에서 우리는 친절
배열과 나무를 가진.

1051
00:53:35,450 --> 00:53:39,890
>> 그럼 당신은 가지 아래를 검색 할 수 있습니다.

1052
00:53:39,890 --> 00:53:43,650
오히려 기능을 해싱 이상 및
연결리스트로 값을 할당,

1053
00:53:43,650 --> 00:53:49,190
당신은 단지를 구현할 수 있습니다
downwords 검색 트라이.

1054
00:53:49,190 --> 00:53:50,850
정말, 정말 물건을 복잡.

1055
00:53:50,850 --> 00:53:54,060
내가 좋아하는이기 때문에 생각하는 것은 쉽지 않다
많은 데이터 구조를 침

1056
00:53:54,060 --> 00:53:58,710
당신,하지만 가지 모두를 수행
이 논리가 작동하는 방법을 이해?

1057
00:53:58,710 --> 00:54:01,920
>> 그래 좋아.

1058
00:54:01,920 --> 00:54:05,600
그래서 B-A-T, 다음
당신은 검색 할 것입니다.

1059
00:54:05,600 --> 00:54:07,940
당신이거야 다음에
오, 이봐, 그 사실을 참조하고,

1060
00:54:07,940 --> 00:54:09,273
따라서 나는이 단어해야합니다 알고 있습니다.

1061
00:54:09,273 --> 00:54:12,030

1062
00:54:12,030 --> 00:54:13,770
>> 동물원에 대한 똑같은.

1063
00:54:13,770 --> 00:54:17,960
그래서 여기 일이 있다면, 지금의 우리
지금, 동물원을 검색하고 싶어,

1064
00:54:17,960 --> 00:54:20,780
현재 동물원은 아니다
우리의 사전에있는 단어

1065
00:54:20,780 --> 00:54:25,300
때문에 너희들은,를 볼 수 있습니다
우리는 부울이 처음

1066
00:54:25,300 --> 00:54:28,590
반환 진정한 줌의 끝 부분에 있습니다.

1067
00:54:28,590 --> 00:54:30,430
우리는 Z-O-O-M이있다.

1068
00:54:30,430 --> 00:54:33,900
>> 그리고 여기, 우리가 실제로 필요가 없습니다
우리 사전에 단어, 동물원,

1069
00:54:33,900 --> 00:54:36,070
이 확인란을 선택하지 않은 때문이다.

1070
00:54:36,070 --> 00:54:39,540
그래서 컴퓨터는하지 않습니다
동물원이 단어는 것을 알고

1071
00:54:39,540 --> 00:54:42,430
때문에 우리가했습니다 방법
만 줌 여기서, 저장

1072
00:54:42,430 --> 00:54:44,920
실제로 부울 값을 가지고
그는 사실 켜져 있습니다.

1073
00:54:44,920 --> 00:54:49,380
우리가를 삽입 할 경우에 따라서
단어, 동물원, 우리 사전에,

1074
00:54:49,380 --> 00:54:51,770
우리는 그 일에 대해 어떻게 갈 것인가?

1075
00:54:51,770 --> 00:54:55,960
우리는 확인해야 할 일을 우리의
컴퓨터는 Z-O-O 단어는 것을 알고있다

1076
00:54:55,960 --> 00:54:58,130
아닌 첫 번째 단어는 Z-O-O-M은?

1077
00:54:58,130 --> 00:54:59,360
>> 청중 : [들리지]

1078
00:54:59,360 --> 00:55:01,450
>> ANDI 펭 : 정확히, 우리
이 있는지 확인하려면

1079
00:55:01,450 --> 00:55:07,890
여기, 그 부울 값입니다
그게 사실 것을 체크 해제.

1080
00:55:07,890 --> 00:55:13,297
Z-O-O는, 우리는 그것을 확인하는거야,
그래서 우리는 정확하게, 헤이, 동물원 단어 알고있다.

1081
00:55:13,297 --> 00:55:15,380
나는 말할거야
이 단어는 그래서 컴퓨터

1082
00:55:15,380 --> 00:55:18,000
때 컴퓨터를 확인하는
이 동물원은 단어임을 알고있다.

1083
00:55:18,000 --> 00:55:21,269
>> 이러한 모든 데이터를 기억하고 있기 때문에
구조, 그것은 우리에게 매우 쉽다

1084
00:55:21,269 --> 00:55:22,310
오, 박쥐 단어의 말을한다.

1085
00:55:22,310 --> 00:55:22,851
동물원 단어입니다.

1086
00:55:22,851 --> 00:55:23,611
줌 단어입니다.

1087
00:55:23,611 --> 00:55:25,860
그러나 당신이 그것을 구축 할 때,
컴퓨터가 아무 생각이 없습니다.

1088
00:55:25,860 --> 00:55:28,619
>> 그래서 당신은 정확히 말할 필요
어떤 점에서이 단어는?

1089
00:55:28,619 --> 00:55:29,910
어떤 시점에서이 단어가 아니다?

1090
00:55:29,910 --> 00:55:31,784
그리고 어느 시점에서 내가 할
물건을 검색 할 필요가있다,

1091
00:55:31,784 --> 00:55:34,000
어떤 점에서 나는 다음에 갈 필요합니까?

1092
00:55:34,000 --> 00:55:37,010
그 명확한 모두?

1093
00:55:37,010 --> 00:55:39,540
시원한.

1094
00:55:39,540 --> 00:55:42,530
>> 그리고 다음 온다
의 문제를 우리가 어떻게 것

1095
00:55:42,530 --> 00:55:45,560
뭔가를 삽입하는 방법에 대한 이동
즉,이 사실이 아니다?

1096
00:55:45,560 --> 00:55:49,090
그래서 그냥 우리가 삽입 할 가정 해 봅시다
우리의 트라이로 단어, 목욕,.

1097
00:55:49,090 --> 00:55:53,589
너희들은 현재처럼 볼 수 있듯이
우리가 지금해야하는 것은, B-A-T입니다

1098
00:55:53,589 --> 00:55:55,630
이 새로운 데이터 구조
파인트가 있다고

1099
00:55:55,630 --> 00:55:59,740
우리가 생각하기 때문에 null로 지적
오, B-A-T 후 어떤 단어가 없습니다 것을,

1100
00:55:59,740 --> 00:56:02,530
왜 우리는 계속해야합니까
그 T. 후 물건을 가지고

1101
00:56:02,530 --> 00:56:06,581
>> 우리는 당신을한다면 문제가 발생
다음에 오는 단어를 갖고 싶어

1102
00:56:06,581 --> 00:56:07,080
T의.

1103
00:56:07,080 --> 00:56:09,500
당신이 목욕이있는 경우있어
H의 권리를 원하는 것.

1104
00:56:09,500 --> 00:56:13,290
그래서 우리가 그것을 할 거 야 방법은
우리는 별도의 노드를 만들 것입니다.

1105
00:56:13,290 --> 00:56:16,840
우리는 어떤 금액을 충당하지 않을
이 새로운 배열의 메모리,

1106
00:56:16,840 --> 00:56:20,720
우리는 포인터를 재 할당 할 것입니다.

1107
00:56:20,720 --> 00:56:22,947
>> 우리는을 할당 할거야
H, 우선,이 NULL,

1108
00:56:22,947 --> 00:56:24,030
우리는 제거하는 것입니다.

1109
00:56:24,030 --> 00:56:26,590
우리는 할 겁니다
H 포인트 아래로.

1110
00:56:26,590 --> 00:56:30,600
우리는 H를 참조하면, 우리는 원하는
다른 곳으로 이동합니다.

1111
00:56:30,600 --> 00:56:33,910
>> 여기에서 우리는 다음 예를 꺼 확인할 수 있습니다.

1112
00:56:33,910 --> 00:56:38,170
우리는 T 후 H를 칠 경우, 오,
우리는이 단어 것을 알고 있습니다.

1113
00:56:38,170 --> 00:56:41,110
부울 true를 반환하는 것입니다.

1114
00:56:41,110 --> 00:56:42,950
모두 무슨 일이 있었 방법에 대한 명확한?

1115
00:56:42,950 --> 00:56:45,110
그래.

1116
00:56:45,110 --> 00:56:47,214
>> 그래서 본질적으로, 모든
이러한 데이터 구조

1117
00:56:47,214 --> 00:56:50,130
우리가 오늘을 통해 갔어요 것을, 나는했습니다
정말, 정말 빨리 그들을 사라

1118
00:56:50,130 --> 00:56:52,192
그리고별로에의를
세부 사항, 그리고 괜찮아요.

1119
00:56:52,192 --> 00:56:53,900
당신은 장난 시작하면
그것으로, 당신은 수 있습니다

1120
00:56:53,900 --> 00:56:55,733
위치를 추적 유지
모든 포인터이다

1121
00:56:55,733 --> 00:56:58,060
무슨에서 일어나는 당신의
데이터 구조, 기타 등등.

1122
00:56:58,060 --> 00:56:59,810
그들은 매우 유용 할 것이다
그것은 당신에게 달려 있습니다

1123
00:56:59,810 --> 00:57:03,890
사람은 완전히 방법을 알아낼
당신은 물건을 구현하려는.

1124
00:57:03,890 --> 00:57:07,650
>> 그래서 pset4,의 5-- 아, 그건 잘못된 것입니다.

1125
00:57:07,650 --> 00:57:10,140
Pset5는 맞춤법 오류입니다.

1126
00:57:10,140 --> 00:57:13,710
내가 전에 말했듯이, 당신은 한 번에가는거야
다시, 우리의 소스 코드를 다운로드합니다.

1127
00:57:13,710 --> 00:57:16,210
세 가지 주요있을거야
이것은 당신이 다운로드됩니다.

1128
00:57:16,210 --> 00:57:18,470
당신은 사전을 다운로드 할 수 있습니다
KERS, 및 텍스트.

1129
00:57:18,470 --> 00:57:21,660
>> 모든 것들은있다
두 단어의 사전

1130
00:57:21,660 --> 00:57:25,190
우리는 당신이 확인하고 싶은 것을
또는 정보의 테스트

1131
00:57:25,190 --> 00:57:26,930
우리는 당신이 체크를 주문하려는.

1132
00:57:26,930 --> 00:57:29,670
그래서 사전
우리는 당신이가는 줄

1133
00:57:29,670 --> 00:57:34,870
당신에게 우리가 원하는 실제 단어를 제공합니다
당신의 방식으로 어떻게 든 저장하기

1134
00:57:34,870 --> 00:57:36,530
보다 효율적인 어레이.

1135
00:57:36,530 --> 00:57:38,470
그리고 텍스트는
우리가있는 무슨 될 것

1136
00:57:38,470 --> 00:57:43,900
묻는 것이 있는지 확인하십시오 철자
모든 단어 실제 단어들이있다.

1137
00:57:43,900 --> 00:57:47,970
>> 의 그리고 세 블록
우리는 당신이주지 프로그램

1138
00:57:47,970 --> 00:57:51,130
dictionary.c라고,
dictionary.h 및 speller.c.

1139
00:57:51,130 --> 00:57:56,500
그리고 모든 dictionary.c입니다 않습니다
당신은 무엇을 구현하도록 요청하고 있습니다.

1140
00:57:56,500 --> 00:57:57,880
그것은 단어를로드합니다.

1141
00:57:57,880 --> 00:58:02,000
그것은 검사에게 그 철자, 그리고 그것을 확인한다
모든 것이 제대로 삽입됩니다.

1142
00:58:02,000 --> 00:58:05,180
>> diction.h 그냥 라이브러리 파일입니다
그 모든 기능을 선언합니다.

1143
00:58:05,180 --> 00:58:07,650
그리고 speller.c, 우리는 당신을 줄 것입니다.

1144
00:58:07,650 --> 00:58:09,290
당신은 어떤을 수정할 필요가 없습니다.

1145
00:58:09,290 --> 00:58:14,290
모든 speller.c은 그 걸립니까,
로드는, 그것의 속도를 확인

1146
00:58:14,290 --> 00:58:19,190
방법 등의 벤치 마크 테스트
빨리 당신은 일을 할 수있어.

1147
00:58:19,190 --> 00:58:20,410
>> 그것은 철자입니다.

1148
00:58:20,410 --> 00:58:23,920
그냥 엉망을하지 않습니다,하지만 확인
확실히 당신은 무엇을하고 있는지 이해합니다.

1149
00:58:23,920 --> 00:58:28,090
우리는 기능이라고 getrusage를 사용하는
당신의 주문의 성능을 테스트

1150
00:58:28,090 --> 00:58:28,590
체커.

1151
00:58:28,590 --> 00:58:32,200
모든 그것은 기본적으로 테스트됩니다 않습니다
당신의 사전에있는 모든 시간,

1152
00:58:32,200 --> 00:58:33,680
그래서 당신이 그것을 알고 있어야합니다.

1153
00:58:33,680 --> 00:58:36,660
그것으로 엉망 않도록주의 또는
다른 일들이 제대로 실행되지 않습니다.

1154
00:58:36,660 --> 00:58:39,740

1155
00:58:39,740 --> 00:58:44,170
>> 그리고 이러한 문제의 대부분은입니다
너희들은 정말 dictionary.c을 수정할 수 있습니다.

1156
00:58:44,170 --> 00:58:48,526
우리는 당신에게 줄거야
사전에 14 만 단어.

1157
00:58:48,526 --> 00:58:50,900
우리는 당신에게 텍스트를 줄거야
그 단어를 가지고 파일,

1158
00:58:50,900 --> 00:58:54,840
우리는 당신이 구성 할 수 있도록하려면
해시 테이블 또는 트라이로

1159
00:58:54,840 --> 00:58:58,140
우리가 주문하도록 요구하는 경우 때문에
당신이 마법이 있다면 상상 check--

1160
00:58:58,140 --> 00:59:00,690
호머의 오디세이처럼 검사합니다.

1161
00:59:00,690 --> 00:59:03,010
그것은이 거대한, 거대한 테스트 같다.

1162
00:59:03,010 --> 00:59:05,190
>> 매일 상상해
단어 당신을 지켜 볼 수밖에 없었습니다

1163
00:59:05,190 --> 00:59:08,100
140,000 값의 배열을 통해.

1164
00:59:08,100 --> 00:59:10,350
즉 영원히 걸릴 것
컴퓨터가 실행하는.

1165
00:59:10,350 --> 00:59:14,490
우리가 우리를 구성하려는 이유입니다
더 효율적인 데이터 구조로 데이터

1166
00:59:14,490 --> 00:59:17,270
이러한 해시 테이블 또는 트라이있다.

1167
00:59:17,270 --> 00:59:20,700
그리고 너희들은 종류의 수
액세스를 검색 할 때의

1168
00:59:20,700 --> 00:59:22,570
것을 더 쉽게 더 빨리.

1169
00:59:22,570 --> 00:59:24,934
>> 그래서 충돌을 해결하기 위해주의해야합니다.

1170
00:59:24,934 --> 00:59:27,350
당신은 무리를받을거야
A.와 그 시작의 단어

1171
00:59:27,350 --> 00:59:29,957
당신은 한 무리의 단어를받을거야
즉, 최대 B. 시작

1172
00:59:29,957 --> 00:59:31,290
당신이 원하는 방법 사람들은 그것을 해결하기 위해.

1173
00:59:31,290 --> 00:59:34,144
아마도 더있다
효율적인 해시 함수

1174
00:59:34,144 --> 00:59:36,810
단지 첫 글자보다
뭔가, 그래서 그것은 당신에게 달려 있습니다

1175
00:59:36,810 --> 00:59:38,190
사람은 종류의 당신이 원하는 무엇이든 할 수 있습니다.

1176
00:59:38,190 --> 00:59:40,148
>> 어쩌면 당신은 추가 할
함께 모든 문자.

1177
00:59:40,148 --> 00:59:43,410
어쩌면 당신은 이상한 일을 같이 할
문자의 수를 설명하기 위해,

1178
00:59:43,410 --> 00:59:43,970
도대체 무엇이.

1179
00:59:43,970 --> 00:59:45,386
당신이 원하는 방법들까지.

1180
00:59:45,386 --> 00:59:49,262
당신은 당신이 경우, 해시 테이블을 수행 할 경우
전적으로 당신에게 달려, 트라이를 시도합니다.

1181
00:59:49,262 --> 00:59:52,470
나는 시간 앞서 경고합니다
트라이은 일반적으로 조금 더 어렵습니다

1182
00:59:52,470 --> 00:59:54,520
많이있다해서
더 포인터를 추적합니다.

1183
00:59:54,520 --> 00:59:55,645
그러나 완전히 너희들까지.

1184
00:59:55,645 --> 00:59:58,742
이것은 훨씬 더 효율적
대부분의 경우에.

1185
00:59:58,742 --> 01:00:01,450
당신은 정말 계속 할 수 있도록하려면
당신의 포인터의 모든 트랙.

1186
01:00:01,450 --> 01:00:03,850
마찬가지로 같은 일을
내가 여기서 일을하였습니다.

1187
01:00:03,850 --> 01:00:06,871
때 삽입하려는
해시 테이블에 값 또는 삭제

1188
01:00:06,871 --> 01:00:08,620
당신이있어 있는지 확인
정말를 추적

1189
01:00:08,620 --> 01:00:11,860
모든 것이 있기 때문이다의
이 난 경우 정말 쉽게

1190
01:00:11,860 --> 01:00:14,727
단어, 앤디처럼 삽입하려고합니다.

1191
01:00:14,727 --> 01:00:16,810
그냥 그 말할하자
실제 단어, 단어, 앤디,

1192
01:00:16,810 --> 01:00:19,640
단어의 거대한 목록에.

1193
01:00:19,640 --> 01:00:22,450
>> 난 그냥 재 할당하는 일 경우
포인터 잘못, 죄송합니다,

1194
01:00:22,450 --> 01:00:24,940
전체를 간다
내 연결리스트의 나머지.

1195
01:00:24,940 --> 01:00:26,897
이제 유일한 단어 나
이 앤디, 그리고 지금

1196
01:00:26,897 --> 01:00:29,230
에있는 다른 모든 단어
사전이 손실되었다.

1197
01:00:29,230 --> 01:00:31,370
그래서 당신은 당신이 있는지 확인하려면
당신의 포인터의 모든 추적

1198
01:00:31,370 --> 01:00:33,661
그렇지 않으면 당신은받을거야
코드에서 큰 문제.

1199
01:00:33,661 --> 01:00:35,840
단계별로 신중하게 물건을 그립니다.

1200
01:00:35,840 --> 01:00:37,870
그것은 생각하기가 훨씬 쉬워집니다.

1201
01:00:37,870 --> 01:00:40,910
>> 그리고 마지막으로, 당신은 할 수 있도록하려면
프로그램의 성능을 테스트

1202
01:00:40,910 --> 01:00:41,618
큰 보드에.

1203
01:00:41,618 --> 01:00:43,710
너희들이 걸릴 경우
지금 CS50를 보면,

1204
01:00:43,710 --> 01:00:45,210
우리는 큰 보드라고 무슨있다.

1205
01:00:45,210 --> 01:00:50,200
그것은 가장 빠른의 점수 시트입니다
CS50의 모든 걸쳐 검사 시간을 철자

1206
01:00:50,200 --> 01:00:55,720
지금, 나는 10 등의 상단을 생각
시간 나는 그들의 여덟 직원 생각합니다.

1207
01:00:55,720 --> 01:00:57,960
우리가 정말 너희들이 우리를 이길 원한다.

1208
01:00:57,960 --> 01:01:00,870
>> 우리 모두는 구현하기 위해 노력하고 있었다
가능한 가장 빠른 번호.

1209
01:01:00,870 --> 01:01:04,880
우리는 너희들이 도전하려고 시도하는
우리와 우리 모두보다 빠르게 구현

1210
01:01:04,880 --> 01:01:05,550
양철통.

1211
01:01:05,550 --> 01:01:07,970
그리고 이것은 정말
우리가있어 처음으로

1212
01:01:07,970 --> 01:01:12,680
너희들을 요구하는 것은 PSET을 수행하는 그
당신은 정말 어떤 방법으로 할 수있다

1213
01:01:12,680 --> 01:01:13,760
당신이 원하는.

1214
01:01:13,760 --> 01:01:17,730
>> 난 항상이 더 가깝다, 말
실제 솔루션, 오른쪽?

1215
01:01:17,730 --> 01:01:19,550
나는 안녕하세요, 당신이해야 할 말.

1216
01:01:19,550 --> 01:01:21,380
나를 위해이 작업을 수행하는 프로그램을 구축 할 수 있습니다.

1217
01:01:21,380 --> 01:01:22,630
당신이 원하는 그러나 그것을한다.

1218
01:01:22,630 --> 01:01:24,271
난 그냥 빨리 할 것을 알고있다.

1219
01:01:24,271 --> 01:01:25,770
즉,이 주에 대한 도전입니다.

1220
01:01:25,770 --> 01:01:27,531
너희들은, 우리는거야
당신에게 작업을 제공합니다.

1221
01:01:27,531 --> 01:01:29,030
우리는 당신에게 도전을 줄 것입니다.

1222
01:01:29,030 --> 01:01:31,559
그리고 그것은 너희들이야
완전하게 파악하기

1223
01:01:31,559 --> 01:01:34,100
가장 빠르고 무엇
효율적인 방법은이를 구현합니다.

1224
01:01:34,100 --> 01:01:34,600
네?

1225
01:01:34,600 --> 01:01:37,476
>> 청중 : 우리는 경우에 허용 되는가
빠른 방법을 연구하고 싶었

1226
01:01:37,476 --> 01:01:40,821
우리가 할 수있는 온라인 해시 테이블을 할 수
그와 누군가 다른 사람의 코드를 인용?

1227
01:01:40,821 --> 01:01:42,070
ANDI 펭 : 네, 완전히 괜찮아요.

1228
01:01:42,070 --> 01:01:44,320
그래서 너희들이 읽는다면
사양은, 라인있다

1229
01:01:44,320 --> 01:01:48,310
너희들을 말한다 사양에
해시 조회 완전히 무료입니다

1230
01:01:48,310 --> 01:01:51,070
어떤 일부의 기능
빠른 해시 함수

1231
01:01:51,070 --> 01:01:54,720
등을 통해 일을 실행
당신이 그 코드를 인용 한.

1232
01:01:54,720 --> 01:01:57,220
그래서 어떤 사람들은 이미
빠른 방법을 알아 냈어

1233
01:01:57,220 --> 01:02:00,250
신속의, 맞춤법 검사기를하고
정보를 저장하는 방법.

1234
01:02:00,250 --> 01:02:02,750
완전히 너희들까지 당신 경우
바로, 그냥 먹고 싶어?

1235
01:02:02,750 --> 01:02:04,045
당신이 인용하고 있는지 확인합니다.

1236
01:02:04,045 --> 01:02:06,170
도전 여기에 정말
우리는 테스트를 위해 노력하고 있음

1237
01:02:06,170 --> 01:02:09,750
당신이 알고 있는지 확인하고있다
당신의 방법은 주위에 대한 포인터.

1238
01:02:09,750 --> 01:02:12,700
지금까지 당신이 구현으로
실제 해시 함수

1239
01:02:12,700 --> 01:02:15,070
과 등으로 올라오고
수학은 그렇게,

1240
01:02:15,070 --> 01:02:17,570
너희들은 연구 할 수 무엇이든
방법은 온라인 너희들은 할 수 있습니다.

1241
01:02:17,570 --> 01:02:17,996
네?

1242
01:02:17,996 --> 01:02:19,700
>> 청중 : 우리는 그냥 인용 수
[들리지]를 사용하여?

1243
01:02:19,700 --> 01:02:20,120
>> ANDI 펭 : 네.

1244
01:02:20,120 --> 01:02:22,328
할 수 있습니다 만, 당신의 의견에,
당신이, 오, 같은 인용 수

1245
01:02:22,328 --> 01:02:26,127
궁시렁에서 촬영, 궁시렁,
궁시렁, 해시 함수.

1246
01:02:26,127 --> 01:02:27,210
누구나 어떤 질문이?

1247
01:02:27,210 --> 01:02:29,694
우리는 실제로 스레
오늘 섹션을 통해.

1248
01:02:29,694 --> 01:02:31,610
나는 여기까지가 될 것입니다
뿐만 아니라 질문에 대한 답변.

1249
01:02:31,610 --> 01:02:36,570
>> 또한, 내가 말했듯이, 사무실
시간 오늘 밤과 내일.

1250
01:02:36,570 --> 01:02:40,307
이번 주에 실제로 사양
아주 쉽게 읽을 슈퍼 짧은.

1251
01:02:40,307 --> 01:02:43,140
난 그냥 살펴 본다 제안
그것의 전체를 읽어.

1252
01:02:43,140 --> 01:02:45,730
>> 그리고 Zamyla 사실을 안내합니다
각 기능을 통하여

1253
01:02:45,730 --> 01:02:49,796
당신은 구현해야하고, 그래서있어
모든 작업을 수행하는 방법에 아주, 아주 분명.

1254
01:02:49,796 --> 01:02:51,920
그냥 당신이있어 만들려면
포인터를 추적.

1255
01:02:51,920 --> 01:02:53,650
이것은 매우 어려운 PSET이다.

1256
01:02:53,650 --> 01:02:56,744
>> 그것은 좋아하기 때문에 도전 아니에요
오, 개념은 훨씬 더 있습니다

1257
01:02:56,744 --> 01:02:59,160
어려운, 또는 당신은 배울 필요가
그런데 너무 많은 새 구문

1258
01:02:59,160 --> 01:03:00,650
당신은 마지막 PSET 위해 한 것이다.

1259
01:03:00,650 --> 01:03:03,320
이 PSET는 어렵 기 때문에
많은 포인터가,

1260
01:03:03,320 --> 01:03:06,980
다음은 한 번에 아주 쉽게
당신은 할 수 코드에서 버그가

1261
01:03:06,980 --> 01:03:08,315
그 버그가 어디에서 찾을 수 있습니다.

1262
01:03:08,315 --> 01:03:13,200
>> 그래서 완전하고 당신의 완전한 믿음
너희들은 우리의 [들리지]을 이길 수 있도록

1263
01:03:13,200 --> 01:03:13,700
철자.

1264
01:03:13,700 --> 01:03:16,640
나는 실제로하지 서면 광산이
아직,하지만 난 내 쓰기하려고 해요.

1265
01:03:16,640 --> 01:03:19,070
당신이 작성하는 동안 그래서
당신은, 난 내를 작성 할 수 있습니다.

1266
01:03:19,070 --> 01:03:21,070
내가 만들려고하는거야
내 빠른 당신보다.

1267
01:03:21,070 --> 01:03:23,940
우리는 가장 빠른 하나있는 사람을 볼 수 있습니다.

1268
01:03:23,940 --> 01:03:27,340
>> 그리고 그래, 나는 모두를 볼 수 있습니다
여기에 화요일에 너희들.

1269
01:03:27,340 --> 01:03:29,510
나는 PSET 워크샵과 같은 종류를 실행합니다.

1270
01:03:29,510 --> 01:03:32,640
모든 섹션이
주, PSET 워크샵입니다

1271
01:03:32,640 --> 01:03:36,690
그래서 너희들은 많은 기회를
도움, 업무 시간 언제나처럼,

1272
01:03:36,690 --> 01:03:41,330
와 정말 기대
당신의 남자 '모든 코드를 읽고.

1273
01:03:41,330 --> 01:03:44,160
나는 여기 경우 퀴즈를 가지고
사람은 사람들을 데리러 싶습니다.

1274
01:03:44,160 --> 01:03:45,880
그게 다야.

1275
01:03:45,880 --> 01:03:48,180