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

2
00:00:03,332 --> 00:00:06,490
>> ANDI 펭 : 섹션의 주 3에 오신 것을 환영합니다.

3
00:00:06,490 --> 00:00:09,550
모든 주셔서 감사합니다, 너희들,
이 이전 시작 시간 오늘.

4
00:00:09,550 --> 00:00:11,466
우리는 좋은, 조금있어
친밀한 그룹 오늘.

5
00:00:11,466 --> 00:00:14,570
그래서 잘하면 우리는에 도착합니다
마무리, 아마도 초기,

6
00:00:14,570 --> 00:00:15,780
조금 일찍 오늘.

7
00:00:15,780 --> 00:00:22,057
이렇게 빨리, 좀
의제 오늘 발표.

8
00:00:22,057 --> 00:00:23,890
우리가 시작하기 전에, 우리는있어
그냥 갈

9
00:00:23,890 --> 00:00:28,910
몇 가지 간단한 물류 문제, PSET
질문, 브리핑, 그런 것들.

10
00:00:28,910 --> 00:00:30,250
그리고 우리는에 바로 뛰어들 것이다.

11
00:00:30,250 --> 00:00:34,710
우리는에 GDB라는 디버거를 사용합니다
우리의 코드를, 정체를 폭로 시작하는 다윗

12
00:00:34,710 --> 00:00:36,550
다른 날 강의에서 설명했다.

13
00:00:36,550 --> 00:00:39,420
우리는 종류의 네 가지 유형을 통해 이동합니다.

14
00:00:39,420 --> 00:00:42,310
우리는 꽤 빨리 그들을 갈거야
그들은 꽤 많이있어 때문이다.

15
00:00:42,310 --> 00:00:45,710
하지만 알고있는 모든 슬라이드와
소스 코드는 항상 온라인 상태입니다.

16
00:00:45,710 --> 00:00:50,810
그래서에, 당신의 열람에 주시기
돌아가서 그를보십시오.

17
00:00:50,810 --> 00:00:53,930
>> 우리는 통과합니다
점근 표기법, 어떤

18
00:00:53,930 --> 00:00:55,944
단지 멋진 방법입니다
말하는 "런타임을"

19
00:00:55,944 --> 00:00:58,360
우리는 큰 O를,이 곳에있는
다윗은 강의에서 설명했다.

20
00:00:58,360 --> 00:01:01,550
그리고 우리는 또한 오메가를 가지고있는
하한 런타임이다.

21
00:01:01,550 --> 00:01:06,450
그리고 우리는 좀 더 얘기하자
심층 어떻게 그 일에.

22
00:01:06,450 --> 00:01:10,160
그리고 마지막으로, 우리는 이진 검색을 통해 갈거야
때문에 이미 당신의 많은

23
00:01:10,160 --> 00:01:15,190
당신의 psets를 흘끗 아마 알고
그게 당신의 PSET에서의 문제이다.

24
00:01:15,190 --> 00:01:17,470
그래서 당신은 모든 행복 할 것
우리는이 오늘 다룰 것이다.

25
00:01:17,470 --> 00:01:20,610
>> 그리고 마지막으로, 당
섹션 피드백, 나는 실제로

26
00:01:20,610 --> 00:01:23,000
약 15 분 왼쪽
말은 그냥 이동

27
00:01:23,000 --> 00:01:27,730
pset3의 물류, 질문,
아마 인도의 비트, 만약에 당신,

28
00:01:27,730 --> 00:01:28,990
우리가 프로그래밍을 시작하기 전에.

29
00:01:28,990 --> 00:01:30,890
그럼 통해 얻을 해보자
꽤 빨리 재료.

30
00:01:30,890 --> 00:01:33,880
그리고 우리는 약간의 시간을 보낼 수 있습니다
PSET에 대한 더 많은 질문을 복용.

31
00:01:33,880 --> 00:01:35,230
그래.

32
00:01:35,230 --> 00:01:39,570
>> 신속, 그래서 몇 가지
우리는 이전에 발표 오늘 시작합니다.

33
00:01:39,570 --> 00:01:45,410
첫째, 만들기에 오신 것을 환영합니다
당신의 Pset의 두 통해.

34
00:01:45,410 --> 00:01:49,432
나는 your-- 그래,하자의에보고했다
그 하나 박수를 얻을.

35
00:01:49,432 --> 00:01:51,140
사실, 난, 정말로
정말 감동.

36
00:01:51,140 --> 00:01:55,800
나는 너희들의 첫 번째 PSET을 등급
지난 주와 너희들은 놀라운했다.

37
00:01:55,800 --> 00:01:58,290
>> 스타일 포인트에 있었다
몇 가지 의견 외에.

38
00:01:58,290 --> 00:02:00,660
당신이 항상있어 확인
코드를 주석.

39
00:02:00,660 --> 00:02:03,040
그러나 당신의 Pset 점에 있었다.

40
00:02:03,040 --> 00:02:05,549
그리고 그것을 유지.

41
00:02:05,549 --> 00:02:08,090
그리고 그것은에 학년을위한 좋은
너희들두고있는 것을 볼 수

42
00:02:08,090 --> 00:02:10,704
당신의 스타일에 많은 노력
코드 및 설계

43
00:02:10,704 --> 00:02:12,120
당신이 볼 수 있도록 우리는하고 싶은 것을.

44
00:02:12,120 --> 00:02:16,450
그래서 난 내 감사를 따라 전달 해요
조교의 나머지 부분에 대한.

45
00:02:16,450 --> 00:02:19,210
>> 그러나이있다
몇 브리핑 질문

46
00:02:19,210 --> 00:02:22,010
난 그냥 가서 할
모두 내 인생을 만들 것

47
00:02:22,010 --> 00:02:24,900
다른 많은
조교는 '좀 더 쉽게 살고있다.

48
00:02:24,900 --> 00:02:28,220
첫째, 내가 발견 한이
과거는 당신의 얼마나 많은 week--

49
00:02:28,220 --> 00:02:32,301
에 check50를 실행 한
당신 전에 코드를 제출?

50
00:02:32,301 --> 00:02:32,800
그래.

51
00:02:32,800 --> 00:02:36,690
그래서 모두가 check50 일을해야한다,
실제로 우리 secret--을 이유는 -

52
00:02:36,690 --> 00:02:41,540
우리의 정확성의 일환으로 check50를 실행
코드를 테스트하기위한 스크립트.

53
00:02:41,540 --> 00:02:45,480
코드가 실패한다면
check50, 모든 가능성에,

54
00:02:45,480 --> 00:02:47,570
아마 것
뿐만 아니라 우리의 검사를 실패합니다.

55
00:02:47,570 --> 00:02:49,320
때로는 사람
정답이있다.

56
00:02:49,320 --> 00:02:52,200
의처럼, 욕심, 일부
당신은 바로 번호를 가지고,

57
00:02:52,200 --> 00:02:53,960
당신은 몇 가지 여분의 물건을 인쇄 할 수 있습니다.

58
00:02:53,960 --> 00:02:55,940
그리고 그 여분의 물건
실제로 검사를 실패

59
00:02:55,940 --> 00:02:58,440
컴퓨터가 없기 때문에
정말이 찾고 있는지 알고있다.

60
00:02:58,440 --> 00:03:00,981
그리고 그것은 단지를 통해 실행됩니다
당신의 출력을하지 않는 것을 볼 수

61
00:03:00,981 --> 00:03:03,810
우리는 대답을 기대 일치
, 그리고 그것이 잘못 표시합니다.

62
00:03:03,810 --> 00:03:06,560
>> 그리고 나는 일어난 것을 알고있다
귀하의 경우 몇몇이 주.

63
00:03:06,560 --> 00:03:09,870
그래서 나는 다시 수동으로 갔다
모든 사람의 코드를 재 채점.

64
00:03:09,870 --> 00:03:12,780
하지만 미래에는,
있는지 확인하시기 바랍니다하십시오

65
00:03:12,780 --> 00:03:14,570
당신은 실행중인 것을
코드 50를 확인하십시오.

66
00:03:14,570 --> 00:03:17,970
그것은 TA에 대한 고통 가지이기 때문에
regrade 수동으로 돌아가서해야 할

67
00:03:17,970 --> 00:03:21,197
모든마다 하나의 PSET
하나의 작은 놓친 예.

68
00:03:21,197 --> 00:03:22,530
그래서 나는 어떤 점을 고려하지 않았다.

69
00:03:22,530 --> 00:03:25,210
나는 어쩌면 벗고 생각
하나 또는 디자인을위한 두 가지.

70
00:03:25,210 --> 00:03:27,710
하지만 미래에는, 경우
당신은 check50 실패하고

71
00:03:27,710 --> 00:03:31,330
포인트는 이동합니다
정확성에 대한 끕니다.

72
00:03:31,330 --> 00:03:35,020
>> 또한,의 Pset은
정오에서 금요일 때문에.

73
00:03:35,020 --> 00:03:38,990
나는 7 분 있다고 생각
우리는 당신을 줄 늦게 유예 기간.

74
00:03:38,990 --> 00:03:42,434
하버드 시간당, 그들은 허용하고
칠분 늦은 모든 것에를합니다.

75
00:03:42,434 --> 00:03:44,350
그래서 여기에 예일 대학에서, 우리는거야
뿐만 아니라 그 준수합니다.

76
00:03:44,350 --> 00:03:47,910
그러나 꽤 많은, 12시 7분에서,
당신의 PSET가 아닌 경우

77
00:03:47,910 --> 00:03:49,720
그것은 늦게 표시 될 것입니다.

78
00:03:49,720 --> 00:03:53,160
반면 있도록 그리고 그것은 표시됩니다
늦게, TA-- 내가 해요

79
00:03:53,160 --> 00:03:54,870
여전히 psets를 채점 할 것.

80
00:03:54,870 --> 00:03:56,760
그래서 당신은 아직 등급이 표시가 나타납니다.

81
00:03:56,760 --> 00:03:58,820
그러나,에 알고
학기말,

82
00:03:58,820 --> 00:04:02,270
모든 말의 Pset는 것입니다
자동으로 컴퓨터에 의해 제로.

83
00:04:02,270 --> 00:04:04,490
>> 우리는 두 가지 이유에 대해이 작업을 수행합니다.

84
00:04:04,490 --> 00:04:09,220
하나, 때로는 우리가 얻을
학장의 변명처럼, 면제,

85
00:04:09,220 --> 00:04:10,762
나중에에 아직 모르는.

86
00:04:10,762 --> 00:04:13,761
그래서 우리는 우리가 채점하고 있는지 확인하려면
다만 경우에 모든 것을, 같은, 내가 해요

87
00:04:13,761 --> 00:04:15,080
학장의 변명이 없습니다.

88
00:04:15,080 --> 00:04:17,000
그리고 둘째로,에 계속
마음, 당신은 아직 할 수

89
00:04:17,000 --> 00:04:19,370
하나 PSET 드롭 그
전체 범위의 점을 가지고있다.

90
00:04:19,370 --> 00:04:21,430
그래서 우리는 학년에 좋아
당신의 Pset의 모든 단지

91
00:04:21,430 --> 00:04:24,730
스코프의를 확인 것과
거기 당신은 그들을 시도하고있다.

92
00:04:24,730 --> 00:04:29,150
이 늦었 그래서 경우에도, 당신은 여전히​​거야
범위 포인트를 신용을 얻을, 나는 생각한다.

93
00:04:29,150 --> 00:04:33,730
>> 이야기가 너무 도덕적, 확인
반드시 당신의 Pset에 시간에 있습니다.

94
00:04:33,730 --> 00:04:38,350
그들이 적시에 없으면
그것은 큰 아니라고 알고있다.

95
00:04:38,350 --> 00:04:41,678
그래, 난에 이동하기 전에, 사람이 있는가
PSET 피드백에 관한 질문?

96
00:04:41,678 --> 00:04:42,178
그래.

97
00:04:42,178 --> 00:04:43,630
>> 청중 : 당신은 우리 말 하였습니까
psets를 중 하나를 드롭 할 수 있습니까?

98
00:04:43,630 --> 00:04:44,296
>> ANDI 펭 : 네.

99
00:04:44,296 --> 00:04:47,050
그래서 아홉의 Pset 전반적인있다
학기의 과정을 통해.

100
00:04:47,050 --> 00:04:50,610
그리고 당신은 범위가있는 경우
points-- 그래서 범위는, 그냥

101
00:04:50,610 --> 00:04:53,567
꽤 많은, 당신이 시도
문제는, 당신은 시간에 가하고 있습니다

102
00:04:53,567 --> 00:04:56,150
당신은 당신이되었음을 보여주고있다
증명 당신은 스펙을 읽었습니다.

103
00:04:56,150 --> 00:04:57,191
즉 거의 범위입니다.

104
00:04:57,191 --> 00:04:59,370
그리고 당신은 만족하는 경우
범위 포인트, 우리

105
00:04:59,370 --> 00:05:03,360
가장 낮은 드롭 수
전체 범위 중 하나.

106
00:05:03,360 --> 00:05:06,790
그래서에 당신의 이점에있어
완료하고 모든 PSET을 시도합니다.

107
00:05:06,790 --> 00:05:10,320
>> 심지어 upload-- 없음의 경우
그들은 그들 모두를 업로드, 작동합니다.

108
00:05:10,320 --> 00:05:13,711
그리고 우리가 희망 할 수있을 것이다
당신에게 그 포인트의 일부를 다시 제공합니다.

109
00:05:13,711 --> 00:05:14,210
쿨.

110
00:05:14,210 --> 00:05:16,780
다른 질문?

111
00:05:16,780 --> 00:05:17,840
좋아요.

112
00:05:17,840 --> 00:05:21,960
>> 둘째, 사무실은 몇 끝도
근무 시간에 대한 빠른 노트.

113
00:05:21,960 --> 00:05:24,300
그래서 일단, 초기 주에서 온다.

114
00:05:24,300 --> 00:05:26,909
아무도에서 이제까지 없다
월요일 근무 시간.

115
00:05:26,909 --> 00:05:28,700
Christabel는 온
근무 시간 지난 밤.

116
00:05:28,700 --> 00:05:29,691
그래, Christabel.

117
00:05:29,691 --> 00:05:32,190
그리고 우리는 사무실에서 무엇을했을까요
시간 지난 밤, Christabel?

118
00:05:32,190 --> 00:05:33,020
>> 청중 : 우리는 아이스크림을했다.

119
00:05:33,020 --> 00:05:36,160
>> ANDI 펭이 : 그래서 그건 바로, 우리가했다
근무 시간에 아이스크림 지난 밤.

120
00:05:36,160 --> 00:05:39,390
나는 것을 약속 할 수는 없지만
우리는 근무 시간에 아이스크림을해야합니다

121
00:05:39,390 --> 00:05:43,230
매주, 난 당신을 약속 할 수있는
상당히있을 것입니다

122
00:05:43,230 --> 00:05:45,380
TA 비율이 더 나은 학생.

123
00:05:45,380 --> 00:05:47,650
합법적 마찬가지로 3-1 같아요.

124
00:05:47,650 --> 00:05:50,350
와 그 대비 반면
목요일, 당신은 약 150있어

125
00:05:50,350 --> 00:05:52,830
정말 아이들없이 아이스크림을 강조했다.

126
00:05:52,830 --> 00:05:55,360
그리고 그것은 단지 사람을위한 생산하지 않습니다.

127
00:05:55,360 --> 00:05:58,730
이야기의 교훈은 그래서 일찍 와서
근무 시간과 좋은 일에

128
00:05:58,730 --> 00:06:00,310
발생합니다.

129
00:06:00,310 --> 00:06:02,110
>> 또한, 질문을 할 준비가되어 있습니다.

130
00:06:02,110 --> 00:06:03,200
당신은 알아?

131
00:06:03,200 --> 00:06:05,420
에 관계없이 어떤 조교, 나는
말 한 생각,

132
00:06:05,420 --> 00:06:10,710
우리는 몇 학생을지고있어
10시 50분 같은, 목요일에 와서 사람들

133
00:06:10,710 --> 00:06:15,100
사양을 읽은하지
나에게 도움이되고 싶어, 내가 도움이됩니다.

134
00:06:15,100 --> 00:06:18,200
불행하게도 그 시점에서, 거기에
별로 우리가 당신을 도와 줄 수 있습니다.

135
00:06:18,200 --> 00:06:19,590
그래서 초기에 주에 오시기 바랍니다.

136
00:06:19,590 --> 00:06:22,040
근무 시간에 일찍 가자.

137
00:06:22,040 --> 00:06:23,350
질문을 할 준비가되어 있습니다.

138
00:06:23,350 --> 00:06:25,310
로, 반드시 확인
학생, 어디

139
00:06:25,310 --> 00:06:27,620
그렇게 그해야
조교는 함께 여러분을 안내 할 수 있습니다

140
00:06:27,620 --> 00:06:32,850
무엇 근무 시간 인
해야에 할당 될 수있다.

141
00:06:32,850 --> 00:06:37,380
>> 둘째, 그래서 나는 교수를 알고
시험으로 우리를 놀라게하고 싶다.

142
00:06:37,380 --> 00:06:39,439
나는 교수들 있었다
요, 같은 방법에 의해,

143
00:06:39,439 --> 00:06:41,230
그 중간을 기억
당신은 다음 주 월요일있다.

144
00:06:41,230 --> 00:06:42,855
그래, 그 중간에 대해 알고하지 않았다.

145
00:06:42,855 --> 00:06:45,630
그래서 나는 될거야 TA
그것은 당신에게 모든 퀴즈를 생각 나게한다

146
00:06:45,630 --> 00:06:47,270
당신이 알고 있기 때문 0--, 우리는 CS이야.

147
00:06:47,270 --> 00:06:50,730
이제 우리가 한 배열을했는지, 당신은 얻을
이 퀴즈 0 왜, 어, 1 퀴즈하지?

148
00:06:50,730 --> 00:06:51,320
그래.

149
00:06:51,320 --> 00:06:52,490
아, 그 하나에 약간의 싱그레 웃음을 얻었다.

150
00:06:52,490 --> 00:06:53,120
그래.

151
00:06:53,120 --> 00:06:59,710
>> 그래서 퀴즈 0 경우 10월 14일 될 것입니다
당신은 월요일 수요일 부분에있어

152
00:06:59,710 --> 00:07:02,920
10 월 15 번째가에 있다면
화요일 - 목요일 섹션.

153
00:07:02,920 --> 00:07:05,630
이 적용되지 않습니다
하버드에서 당신의 그

154
00:07:05,630 --> 00:07:10,350
난 당신이 모든 일 거라 생각 who--
14 일 당신의 퀴즈를 복용.

155
00:07:10,350 --> 00:07:13,560
>> 그래서 그래, 다음 주, 경우
다윗은, 강의, 간다

156
00:07:13,560 --> 00:07:15,747
그래, 그것에 대해 너무
퀴즈 다음 주에, 당신의 모든

157
00:07:15,747 --> 00:07:17,580
때문에 충격을하지 않습니다
당신은 절에 와서

158
00:07:17,580 --> 00:07:19,664
당신은 알고 당신의
퀴즈 0 2 주입니다.

159
00:07:19,664 --> 00:07:21,580
그리고 우리는 검토를해야합니다
세션과 모든 것을.

160
00:07:21,580 --> 00:07:26,360
대한 그래서 걱정 없다
그것을 위해 깜짝 놀라게된다.

161
00:07:26,360 --> 00:07:29,890
질문은 질문 before--
모든 관련 물류 문제에서,

162
00:07:29,890 --> 00:07:32,591
등급, 근무 시간, 섹션?

163
00:07:32,591 --> 00:07:33,090
그래.

164
00:07:33,090 --> 00:07:35,100
>> 청중 : 퀴즈가 그래서
강연이 될 것?

165
00:07:35,100 --> 00:07:35,766
>> ANDI 펭 : 네.

166
00:07:35,766 --> 00:07:39,460
퀴즈 그래서, 나는 생각한다, 60
그 시간 슬롯에 할당 분

167
00:07:39,460 --> 00:07:42,240
당신은 걸릴거야
강당에서.

168
00:07:42,240 --> 00:07:44,810
그래서 올 필요가 없습니다
임의 오후 7 등,에.

169
00:07:44,810 --> 00:07:46,140
전부다 괜찮아.

170
00:07:46,140 --> 00:07:47,100
그래.

171
00:07:47,100 --> 00:07:50,060
쿨.

172
00:07:50,060 --> 00:07:50,840
>> 괜찮아.

173
00:07:50,840 --> 00:07:54,330
그래서 우리는 갈거야
당신에게 개념을 소개

174
00:07:54,330 --> 00:08:00,760
다윗이 종류 이미이 이번 주
이 지난 주 강의에 감동.

175
00:08:00,760 --> 00:08:02,010
그것은 GDB라고.

176
00:08:02,010 --> 00:08:05,570
어떻게 당신의 많은에있는 동안
귀하의 Pset를 작성하는 과정,

177
00:08:05,570 --> 00:08:09,981
라는 큰 버튼을 발견했습니다
당신의 IDE의 상단에 "디버그"?

178
00:08:09,981 --> 00:08:10,480
그래.

179
00:08:10,480 --> 00:08:13,770
그래서 지금 우리가 실제로 발굴하는거야
어떻게 그 버튼의 신비 실제로

180
00:08:13,770 --> 00:08:14,270
않습니다.

181
00:08:14,270 --> 00:08:16,790
그리고 나는, 당신을 보장
아름다운, 아름다운 것.

182
00:08:16,790 --> 00:08:20,740
>> 지금까지 내가 생각까지 그래서
두 가지가있었습니다

183
00:08:20,740 --> 00:08:23,320
학생들은 일반적으로왔다
psets를 디버깅 할 때 일.

184
00:08:23,320 --> 00:08:27,635
하나, 그들 중 하나에 추가
의 printf () - 그래서 모든 몇 줄,

185
00:08:27,635 --> 00:08:29,760
그들은의 printf ()에 추가 -
오,이 변수는 무엇인가?

186
00:08:29,760 --> 00:08:32,551
아,이 변수는 무엇입니까들을 당장
당신은 종류의 진행을 참조

187
00:08:32,551 --> 00:08:33,940
코드의 그것을 실행으로.

188
00:08:33,940 --> 00:08:37,030
또는 아이가하는 두 번째 방법은
그들은 단지 전체를 작성하는 것이

189
00:08:37,030 --> 00:08:38,610
다음 마지막에 다음과 같이 이동합니다.

190
00:08:38,610 --> 00:08:39,970
희망이 작동합니다.

191
00:08:39,970 --> 00:08:44,851
나는 당신을 보장, GDB는 더 낫다
그 방법 중보다.

192
00:08:44,851 --> 00:08:45,350
그래.

193
00:08:45,350 --> 00:08:46,980
그래서 이것은 당신의 새로운 가장 친한 친구가 될 것입니다.

194
00:08:46,980 --> 00:08:51,780
그것은 아름다운 일이기 때문에
그 시각 모두 표시

195
00:08:51,780 --> 00:08:54,850
어떤 코드가하고있다
특정 시점에서

196
00:08:54,850 --> 00:08:57,486
뿐만 아니라 어떤 모두 같은
변수는 운반하는,

197
00:08:57,486 --> 00:08:59,610
그 값이 무엇인지 등,
특정 시점에서.

198
00:08:59,610 --> 00:09:02,670
그리고 이러한 방법으로, 당신은 정말 할 수
코드에서 중단 점을 설정합니다.

199
00:09:02,670 --> 00:09:04,350
당신은 라인으로 라인을 통해 실행할 수 있습니다.

200
00:09:04,350 --> 00:09:07,324
그리고 GDB는 단지에 대한 것
당신은, 당신을 위해 표시

201
00:09:07,324 --> 00:09:09,490
무엇 모든 변수
그들은 무엇을하고 있습니다,

202
00:09:09,490 --> 00:09:10,656
어떤 코드에서 일어나는.

203
00:09:10,656 --> 00:09:13,240
이러한 방식으로,이야
너무 쉽게 볼 수 있습니다

204
00:09:13,240 --> 00:09:17,120
무슨 일이 printf의-ING 대신에 무슨 일이 일어나고
또는 명령문을 작성합니다.

205
00:09:17,120 --> 00:09:19,160
>> 그래서 우리는 이번의 예를 할 수 있습니다.

206
00:09:19,160 --> 00:09:20,660
그래서이 조금 추상적 인 것 같습니다.

207
00:09:20,660 --> 00:09:23,490
걱정, 우리는 예를하지 않는다 할 것이다.

208
00:09:23,490 --> 00:09:29,170
그래서 본질적으로, 세 가지 가장 큰,
당신이 GDB에 필요 기능을 가장 많이 사용

209
00:09:29,170 --> 00:09:32,500
다음으로, 이상 단계입니다,
버튼으로 단계.

210
00:09:32,500 --> 00:09:34,860
나는 향하기거야
이 사실은, 지금.

211
00:09:34,860 --> 00:09:40,930
>> 그래서 너희들 모두는 것을 알 수 있습니다
또는 나는 약간 확대해야합니까?

212
00:09:40,930 --> 00:09:43,220

213
00:09:43,220 --> 00:09:44,470
다시, 당신은 그것을 볼 수 있습니까?

214
00:09:44,470 --> 00:09:45,730
나는 확대해야 하는가?

215
00:09:45,730 --> 00:09:46,480
그냥 조금?

216
00:09:46,480 --> 00:09:49,390
그래 좋아.

217
00:09:49,390 --> 00:09:50,280
우리는 거기에 갈.

218
00:09:50,280 --> 00:09:50,960
그래.

219
00:09:50,960 --> 00:09:57,000
>> 그래서 나는 나의 여기,이
욕심에 대한 구현입니다.

220
00:09:57,000 --> 00:10:01,430
그리고 너희들을 많이 썼다
그 form-- while 루프에 욕심

221
00:10:01,430 --> 00:10:04,890
할 수있는 완벽하게 허용되는 방법입니다
단순히를하는 것입니다 수있는 또 다른 방법을 그건 ...

222
00:10:04,890 --> 00:10:06,280
모듈에 분할.

223
00:10:06,280 --> 00:10:09,290
당신이 가질 수 있기 때문에 당신의
값 다음은 나머지를 가지고있다.

224
00:10:09,290 --> 00:10:11,150
그리고 당신은 할 수 있습니다
모두 함께 추가 할 수 있습니다.

225
00:10:11,150 --> 00:10:13,390
내가 뭘하는지의 논리를합니까
여기에 모든 사람에게 이해,

226
00:10:13,390 --> 00:10:14,117
우리가 시작하기 전에?

227
00:10:14,117 --> 00:10:16,760

228
00:10:16,760 --> 00:10:17,980
종류의?

229
00:10:17,980 --> 00:10:18,710
쿨.

230
00:10:18,710 --> 00:10:19,210
좋아요.

231
00:10:19,210 --> 00:10:21,290
그것은 꽤 섹시한 조각입니다
코드, 나는 말할 것입니다.

232
00:10:21,290 --> 00:10:23,502
마찬가지로 나는 다윗에 말했다,
잠시 후, 강의,

233
00:10:23,502 --> 00:10:25,960
모든 코드를보고 시작합니다
아름다운 무언가로.

234
00:10:25,960 --> 00:10:29,950
그리고 때때로 당신은 아름다운 볼 때
코드는, 그러한 훌륭한 느낌.

235
00:10:29,950 --> 00:10:35,410
>> 그래서 그러나,이 코드는 매우 인 반면
아름다운, 제대로 작동하지 않습니다.

236
00:10:35,410 --> 00:10:37,750
그럼이에 check50을 실행 할 수 있습니다.

237
00:10:37,750 --> 00:10:39,440
50 20-- OOP를 확인합니다.

238
00:10:39,440 --> 00:10:43,221

239
00:10:43,221 --> 00:10:43,720
2?

240
00:10:43,720 --> 00:10:44,990
그 pset2인가?

241
00:10:44,990 --> 00:10:46,870
그래.

242
00:10:46,870 --> 00:10:47,520
아, PSET1.

243
00:10:47,520 --> 00:10:50,970

244
00:10:50,970 --> 00:10:52,890
그래.

245
00:10:52,890 --> 00:10:53,900
그래서 우리는 check50를 실행합니다.

246
00:10:53,900 --> 00:11:01,550

247
00:11:01,550 --> 00:11:07,170
>> 그리고 너희들은 여기에서 볼 수 있듯이,
이 경우의 몇 가지를 실패합니다.

248
00:11:07,170 --> 00:11:10,165
그리고에서 당신의 일부에 대한
문제 세트를 수행하는 과정,

249
00:11:10,165 --> 00:11:11,110
아, 왜 작동하지 않는처럼 당신이있어.

250
00:11:11,110 --> 00:11:13,318
왜 일부 작동
값이 아닌 다른 사람을 위해?

251
00:11:13,318 --> 00:11:17,760
음, GDB는 당신의 그림을 도움이 될 것입니다
왜 그 입력이 작동되지 않았다.

252
00:11:17,760 --> 00:11:18,320
>> 그래.

253
00:11:18,320 --> 00:11:21,640
그럼, 중 하나를 보자
내가 check50에 실패했다 확인

254
00:11:21,640 --> 00:11:24,920
0.41의 입력 값이었다.

255
00:11:24,920 --> 00:11:27,830
정답 있도록
당신이 점점되어야한다 4.

256
00:11:27,830 --> 00:11:33,090
하지만 그 대신 나는 밖으로 인쇄하고 무엇을
부정확 3 N이다.

257
00:11:33,090 --> 00:11:36,190
그래서 그냥, 그냥 수동으로 실행할 수
check50가 작동하는지 확인하십시오.

258
00:11:36,190 --> 00:11:36,940
의는 ./greedy하자.

259
00:11:36,940 --> 00:11:40,130

260
00:11:40,130 --> 00:11:43,340
아차, 내가 욕심 확인해야합니다.

261
00:11:43,340 --> 00:11:43,840
우리는 거기에 갈.

262
00:11:43,840 --> 00:11:44,381
지금 ./greedy.

263
00:11:44,381 --> 00:11:46,950

264
00:11:46,950 --> 00:11:47,670
>> 얼마나 빚지고있다?

265
00:11:47,670 --> 00:11:49,550
이제 0.41을하자.

266
00:11:49,550 --> 00:11:52,590
그리고 네, 우리는 여기에서 볼
그것은 3 출력 있다고

267
00:11:52,590 --> 00:11:55,160
때 정답,
사실, (4)를해야한다.

268
00:11:55,160 --> 00:12:01,460
그럼 GDB를 입력 할 수 있도록 우리 방법을 참조
이 문제를 해결에 대한 갈 수 있습니다.

269
00:12:01,460 --> 00:12:03,992
>> 첫 번째 단계 그래서
항상 코드를 디버깅

270
00:12:03,992 --> 00:12:05,950
중단 점을 설정하는 것입니다,
또는 점하는 당신

271
00:12:05,950 --> 00:12:09,079
컴퓨터 나 원하는
디버거는보고 시작합니다.

272
00:12:09,079 --> 00:12:11,120
당신이 경우에 따라서 정말
문제가 무엇인지,

273
00:12:11,120 --> 00:12:14,670
일반적으로, 전형적인 것은 우리가 원하는
이렇게 주에 우리의 중단 점을 설정하는 것입니다.

274
00:12:14,670 --> 00:12:18,520
그래서 너희들이 볼 수있는 경우
바로 빨간 버튼,

275
00:12:18,520 --> 00:12:22,860
네, 그 날이 설정되었다
주요 기능에 브레이크 포인트.

276
00:12:22,860 --> 00:12:24,130
나는 그것을 클릭합니다.

277
00:12:24,130 --> 00:12:26,130
>> 그리고 내 디버그 버튼까지 갈 수 있습니다.

278
00:12:26,130 --> 00:12:27,036
그 버튼을 누르십시오.

279
00:12:27,036 --> 00:12:31,710

280
00:12:31,710 --> 00:12:36,555
내가 할 수있는 경우에 저 밖으로 다시 확대하자.

281
00:12:36,555 --> 00:12:38,020
우리는 거기에 갈.

282
00:12:38,020 --> 00:12:40,730
그래서 우리는 여기에, 오른쪽의 패널이 있습니다.

283
00:12:40,730 --> 00:12:43,680
나는 뒤에, 사람을 미안 해요, 당신
정말 정말 잘 볼 수 없습니다.

284
00:12:43,680 --> 00:12:49,090
그러나 본질적으로, 모든
이 오른쪽 패널하고있다

285
00:12:49,090 --> 00:12:53,130
모두 강조의 트랙을 유지하고있다
코드의 라인 라인,

286
00:12:53,130 --> 00:12:56,640
컴퓨터가 현재 실행되고 있는지,
뿐만 아니라 당신의 모든 변수로

287
00:12:56,640 --> 00:12:57,600
여기로.

288
00:12:57,600 --> 00:13:00,487
>> 그래서 당신은 센트, 동전, N있어,
모든 다른 일에 선언

289
00:13:00,487 --> 00:13:01,070
이 지점에서.

290
00:13:01,070 --> 00:13:04,850
걱정은, 때문에 우리는 실제로 없다
아직 변수로 초기화.

291
00:13:04,850 --> 00:13:07,200
컴퓨터에 따라서 당신의
컴퓨터는 단지 보는 것,

292
00:13:07,200 --> 00:13:14,376
오, 32767는 마지막으로 사용 된 기능이었다
내 컴퓨터에서 해당 메모리 공간.

293
00:13:14,376 --> 00:13:16,000
센트가 현재 어디에 그리고 그입니다.

294
00:13:16,000 --> 00:13:19,360
하지만 한번 당신은 코드를 실행하지
이 초기화 될 것이다.

295
00:13:19,360 --> 00:13:24,110
>> 그럼으로, 선을 통해 가자
라인, 어떻게 여기에 것입니다.

296
00:13:24,110 --> 00:13:25,350
그래.

297
00:13:25,350 --> 00:13:29,400
여기되도록 아르 세
난 그냥 설명 버튼.

298
00:13:29,400 --> 00:13:34,090
당신은, 재생 또는 실행 기능이
버튼을, 당신은 버튼을 통해 단계를

299
00:13:34,090 --> 00:13:36,600
당신은 또한 버튼으로 단계가 있습니다.

300
00:13:36,600 --> 00:13:41,260
그리고 본질적으로, 세 가지의
그들은 당신의 코드를 통해 이동

301
00:13:41,260 --> 00:13:42,690
다른 일을.

302
00:13:42,690 --> 00:13:45,680
>> 그래서 일반적으로 디버깅 할 때,
우리가 플레이를 치고 싶지 않아,

303
00:13:45,680 --> 00:13:47,930
재생 그냥 실행으로 인해
그것의 끝 코드.

304
00:13:47,930 --> 00:13:49,070
그리고 당신은 실제로하지 않습니다
알고있는 문제

305
00:13:49,070 --> 00:13:51,432
여러 중단 점을 설정하지 않은 경우입니다.

306
00:13:51,432 --> 00:13:53,890
여러 브레이크 포인트를 설정하면,
그냥 자동 것

307
00:13:53,890 --> 00:13:56,030
한 중단 점에서 실행,
다음에, 다음에.

308
00:13:56,030 --> 00:13:58,030
그러나이 경우 우리는했습니다
단지 하나, 우리 때문에

309
00:13:58,030 --> 00:13:59,970
우리의 방식으로 작동 할
위에서 아래로 아래에서.

310
00:13:59,970 --> 00:14:04,830
그래서 우리는 그 버튼을 무시하는거야
지금이 프로그램의 목적.

311
00:14:04,830 --> 00:14:08,230
>> 기능을 통해 단계 그러니
모든 단일 회선을 통해 단계

312
00:14:08,230 --> 00:14:11,510
당신을 알려줍니다 무엇을
컴퓨터가하고있다.

313
00:14:11,510 --> 00:14:14,630
기능에 단계 간다
실제 기능에

314
00:14:14,630 --> 00:14:16,000
그 코드의 당신의 라인에 있습니다.

315
00:14:16,000 --> 00:14:19,070
그래서 예를 들어, printf와 같은 (),
맞아, 기능인가?

316
00:14:19,070 --> 00:14:21,980
나는 육체적으로 단계 원한다면
의 printf () 함수로,

317
00:14:21,980 --> 00:14:25,610
사실의 조각으로 갈 것
의 printf ()가 작성되고 참조 된 코드

318
00:14:25,610 --> 00:14:26,730
무슨 일이 일어나고.

319
00:14:26,730 --> 00:14:29,924
>> 그러나 일반적으로, 우리는 가정
우리는 당신을 줄 코드가 작동합니다.

320
00:14:29,924 --> 00:14:31,340
우리는 ()가 작동 중이의 printf를 가정합니다.

321
00:14:31,340 --> 00:14:33,170
우리의 getInt ()가 작동하고 있다고 가정합니다.

322
00:14:33,170 --> 00:14:35,170
그래서 필요에가 없습니다
이러한 기능으로 단계.

323
00:14:35,170 --> 00:14:37,170
하지만 기능이 있다면
당신은 자신을 작성하는 것이

324
00:14:37,170 --> 00:14:39,060
당신은 확인하려는
무슨 일이 일어나고 있는지 알아,

325
00:14:39,060 --> 00:14:41,200
당신은 단계로 할 것
그 기능에.

326
00:14:41,200 --> 00:14:43,940
>> 그래서 지금 우리는 단지거야
이 코드 조각을 통해 진행한다.

327
00:14:43,940 --> 00:14:44,485
그래서 보자.

328
00:14:44,485 --> 00:14:46,547
아, 인쇄, "오 하이, 방법
많은 변화가 빚진? "

329
00:14:46,547 --> 00:14:47,130
우리는 상관하지 않습니다.

330
00:14:47,130 --> 00:14:49,830
우리는이 일 것을 알고,
그래서 우리는 그 위에 단계.

331
00:14:49,830 --> 00:14:53,290
>> 그래서 N, 우리의 플로트 인 그
우리는 initialized--했습니다 또는 declared--

332
00:14:53,290 --> 00:14:56,810
상단까지, 우리는 지금이야
GetFloat에 그 같게 ().

333
00:14:56,810 --> 00:14:57,810
그래서 그 이상의 단계 수 있습니다.

334
00:14:57,810 --> 00:14:59,580
그리고 우리는에서 참조
바닥 여기서, 프로그램

335
00:14:59,580 --> 00:15:03,360
값 입력에 나 메시지를 표시합니다.

336
00:15:03,360 --> 00:15:08,580
그래서 입력을의 우리가 원하는 값을 보자
0.41이다, 여기에 테스트합니다.

337
00:15:08,580 --> 00:15:09,160
좋아요.

338
00:15:09,160 --> 00:15:12,780
>> 그래서 지금 N-- 너희들은 참조 할
여기에, bottom-- 그것을이다

339
00:15:12,780 --> 00:15:15,140
stored-- 우리 때문에
아직 반올림하지 않은, 그건

340
00:15:15,140 --> 00:15:19,540
이 같은 거대한에 저장
0.4099999996이다 플로트,

341
00:15:19,540 --> 00:15:22,550
충분히 가까이있는 우리의
목적, ​​지금, 0.41.

342
00:15:22,550 --> 00:15:26,090
그리고 우리는 나중에로 볼 수 있습니다 우리
프로그램을 통해 스테핑 계속

343
00:15:26,090 --> 00:15:29,850
여기 후, N은이되었다
둥근 센트 (41)이되었다.

344
00:15:29,850 --> 00:15:30,350
좋아요.

345
00:15:30,350 --> 00:15:32,230
그래서 우리는 우리의 라운딩의 작업 것을 알고있다.

346
00:15:32,230 --> 00:15:34,700
우리는 우리가있는 것을 알고있다
센트의 정확한 수,

347
00:15:34,700 --> 00:15:36,990
그래서 우리는 그건 알고
정말 문제.

348
00:15:36,990 --> 00:15:40,050
>> 그래서 우리는 스테핑 계속
이 프로그램에.

349
00:15:40,050 --> 00:15:40,900
우리는 여기.

350
00:15:40,900 --> 00:15:46,139
그리고이 코드 줄 후, 우리
우리가 얼마나 많은 분기 알고 있어야합니다.

351
00:15:46,139 --> 00:15:46,680
우리는 이상의 단계.

352
00:15:46,680 --> 00:15:52,040
그리고 당신은 우리가, 사실, 하나를해야합니까 참조
분기 우리가 25을 차감 한 때문에

353
00:15:52,040 --> 00:15:53,790
(41) 우리의 초기 값에서.

354
00:15:53,790 --> 00:15:55,890
그리고 우리는 우리의 센트 (16) 왼쪽 있습니다.

355
00:15:55,890 --> 00:15:58,830
>> 모든 사람들이 어떻게 이해합니까
이 프로그램은 단계별된다

356
00:15:58,830 --> 00:16:02,980
왜 센트는 지금 (16)이되었다
왜, 지금, 동전은 1되고있다?

357
00:16:02,980 --> 00:16:04,610
모든 사람이 그 논리를 다음인가?

358
00:16:04,610 --> 00:16:05,110
쿨.

359
00:16:05,110 --> 00:16:07,860
,이 점의 수 있도록
프로그램의 작업, 오른쪽?

360
00:16:07,860 --> 00:16:09,797
우리는 정확하고있어 알고
우리는 그것을 원하는 것을.

361
00:16:09,797 --> 00:16:11,880
그리고 우리는 실제로하지 않았다
오, 인쇄 할 수 있고, 무엇을

362
00:16:11,880 --> 00:16:14,430
이 시점에서 센트이며,
이 시점에서 동전 것입니다.

363
00:16:14,430 --> 00:16:17,170
>> 우리는 프로그램을 통해 지속될.

364
00:16:17,170 --> 00:16:18,100
이상의 단계.

365
00:16:18,100 --> 00:16:18,620
쿨.

366
00:16:18,620 --> 00:16:19,700
우리는 센트를 통해 이동합니다.

367
00:16:19,700 --> 00:16:20,200
좋아요.

368
00:16:20,200 --> 00:16:22,367
우리는 가지고 있다고 볼
한 푼에 대한 $ 0.10 끕니다.

369
00:16:22,367 --> 00:16:23,450
그리고 지금 우리는 두 개의 동전을 가지고있다.

370
00:16:23,450 --> 00:16:25,260
맞습니다.

371
00:16:25,260 --> 00:16:31,555
>> 우리는 동전 가서 우리가 참조
우리는 센트 이상 남았으니.

372
00:16:31,555 --> 00:16:32,680
흠, 그게 이상하다.

373
00:16:32,680 --> 00:16:37,540
여기에 프로그램에서까지, 나는 생각했다
내 동전을 차감 한 것으로.

374
00:16:37,540 --> 00:16:39,400
아마도 난 그냥이 아니었다
그 라인 오른쪽을하고.

375
00:16:39,400 --> 00:16:42,190
그리고 슬프게도, 당신은 볼 수 있습니다
여기, 우리가 알고 있기 때문에

376
00:16:42,190 --> 00:16:44,360
우리는 스테핑됩니다
라인 (32, 33)을 통해,

377
00:16:44,360 --> 00:16:50,560
그 곳에 우리의 프로그램
잘못 변수를 실행했다.

378
00:16:50,560 --> 00:16:55,136
그래서 우리는보고 오, 볼 수 있습니다,
여기 센트를 뺀거야,

379
00:16:55,136 --> 00:16:57,010
하지만 사실이 아니에요
내 코인 값에 추가.

380
00:16:57,010 --> 00:16:57,860
나는 센트에 추가 해요.

381
00:16:57,860 --> 00:17:00,234
그리고 난에 추가하지 않으
센트, 나는 동전에 추가 할.

382
00:17:00,234 --> 00:17:05,420
그래서 우리는 동전에 있음을 변경하는 경우,
우리는 작업 프로그램을 가지고있다.

383
00:17:05,420 --> 00:17:06,730
나는 check50를 실행할 수 있습니다.

384
00:17:06,730 --> 00:17:11,063
당신은 GDB 바로 나갈 수 있습니다
여기에 다시 check50를 실행합니다.

385
00:17:11,063 --> 00:17:11,938
난 그냥이 작업을 수행 할 수 있습니다.

386
00:17:11,938 --> 00:17:14,822

387
00:17:14,822 --> 00:17:18,480
나는 욕심 확인해야합니다.

388
00:17:18,480 --> 00:17:19,940
0.41.

389
00:17:19,940 --> 00:17:22,819
그리고 여기, 그것은 인쇄의
정답 아웃.

390
00:17:22,819 --> 00:17:26,569
>> 너희들이 볼 수 있도록, GDB
정말 강력한 도구입니다

391
00:17:26,569 --> 00:17:29,940
우리가 너무 많은 코드가있을 때를위한
에 가서 많은 변수

392
00:17:29,940 --> 00:17:32,510
그것으로, 우리를 위해 어려운 것을
인간의 트랙을 유지합니다.

393
00:17:32,510 --> 00:17:35,360
GDB에서 컴퓨터,
디버거는 능력을 갖는다

394
00:17:35,360 --> 00:17:37,020
모든 것을 추적 할 수 있습니다.

395
00:17:37,020 --> 00:17:40,480
아마 Visionaire에서, 너희들, 알고
일부 분할 오류를 칠 수도

396
00:17:40,480 --> 00:17:43,150
당신이 실행중인 때문에
배열의 경계 밖으로.

397
00:17:43,150 --> 00:17:46,510
시저의 예에서, 그건
정확히 내가 여기서 무엇을 구현했습니다.

398
00:17:46,510 --> 00:17:50,060
>> 그래서 확인하는 것을 잊었다
무슨 일이 일어날 것이라고 나는

399
00:17:50,060 --> 00:17:52,510
두 개의 명령 줄 인수를하지 않았다.

400
00:17:52,510 --> 00:17:53,880
난 그냥 체크에 넣어하지 않았다.

401
00:17:53,880 --> 00:17:57,380
내가 Debug--을 실행하면 그래서 나는 설정
내 브레이크 포인트가 오른쪽으로.

402
00:17:57,380 --> 00:17:58,055
나는 디버그를 실행합니다.

403
00:17:58,055 --> 00:18:15,880

404
00:18:15,880 --> 00:18:16,550
>> 그래.

405
00:18:16,550 --> 00:18:17,050
그래.

406
00:18:17,050 --> 00:18:20,350
그래서 실제로, GDB는했는데
가 나에게 말했다 가지고

407
00:18:20,350 --> 00:18:22,300
이 세그먼트 오류였다.

408
00:18:22,300 --> 00:18:24,883
나는 무슨 일이 있었는지 모른다
바로 거기에,하지만 난 그것을 실행했을 때

409
00:18:24,883 --> 00:18:25,590
그것은 작동했다.

410
00:18:25,590 --> 00:18:29,410
당신은을 통해 코드 라인을 실행할 때와
GDB는 갑자기, 당신을 종료 할 수

411
00:18:29,410 --> 00:18:31,540
가서 빨간색 오류가 무엇인지 봐.

412
00:18:31,540 --> 00:18:33,930
그것은,이 봐, 당신을 말해주지
세그먼트 오류를​​했다,

413
00:18:33,930 --> 00:18:38,550
이는 당신이 접근을 시도한다는 것을 의미
존재하지 않는 배열의 공간.

414
00:18:38,550 --> 00:18:39,050
그래.

415
00:18:39,050 --> 00:18:43,280
>> 다음 문제에 따라서
이번 주를 설정, 너희들

416
00:18:43,280 --> 00:18:45,600
아마 많이있을 것이다
변수는 주위에 떠있는.

417
00:18:45,600 --> 00:18:48,560
당신은 확실히 될 수 없습니다하는지
그들 모두는 특정 시점에서 의미한다.

418
00:18:48,560 --> 00:18:53,560
그래서 GDB는 정말 파악에 도움이 될 것입니다
그들은 모두 같게하는지 알아

419
00:18:53,560 --> 00:18:55,940
시각적 것을 볼 수있는.

420
00:18:55,940 --> 00:19:01,995
사람이 방법에 혼란
그 중 하나가 작동했다?

421
00:19:01,995 --> 00:19:02,495
쿨.

422
00:19:02,495 --> 00:19:10,121

423
00:19:10,121 --> 00:19:10,620
괜찮아.

424
00:19:10,620 --> 00:19:14,260
그래서 그 후, 우리는
바로 다이빙 것

425
00:19:14,260 --> 00:19:17,562
에 서로 다른 네 가지입니다
이번 주에 대한 종류의 유형.

426
00:19:17,562 --> 00:19:19,520
어떻게 많은 먼저
모두, 우리가 시작하기 전에,

427
00:19:19,520 --> 00:19:23,020
pset3의 전체 사양을 읽고?

428
00:19:23,020 --> 00:19:23,824
그래.

429
00:19:23,824 --> 00:19:24,740
나는 너희들의 자랑 스럽습니다.

430
00:19:24,740 --> 00:19:29,110
즉, 클래스의 절반처럼하는
지난 번보다 훨씬 더 많은입니다.

431
00:19:29,110 --> 00:19:33,950
>> 그래서, 좋은 때 때문에
우리는 콘텐츠에 대해 이야기

432
00:19:33,950 --> 00:19:36,170
lecture-- 또는 미안에,
section--에서 내가 좋아하는

433
00:19:36,170 --> 00:19:38,210
그 많은 관련합니다
다시 PSET가 무엇인지에

434
00:19:38,210 --> 00:19:40,210
당신이 원하는 방법
당신의 PSET에 그를 구현한다.

435
00:19:40,210 --> 00:19:42,400
당신이 가지고 온다면
사양을 읽고, 그것을거야

436
00:19:42,400 --> 00:19:45,510
당신이 이해하기 훨씬 쉽게 할 수
내가 말할 때 무슨 말인지,

437
00:19:45,510 --> 00:19:48,720
헤이 오, 정말이 될 수 있습니다
이런 종류를 구현하는 좋은 장소.

438
00:19:48,720 --> 00:19:52,870
읽고있는 당신의 그것들을 따라서
당신의 PSET의 일환으로, 알고 SPEC,

439
00:19:52,870 --> 00:19:54,900
당신이해야 할거야
종류의 유형을 작성합니다.

440
00:19:54,900 --> 00:19:58,670
그래서 이것은 매우 도움이 될 수 있습니다
당신의 많은 오늘.

441
00:19:58,670 --> 00:20:01,760
>> 그래서 우리는 함께 시작합니다,
본질적으로, 가장 간단한 유형

442
00:20:01,760 --> 00:20:04,580
의 종류, 선택 정렬.

443
00:20:04,580 --> 00:20:06,800
의 일반적인 알고리즘
우리는 이것에 대해 가고 싶어하는 방법

444
00:20:06,800 --> 00:20:10,460
is-- 다윗은 모든 이들 겪었
강의, 그래서 나는 빨리 따라 이동합니다

445
00:20:10,460 --> 00:20:13,900
here-- 당신은, 본질적으로
값의 배열을 갖는다.

446
00:20:13,900 --> 00:20:17,170
그리고 당신은 찾을 수
작은 정렬되지 않은 값

447
00:20:17,170 --> 00:20:20,200
당신은 그 값을 교환
첫 번째 정렬되지 않은 값입니다.

448
00:20:20,200 --> 00:20:22,700
그리고 당신은 계속 반복
목록의 나머지.

449
00:20:22,700 --> 00:20:25,740
>> 그리고 여기에 시각적 인 설명이다
그래도 문제가 해결하는 방법의.

450
00:20:25,740 --> 00:20:30,460
우리가 있었던 경우에 따라서 예를 들어, 시작
다섯 가지 요소의 배열 인덱스

451
00:20:30,460 --> 00:20:35,910
0 내지 4, 3, 5, 2, 6, 4 값
그래서 지금 array--에 배치,

452
00:20:35,910 --> 00:20:38,530
우리는 단지 가정거야
그들은 모두 정렬되지 않은를 걸

453
00:20:38,530 --> 00:20:41,130
우리가 다른 테스트하지 않았기 때문에.

454
00:20:41,130 --> 00:20:44,130
>> 어떻게 선택 종류의 것
작업은 처음 것입니다

455
00:20:44,130 --> 00:20:46,800
전체를 통해 실행
정렬되지 않은 배열의 형태가됩​​니다.

456
00:20:46,800 --> 00:20:49,120
그것은 가장 작은 값을 선택합니다.

457
00:20:49,120 --> 00:20:51,750
이 경우, 3에서 오른쪽
이제 작다.

458
00:20:51,750 --> 00:20:52,680
그것은 5 가져옵니다.

459
00:20:52,680 --> 00:20:55,620
아니, 5 than-- 크지
또는 죄송합니다, 3 than-- 이하이다.

460
00:20:55,620 --> 00:20:57,779
그래서 최소 값은 여전히​​ 3입니다.

461
00:20:57,779 --> 00:20:58,695
그리고 당신은 2에 도착.

462
00:20:58,695 --> 00:21:00,990
아보고 컴퓨터 2는 3 미만이다.

463
00:21:00,990 --> 00:21:02,750
(2)는 지금의 최소 값이어야합니다.

464
00:21:02,750 --> 00:21:06,630
그리고 그 첫 번째 값 2 스왑.

465
00:21:06,630 --> 00:21:10,702
>> 그래서 하나의 패스를, 우리는 참으로 보는가
그 2, 3 스왑됩니다.

466
00:21:10,702 --> 00:21:13,910
그리고 우리는 단지 일을 계속하는거야
이 다시 배열의 나머지.

467
00:21:13,910 --> 00:21:17,660
그래서 우리는 단지를 통해 실행하는거야
어레이의 마지막 네 인덱스.

468
00:21:17,660 --> 00:21:20,670
우리는 3 인 것을 확인할 수 있습니다
다음 최소값.

469
00:21:20,670 --> 00:21:23,240
그래서 우리는 4 그것을 바꿀 것입니다.

470
00:21:23,240 --> 00:21:26,900
그리고 우리는 단지 계속거야
결국, 때까지 실행을 통해, 당신

471
00:21:26,900 --> 00:21:33,730
정렬 된 배열에 도착하는
2, 3, 4, 5, 6이 모두 정렬된다.

472
00:21:33,730 --> 00:21:37,530
모든 사람이 논리를 이해 하는가
선택 정렬이 작동하는 방법?

473
00:21:37,530 --> 00:21:39,669
>> 당신은 어떤 종류가
최소값.

474
00:21:39,669 --> 00:21:41,210
당신은 그게 뭔지를 추적하고 있습니다.

475
00:21:41,210 --> 00:21:45,170
당신이 그것을 찾을 때마다, 당신은 그것을 교환
array--의 첫 번째 값

476
00:21:45,170 --> 00:21:48,740
OR, NOT 제 value--
배열의 다음 값.

477
00:21:48,740 --> 00:21:50,150
쿨.

478
00:21:50,150 --> 00:21:55,460
>> 그래서 너희들과 같은 종류의
짧은 엿볼에서 보았다,

479
00:21:55,460 --> 00:21:58,450
우리는이를 의사 것입니다.

480
00:21:58,450 --> 00:22:02,510
그래서 다시 너희들이 원하는 경우
테이블에 그룹 모두를 형성

481
00:22:02,510 --> 00:22:06,170
작은 파트너를 형성 할 수있는, 내가 갈거야
당신에게 삼분 같은 사람을주고

482
00:22:06,170 --> 00:22:08,190
다만 통해 얘기
논리, 영어,

483
00:22:08,190 --> 00:22:14,161
우리는 구현할 수 있습니다 얼마나
의사는 선택 정렬을 작성합니다.

484
00:22:14,161 --> 00:22:14,910
그리고 사탕이있다.

485
00:22:14,910 --> 00:22:16,118
와서 사탕을 보내 주시기 바랍니다.

486
00:22:16,118 --> 00:22:19,520
당신은 뒤에이고 당신이 원하는 경우
사탕, 난 당신에 사탕을 던질 수 있습니다.

487
00:22:19,520 --> 00:22:22,850
사실, 얘들 아 멋진을한다.

488
00:22:22,850 --> 00:22:23,552
아, 죄송합니다.

489
00:22:23,552 --> 00:22:26,751

490
00:22:26,751 --> 00:22:27,250
그래.

491
00:22:27,250 --> 00:25:23,880

492
00:25:23,880 --> 00:25:27,140
>> 우리는, 좋아하면 그래서
클래스, 쓰기 의사

493
00:25:27,140 --> 00:25:30,466
사람이 접근 할 수있는 방법에 대한
이 문제는 단지 주시기 바랍니다.

494
00:25:30,466 --> 00:25:32,340
난 그냥 주위에 갈 것이다,
순서 기 물어

495
00:25:32,340 --> 00:25:35,065
의 다음 라인
우리는 무슨 일을해야한다.

496
00:25:35,065 --> 00:25:37,840
너희들이 시작 싶다면
오프, 제일 먼저 무엇을

497
00:25:37,840 --> 00:25:40,600
당신이 시도 할 때해야 할 일
본 프로그램을 해결하는 방법을 구현

498
00:25:40,600 --> 00:25:43,480
선택적으로 목록을 정렬하려면?

499
00:25:43,480 --> 00:25:46,349
단지 우리 가정의하자
배열, 모든 권리가있다?

500
00:25:46,349 --> 00:25:49,088
>> 청중 : 당신은 어떤을 만들려면
일종의 [들림] 당신은 걸

501
00:25:49,088 --> 00:25:50,420
전체 배열을 통해 실행.

502
00:25:50,420 --> 00:25:51,128
>> ANDI 펭 : 오른쪽.

503
00:25:51,128 --> 00:25:54,100
그래서 당신은 반복 할거야
모든 공간을 통해, 오른쪽?

504
00:25:54,100 --> 00:26:05,490
그래서 큰.

505
00:26:05,490 --> 00:26:08,600
너희들은 나에게주고 싶은 경우
다음 뒤쪽에, 그래 line--.

506
00:26:08,600 --> 00:26:11,414

507
00:26:11,414 --> 00:26:13,290
>> 청중 : 그들을 확인
모든 작은합니다.

508
00:26:13,290 --> 00:26:14,248
>> ANDI 펭 : 거기 우리는 간다.

509
00:26:14,248 --> 00:26:17,438
그래서 우리는 통과하고 검사 할
최소 값, 오른쪽 뭐가 있는지?

510
00:26:17,438 --> 00:26:22,110

511
00:26:22,110 --> 00:26:24,840
나는 해당 축약거야 "분."

512
00:26:24,840 --> 00:26:27,658
너희들은 이후에 무엇을 하시겠습니까?
당신은 최소 값을 발견했습니다?

513
00:26:27,658 --> 00:26:28,533
>> 청중 : [들리지]

514
00:26:28,533 --> 00:26:29,942

515
00:26:29,942 --> 00:26:33,150
ANDI 펭 : 그래서 당신이 원하는거야
그 배열의 첫 번째로 전환,

516
00:26:33,150 --> 00:26:33,650
권리?

517
00:26:33,650 --> 00:26:45,120

518
00:26:45,120 --> 00:26:46,850
그게 내가 말할거야, 시작입니다.

519
00:26:46,850 --> 00:26:47,220
괜찮아.

520
00:26:47,220 --> 00:26:50,386
그래서 지금 당신이 첫 번째를 교환했다고
하나, 당신은 무엇을 그 후 수행 할 수 있습니까?

521
00:26:50,386 --> 00:26:54,840
그래서 지금 우리가 알고 여기 하나
오른쪽 작은 값이어야합니다?

522
00:26:54,840 --> 00:26:58,310
그럼 당신은 추가 휴식을
정렬되지 않은의 배열.

523
00:26:58,310 --> 00:27:01,569
그래서 당신은 당신이 경우에, 여기에 수행 할 작업
사람들은 나에게 다음 라인을주고 싶어?

524
00:27:01,569 --> 00:27:04,610
청중 : 그럼 당신은 반복 할
배열의 나머지 부분을 통해.

525
00:27:04,610 --> 00:27:05,276
ANDI 펭 : 네.

526
00:27:05,276 --> 00:27:09,857
그리고를 반복하는 일
종류의 우리가 아마해야 의미?

527
00:27:09,857 --> 00:27:10,440
어떤 종류의 동행입니다

528
00:27:10,440 --> 00:27:12,057
>> 청중 : 아, 추가 변수?

529
00:27:12,057 --> 00:27:13,890
ANDI 펭 : 아마
루프에 대한 또 다른, 오른쪽?

530
00:27:13,890 --> 00:27:28,914
그래서 우리는 아마 원하는거야
through-- 큰를 반복합니다.

531
00:27:28,914 --> 00:27:31,830
그리고 당신이 돌아 갈거야 및
아마 다시 최소를 확인,

532
00:27:31,830 --> 00:27:32,100
권리?

533
00:27:32,100 --> 00:27:34,975
그리고 당신은 계속 반복거야
이, 루프 때문에 단지 것

534
00:27:34,975 --> 00:27:36,010
오른쪽으로 계속 실행하는 방법?

535
00:27:36,010 --> 00:27:39,190
>> 그래서 너희들은 우리를 볼 수 있습니다
그냥 일반 의사가

536
00:27:39,190 --> 00:27:41,480
우리가 원하는 방법으로이 프로그램을 찾으십시오.

537
00:27:41,480 --> 00:27:46,646
여기에이 반복 처리, 우리는 무엇을
일반적으로 우리의 코드를 작성해야

538
00:27:46,646 --> 00:27:49,270
우리는 반복하려는 경우
구조의 배열, 어떤 유형?

539
00:27:49,270 --> 00:27:51,030
나는 Christabel 생각
이미 이전에이 말했다.

540
00:27:51,030 --> 00:27:51,500
>> 청중 : 루프.

541
00:27:51,500 --> 00:27:52,160
>> ANDI 펭 : 루프?

542
00:27:52,160 --> 00:27:52,770
정확히.

543
00:27:52,770 --> 00:27:56,060
그래서 이것은 아마
for 루프가 될 것.

544
00:27:56,060 --> 00:27:59,240
암시하는 것 여기에 체크가 무엇입니까?

545
00:27:59,240 --> 00:28:02,536
일반적으로 검사 할 경우
뭔가 뭔가 경우 else--

546
00:28:02,536 --> 00:28:03,270
>> 청중 :합니다.

547
00:28:03,270 --> 00:28:06,790
>> ANDI 펭 : 경우, 오른쪽?

548
00:28:06,790 --> 00:28:10,790
여기에 스왑 그리고, 우리는거야
나중에 가서 다윗 때문에

549
00:28:10,790 --> 00:28:12,770
뿐만 아니라 강의에서이 높아졌습니다.

550
00:28:12,770 --> 00:28:14,580
그리고 두 번째 반복 처리 implies--

551
00:28:14,580 --> 00:28:15,120
>> 청중 : 루프에 대한 또 다른.

552
00:28:15,120 --> 00:28:16,745
>> ANDI 펭 : 정확히, 루프 --another.

553
00:28:16,745 --> 00:28:19,870

554
00:28:19,870 --> 00:28:22,000
우리가 찾는 경우에 따라서
올바르게에서, 우리

555
00:28:22,000 --> 00:28:24,680
우리는 아마 걸 볼 수 있습니다
루프 중첩 필요할 것

556
00:28:24,680 --> 00:28:28,330
거기 조건부 문
다음 코드의 실제 조각의 그

557
00:28:28,330 --> 00:28:31,360
값을 바꿀 것.

558
00:28:31,360 --> 00:28:35,980
그래서 난 그냥 일반적으로 작성했습니다
여기 의사 코드입니다.

559
00:28:35,980 --> 00:28:38,910
그리고 우리가 실제로거야
물리적으로, 클래스와,

560
00:28:38,910 --> 00:28:40,700
이 오늘을 구현하려고합니다.

561
00:28:40,700 --> 00:28:42,486
의이 IDE로 돌아 가자.

562
00:28:42,486 --> 00:28:49,243

563
00:28:49,243 --> 00:28:50,230
>> 어 오.

564
00:28:50,230 --> 00:28:51,754
왜 거기 하죠 그래는 것입니다.

565
00:28:51,754 --> 00:28:52,253
그래.

566
00:28:52,253 --> 00:28:55,834

567
00:28:55,834 --> 00:28:57,500
죄송합니다, 저를 좀 더 확대하려고 할 수 있습니다.

568
00:28:57,500 --> 00:28:59,310
우리는 거기에 갈.

569
00:28:59,310 --> 00:29:05,060
내가 여기서하고있어 모든 내가 만든됩니다
라는 프로그램 "선택 / sort.c."

570
00:29:05,060 --> 00:29:10,860
나는 아홉의 배열을 만들었습니다
값, 4, 8, 2, 1, 6, 9, 7, 5, 3.

571
00:29:10,860 --> 00:29:14,370
현재, 당신은 할 수 있습니다
그들은 순서가, 참조하십시오.

572
00:29:14,370 --> 00:29:17,880
n은 숫자가 될 것입니다 그
만약 그 값의 양을 말한다

573
00:29:17,880 --> 00:29:18,920
당신은 당신의 배열에있다.

574
00:29:18,920 --> 00:29:20,670
이 경우, 우리는 아홉 값을 갖는다.

575
00:29:20,670 --> 00:29:23,760
그리고 난 그냥 여기에 루프를 가지고
즉, 정렬되지 않은 배열을 출력합니다.

576
00:29:23,760 --> 00:29:28,370
>> 그리고 마지막에, 나는 또한에 대한있어
그냥 다시를 출력 루프.

577
00:29:28,370 --> 00:29:32,070
이론적으로,이 경우, 프로그램
마지막에, 제대로 작동,

578
00:29:32,070 --> 00:29:35,670
당신은 루프에 대한 인쇄를 참조한다
된 1, 2, 3, 4, 5, 6, 7, 8,

579
00:29:35,670 --> 00:29:39,310
9 위해 모든 올바르게 있습니다.

580
00:29:39,310 --> 00:29:43,410
>> 그래서 우리는 여기에 우리의 의사를 가지고있다.

581
00:29:43,410 --> 00:29:46,090
난 그냥 해요 이러시면 사람이 원합니까
volunteers-- 요청 갈

582
00:29:46,090 --> 00:29:49,540
경우에 무엇을 입력 정확히 말해
우리는 먼저, 단지 반복 할

583
00:29:49,540 --> 00:29:52,840
이 배열의 시작 부분을 통해?

584
00:29:52,840 --> 00:29:55,204
난 코드의 라인은 무엇입니까
아마 여기에서 필요로하는 것?

585
00:29:55,204 --> 00:29:56,990
>> 청중 : [들리지]

586
00:29:56,990 --> 00:29:59,010
>> ANDI 펭 : 그래, 기분
무료 이러시면 미안 해요, 당신을

587
00:29:59,010 --> 00:30:02,318
up-- 느낌을 참을 필요가 없습니다
음성 비트 인상 무료.

588
00:30:02,318 --> 00:30:08,190
>> 청중 : INT의 난에 해당 내용 0--

589
00:30:08,190 --> 00:30:10,690
>> ANDI 펭 : 그래, 좋아.

590
00:30:10,690 --> 00:30:15,220
>> 청중 : 내가 배열의 길이보다 작습니다.

591
00:30:15,220 --> 00:30:19,630
>> ANDI 펭 : 그래서에서 유지
여기에 마음을 우리 때문에

592
00:30:19,630 --> 00:30:23,060
기능이 없어
우리는 어레이의 길이를 알려주

593
00:30:23,060 --> 00:30:25,790
우리는 이미이
그 저장 값.

594
00:30:25,790 --> 00:30:27,920
권리?

595
00:30:27,920 --> 00:30:31,010
또 다른 것은 유지
배열 mind--에

596
00:30:31,010 --> 00:30:33,940
아홉 값으로, 인덱스는 무엇인가?

597
00:30:33,940 --> 00:30:38,720
그냥이 배열은 0 ~ 3이었다 가정 해 봅시다.

598
00:30:38,720 --> 00:30:41,500
당신은 마지막으로 볼
지수는 실제로 3입니다.

599
00:30:41,500 --> 00:30:45,530
그것은 거기에도 불구하고, 4 아니다
배열의 네 개의 값.

600
00:30:45,530 --> 00:30:49,866
>> 여기에 그래서, 우리는 매우 신중해야
길이 무엇인지 우리의 조건

601
00:30:49,866 --> 00:30:50,490
될 것입니다.

602
00:30:50,490 --> 00:30:51,948
>> 청중 : 그것은 N 마이너스 1을하지 않을까요?

603
00:30:51,948 --> 00:30:54,440
ANDI 펭 : 그것은거야
정확히 N 마이너스 1.

604
00:30:54,440 --> 00:30:57,379
그 말이, 왜
그것은 N 영하 1, 모두?

605
00:30:57,379 --> 00:30:58,920
배열은 제로 인덱스이기 때문이다.

606
00:30:58,920 --> 00:31:02,010
그들은 0에서 시작하고 1 N 마이너스까지 실행합니다.

607
00:31:02,010 --> 00:31:03,210
네, 조금 까다로운.

608
00:31:03,210 --> 00:31:03,730
그래.

609
00:31:03,730 --> 00:31:05,929
그리고--

610
00:31:05,929 --> 00:31:08,054
청중 : Isnt'1 그
이미하지만 알아서,

611
00:31:08,054 --> 00:31:11,400
다만보다 이하 "라고하지 않음으로써
동일 미만 "그냥 말"로? "

612
00:31:11,400 --> 00:31:13,108
>> ANDI 펭 : 그것은이다
정말 좋은 질문입니다.

613
00:31:13,108 --> 00:31:13,630
그래서, 예.

614
00:31:13,630 --> 00:31:17,410
뿐만 아니라, 우리는 길을 걸
검사 권한을 구현,

615
00:31:17,410 --> 00:31:19,120
두 값을 비교해야합니다.

616
00:31:19,120 --> 00:31:21,009
그래서 당신은 실제로 원하는
"을"빈 둡니다.

617
00:31:21,009 --> 00:31:23,050
당신이 비교하는 경우 때문에
이 하나, 당신은하지 않을거야

618
00:31:23,050 --> 00:31:25,530
그 후 아무것도
오른쪽에 비교?

619
00:31:25,530 --> 00:31:27,460
그래.

620
00:31:27,460 --> 00:31:29,297
그래서 ++.

621
00:31:29,297 --> 00:31:30,380
이제 우리의 브라켓을 추가 할 수 있습니다.

622
00:31:30,380 --> 00:31:30,880
으악.

623
00:31:30,880 --> 00:31:33,950

624
00:31:33,950 --> 00:31:34,710
좋아요.

625
00:31:34,710 --> 00:31:39,117
그래서 우리는 시작이
우리의 외부 루프의.

626
00:31:39,117 --> 00:31:41,450
그래서 지금 우리는 아마 원하는
유지하는 변수를 생성

627
00:31:41,450 --> 00:31:43,085
가장 작은 값을 추적, 오른쪽?

628
00:31:43,085 --> 00:31:45,751
사람이 나에게주고 싶어합니까
그렇게 할 것입니다 코드의 라인?

629
00:31:45,751 --> 00:31:48,700

630
00:31:48,700 --> 00:31:53,570
우리가려고하는 경우에 우리는 무엇을해야합니까
뭔가를 저장할 수 있습니다?

631
00:31:53,570 --> 00:31:55,047
>> 권리.

632
00:31:55,047 --> 00:31:57,630
그 어쩌면 더 나은 이름
"온도"를 이따가 것이다 완전히 works--

633
00:31:57,630 --> 00:32:00,655
어쩌면 더 적절하게 될 것이다라는,
우리는 작은 value--을 원하는 경우

634
00:32:00,655 --> 00:32:01,624
>> 청중 : 최소.

635
00:32:01,624 --> 00:32:02,790
ANDI 펭 : 분, 거기 우리는 간다.

636
00:32:02,790 --> 00:32:05,230
분은 좋은 것입니다.

637
00:32:05,230 --> 00:32:08,340
그리고 여기, 우리가 무엇을 할
로 초기화 할?

638
00:32:08,340 --> 00:32:09,620
이것은 조금 까다 롭습니다.

639
00:32:09,620 --> 00:32:13,580
때문에 지금의
이 배열의 시작,

640
00:32:13,580 --> 00:32:15,730
당신이 바로, 아무것도에 못 봤어?

641
00:32:15,730 --> 00:32:19,200
자동 그래서 무엇, 경우
우리는 그냥 0 일에있어

642
00:32:19,200 --> 00:32:22,302
우리는 초기화 원하는 작업
우리의 제 1 최소 값?

643
00:32:22,302 --> 00:32:22,802
청중 : 나는.

644
00:32:22,802 --> 00:32:24,790
ANDI 펭 : I, 정확하게.

645
00:32:24,790 --> 00:32:27,040
Christabel, 왜 우리가 원하는 수행
나는 그것을 초기화?

646
00:32:27,040 --> 00:32:28,510
>> 청중 : 잘, 때문에
우리는 0부터 시작하고 있습니다.

647
00:32:28,510 --> 00:32:31,660
우리가 비교 아무 상관이 없기 때문에 그래서
그것은, 최소 0 인 끝날 것입니다.

648
00:32:31,660 --> 00:32:32,451
>> ANDI 펭 : 맞아요.

649
00:32:32,451 --> 00:32:34,400
그래서 그녀는 정확히 맞아.

650
00:32:34,400 --> 00:32:36,780
우리가 실제로 가지고 있기 때문에
, 아직 아무것도 보았다

651
00:32:36,780 --> 00:32:38,680
우리는 우리의 최소한의 값이 무엇인지 모른다.

652
00:32:38,680 --> 00:32:41,960
우리는 단지에 초기화 할
내가있는 현재, 바로 여기에있다.

653
00:32:41,960 --> 00:32:44,750
그리고 우리는에 계속
이 배열을 아래로 이동,

654
00:32:44,750 --> 00:32:48,122
우리는 각각, 그를 볼 수 있습니다
추가 패스, 내가 증가.

655
00:32:48,122 --> 00:32:49,830
그리고 그 시점에서,
나는 아마 것입니다

656
00:32:49,830 --> 00:32:52,329
최소되고 싶어합니다,
그것은 무엇을 될 것 때문에

657
00:32:52,329 --> 00:32:54,520
정렬되지 않은 배열의 시작입니다.

658
00:32:54,520 --> 00:32:55,270
쿨.

659
00:32:55,270 --> 00:32:58,720
>> 그래서 지금 우리는 추가 할
여기에 루프 그건

660
00:32:58,720 --> 00:33:03,225
을 반복하는 것
분류되지 않은, 또는이 배열의 나머지.

661
00:33:03,225 --> 00:33:05,808
사람이 나에게주고 싶어합니까
그렇게 할 것입니다 코드의 라인?

662
00:33:05,808 --> 00:33:08,870

663
00:33:08,870 --> 00:33:11,330
Hint-- 우리는 여기에서 무엇을해야합니까?

664
00:33:11,330 --> 00:33:17,320

665
00:33:17,320 --> 00:33:18,820
무엇 루프이 갈거야?

666
00:33:18,820 --> 00:33:19,465
그래.

667
00:33:19,465 --> 00:33:21,590
청중 : 그래서 우리가 원하는 것
다른 정수를 가지고,

668
00:33:21,590 --> 00:33:25,080
우리는 나머지를 통해 실행하고 있기 때문에
대신 나는 배열, 그래서 아마의

669
00:33:25,080 --> 00:33:25,760
J.

670
00:33:25,760 --> 00:33:27,301
>> ANDI 펭 : 그래, j는 나에게 좋은 소리.

671
00:33:27,301 --> 00:33:27,850
같음?

672
00:33:27,850 --> 00:33:33,930
>> 청중 : 그래서 때문에, 나는 수에 1을 더한 것
당신은 다음 값에서 시작하고있다.

673
00:33:33,930 --> 00:33:40,395
그리고 그렇게 다시 end--에, J는
N 마이너스 1을 입력 한 다음 J ++보다.

674
00:33:40,395 --> 00:33:41,103
ANDI 펭 : 좋아요.

675
00:33:41,103 --> 00:33:48,510

676
00:33:48,510 --> 00:33:52,750
>> 그리고 여기, 우리가 원하는거야
우리의 조건이 충족되어 있는지 확인합니다,

677
00:33:52,750 --> 00:33:53,250
권리?

678
00:33:53,250 --> 00:33:55,740
당신이 원하기 때문에
최소값을 변경

679
00:33:55,740 --> 00:33:58,700
그것보다 실제로 더 작은 있다면 무엇
당신은 오른쪽과 비교거야?

680
00:33:58,700 --> 00:34:01,146
그래서 우리는 여기에서 원하는거야?

681
00:34:01,146 --> 00:34:04,160

682
00:34:04,160 --> 00:34:04,897
확인하십시오.

683
00:34:04,897 --> 00:34:06,730
문 어떤 종류의
우리는 아마 가고있다

684
00:34:06,730 --> 00:34:08,389
TI는 경우에 사용하려는 우리
뭔가를 확인하려면?

685
00:34:08,389 --> 00:34:09,360
>> 청중 : if 문.

686
00:34:09,360 --> 00:34:10,485
>> ANDI 펭 : if 문.

687
00:34:10,485 --> 00:34:13,155
그래서 혹시 ...하고있을거야 무슨
우리 안에 원하는 조건

688
00:34:13,155 --> 00:34:13,988
우리의 경우 문의?

689
00:34:13,988 --> 00:34:18,255

690
00:34:18,255 --> 00:34:22,960
>> 청중 : 만약 J의 값
난 -의 값보다 작

691
00:34:22,960 --> 00:34:24,600
>> ANDI 펭 : 맞아요.

692
00:34:24,600 --> 00:34:27,480
그래서 혹시 ... 그래서이 배열은 "배열"이라고합니다.

693
00:34:27,480 --> 00:34:27,980
좋아요.

694
00:34:27,980 --> 00:34:30,465
그 무엇이었다 array--은 경우에 따라서?

695
00:34:30,465 --> 00:34:31,090
다시 말해.

696
00:34:31,090 --> 00:34:39,590
>> 청중 : 배열 J보다 작 으면
배열 나는, 우리는 분을 변경합니다.

697
00:34:39,590 --> 00:34:41,590
그래서 분 J 것이다.

698
00:34:41,590 --> 00:34:44,590

699
00:34:44,590 --> 00:34:47,249
>> ANDI 펭 : 그 말이됩니까?

700
00:34:47,249 --> 00:34:48,670
그래.

701
00:34:48,670 --> 00:34:52,929
그리고 지금 여기의 아래에서, 우리는 실제로
오른쪽 스왑을 구현하고 싶어?

702
00:34:52,929 --> 00:34:58,285
그래서, 강의, 기억 다윗 때
그는 짓이야 무엇 이었는가를 교환하기 위해 노력했다

703
00:34:58,285 --> 00:34:59,996
그건 ... 오렌지 주스와 milk--

704
00:34:59,996 --> 00:35:01,150
>> 청중 : 그 총이었다.

705
00:35:01,150 --> 00:35:02,816
>> ANDI 펭 : 그래, 그 종류의 총이었다.

706
00:35:02,816 --> 00:35:05,310
그러나 그것은 꽤 좋았다
개념 시간을 보여주는.

707
00:35:05,310 --> 00:35:08,430
그래서 여기에 당신의 가치를 생각.

708
00:35:08,430 --> 00:35:10,794
당신은 배열을 가지고있어
분, 난의 배열,

709
00:35:10,794 --> 00:35:12,460
또는 우리는 여기에 교환하려고했던 뭐든간에.

710
00:35:12,460 --> 00:35:15,310
그리고 당신은 아마로 부어 수 없습니다
동시에 서로 오른쪽?

711
00:35:15,310 --> 00:35:17,180
그래서 우리가 가고있는 것을
여기에 작성해야합니다

712
00:35:17,180 --> 00:35:19,126
제대로 값을 교환하기 위해?

713
00:35:19,126 --> 00:35:19,820
>> 청중 : 임시 변수.

714
00:35:19,820 --> 00:35:21,370
>> ANDI 펭 : 임시 변수.

715
00:35:21,370 --> 00:35:22,570
그럼 INT 온도를 할 수 있습니다.

716
00:35:22,570 --> 00:35:25,681
이 더 나은 것, 참조
워 이러시면 시간, 그 게 무슨?

717
00:35:25,681 --> 00:35:26,180
그래.

718
00:35:26,180 --> 00:35:29,800
그래서이 더 좋았을 것
시간은 변수 "온도를."이름을 지정합니다

719
00:35:29,800 --> 00:35:30,730
그럼 INT 온도를 할 수 있습니다.

720
00:35:30,730 --> 00:35:32,563
우리는 무엇을하려고
여기에서 동일한 온도를 설정?

721
00:35:32,563 --> 00:35:34,752

722
00:35:34,752 --> 00:35:35,335
청중 : 최소?

723
00:35:35,335 --> 00:35:38,508

724
00:35:38,508 --> 00:35:39,716
ANDI 펭 : 그것은 조금 까다로운.

725
00:35:39,716 --> 00:35:43,110

726
00:35:43,110 --> 00:35:44,880
사실은 결국 중요하지 않습니다.

727
00:35:44,880 --> 00:35:47,690
그것은 무엇을 중요하지 않습니다
순서는 스왑을 선택

728
00:35:47,690 --> 00:35:50,862
만큼 당신이 확인하고있는 당신이있어
당신이 교환을하는지 추적을 유지.

729
00:35:50,862 --> 00:35:52,250
>> 청중 : 그것은 배열-I 수 있습니다.

730
00:35:52,250 --> 00:35:53,666
>> ANDI 펭 : 그래, 배열-I를 할 수 있습니다.

731
00:35:53,666 --> 00:35:55,950

732
00:35:55,950 --> 00:35:59,305
그리고 다음 줄거야
코드의 우리는 여기에 갖고 싶어?

733
00:35:59,305 --> 00:36:00,680
청중 : 배열 난 배열-J 같습니다.

734
00:36:00,680 --> 00:36:07,154

735
00:36:07,154 --> 00:36:08,070
ANDI 펭 : 그리고 마지막으로?

736
00:36:08,070 --> 00:36:12,070
청중 : 배열-j는 배열-I 같습니다.

737
00:36:12,070 --> 00:36:14,525
청중 : 또는 배열-J 같음
배열 temp-- 또는, 온도.

738
00:36:14,525 --> 00:36:17,135

739
00:36:17,135 --> 00:36:19,430
>> ANDI 펭 : OK.

740
00:36:19,430 --> 00:36:21,510
그래서이 작업을 실행할 수 있도록하고 참조
그것이 작동거야 경우.

741
00:36:21,510 --> 00:36:37,520

742
00:36:37,520 --> 00:36:39,335
그게 어디 일이?

743
00:36:39,335 --> 00:36:40,210
아, 그건 문제입니다.

744
00:36:40,210 --> 00:36:44,320
우리가있어, 라인 (40)에, 참조
배열-J를 사용하려고?

745
00:36:44,320 --> 00:36:47,022
그러나 여기서 만에 J 존재 하는가?

746
00:36:47,022 --> 00:36:48,402
>> 청중 : 루프에서.

747
00:36:48,402 --> 00:36:49,110
ANDI 펭 : 오른쪽.

748
00:36:49,110 --> 00:36:51,730
그래서 우리가해야 할 건가요?

749
00:36:51,730 --> 00:36:53,170
>> 청중 : 짓이야 밖에서 정의

750
00:36:53,170 --> 00:36:57,777

751
00:36:57,777 --> 00:37:00,610
청중 : 그래, 난 당신이 생각
문 오른쪽 경우 다른를 사용 하는가?

752
00:37:00,610 --> 00:37:05,230
그래서 같은 경우 minimum--
좋아, 내가 생각해 봅시다.

753
00:37:05,230 --> 00:37:08,170

754
00:37:08,170 --> 00:37:09,990
>> ANDI 펭 : 얘들 아, 시도
살펴 보자을 촬영합니다

755
00:37:09,990 --> 00:37:11,270
우리는 여기서 뭔가 무엇을 할 수있어 참조하십시오?

756
00:37:11,270 --> 00:37:11,811
>> 청중 : OK.

757
00:37:11,811 --> 00:37:15,900
최소가 동일하지 않는 경우에 따라서
최소 인 경우 j-- 그래서 여전히 난 -

758
00:37:15,900 --> 00:37:17,570
우리는 교체 할 필요가 없습니다 것입니다.

759
00:37:17,570 --> 00:37:22,450

760
00:37:22,450 --> 00:37:24,712
>> ANDI 펭 : 나는 그와 동일합니까?

761
00:37:24,712 --> 00:37:25,920
당신은 여기 싶은 말은?

762
00:37:25,920 --> 00:37:30,494
>> 청중 : 아니면 그래, 경우
최소 그래, 같지 나는 않습니다.

763
00:37:30,494 --> 00:37:39,627

764
00:37:39,627 --> 00:37:40,210
ANDI 펭 : OK.

765
00:37:40,210 --> 00:37:42,040
우물은 우리의 문제, 가지, 해결한다.

766
00:37:42,040 --> 00:37:47,265
하지만 여전히 해결되지 않습니다
J 이후 j--하면 어떻게됩니까의 문제

767
00:37:47,265 --> 00:37:49,890
그것의 외부에 존재하지 않는, 무엇을
당신은 우리가 함께 할 하시겠습니까?

768
00:37:49,890 --> 00:37:50,698
외부 선언?

769
00:37:50,698 --> 00:37:59,410

770
00:37:59,410 --> 00:38:02,730
의이 실행 해보자.

771
00:38:02,730 --> 00:38:04,435
어 오.

772
00:38:04,435 --> 00:38:06,200
우리의 종류는 작동하지 않습니다.

773
00:38:06,200 --> 00:38:10,060
>> 당신은 우리의 초기를 볼 수 있듯이
배열은 그 값을 가지고 있었다.

774
00:38:10,060 --> 00:38:14,800
그리고 나중에는해야한다
1, 2, 3, 4, 5, 6, 7, 8, 9에 있었다.

775
00:38:14,800 --> 00:38:15,530
그것은 작동하지 않습니다.

776
00:38:15,530 --> 00:38:16,030
아.

777
00:38:16,030 --> 00:38:17,184
우리는 무엇을해야합니까?

778
00:38:17,184 --> 00:38:17,850
청중 : 디버그.

779
00:38:17,850 --> 00:38:21,787

780
00:38:21,787 --> 00:38:23,370
ANDI 펭 : 좋아, 우리가 그것을 시도 할 수 있습니다.

781
00:38:23,370 --> 00:38:25,030
우리는 디버깅 할 수 있습니다.

782
00:38:25,030 --> 00:38:26,042
조금 축소.

783
00:38:26,042 --> 00:38:31,177

784
00:38:31,177 --> 00:38:33,656
이제 우리의 중단 점을 설정하자.

785
00:38:33,656 --> 00:38:37,280
의는 그때 엔 확인을 가자.

786
00:38:37,280 --> 00:38:40,444
>> 우리가 이미 알고 있기 때문에 그래서
이 라인, 15 (22)를 통해,

787
00:38:40,444 --> 00:38:43,610
내가 뭘 모든이기 때문에 working--된다
다만 통해 printing-- 반복

788
00:38:43,610 --> 00:38:45,406
내가 가서 그를 건너 뛸 수 있습니다.

789
00:38:45,406 --> 00:38:47,280
의 라인 (25)에서 시작하자.

790
00:38:47,280 --> 00:38:48,712
OOP는, 내가 그 없애 보자.

791
00:38:48,712 --> 00:38:51,598

792
00:38:51,598 --> 00:38:54,057
>> 청중 : 그래서 중단 점의
디버깅 어디 시작?

793
00:38:54,057 --> 00:38:54,890
ANDI 펭 : 또는 정지.

794
00:38:54,890 --> 00:38:55,670
청중 : 또는 정지.

795
00:38:55,670 --> 00:38:55,930
ANDI 펭 : 네.

796
00:38:55,930 --> 00:38:58,640
여러 중단 점을 설정할 수 있습니다
그냥 다른 하나에서 이동할 수 있습니다.

797
00:38:58,640 --> 00:39:01,590
그러나이 경우 우리는 모른다
여기서 오류가 일어나고있다.

798
00:39:01,590 --> 00:39:03,780
그래서 우리는 단지 원하는
위에서 아래로 시작합니다.

799
00:39:03,780 --> 00:39:05,020
네.

800
00:39:05,020 --> 00:39:05,550
그래.

801
00:39:05,550 --> 00:39:08,460
>> 그래서 여기에이 라인은 우리가 개입 할 수 있습니다.

802
00:39:08,460 --> 00:39:11,499
당신은 여기로 볼 수 있습니다
우리는 배열을 가지고있다.

803
00:39:11,499 --> 00:39:13,290
사람들은 값입니다
배열에있는 것이다.

804
00:39:13,290 --> 00:39:16,360
당신은 볼 수 있습니까, 그 방법 인덱스 0, 그것은
오 value--에 해당

805
00:39:16,360 --> 00:39:17,526
나는 확대하려고하는거야.

806
00:39:17,526 --> 00:39:20,650
죄송합니다, 정말 어렵다
배열 인덱스 0에서 see--합니다,

807
00:39:20,650 --> 00:39:24,090
우리는 4의 값을 가지며
다음 등 등.

808
00:39:24,090 --> 00:39:25,670
우리는 우리의 지역 변수가 있습니다.

809
00:39:25,670 --> 00:39:28,570
지금은 동일하다
우리가 원하는 0.

810
00:39:28,570 --> 00:39:31,540

811
00:39:31,540 --> 00:39:33,690
>> 그리고 이제 단계별로 유지 할 수 있습니다.

812
00:39:33,690 --> 00:39:36,850
우리의 최소값은 0과 같다
저희는 또한이 원하는.

813
00:39:36,850 --> 00:39:39,470

814
00:39:39,470 --> 00:39:45,560
그리고 우리는 우리의 두 번째 입력
루프 배열 J 배열-I 미만이면,

815
00:39:45,560 --> 00:39:46,380
어떤이 아니었다.

816
00:39:46,380 --> 00:39:48,130
그래서 당신은 어떻게 보았는가
즉, 그 이상 건너 뛴?

817
00:39:48,130 --> 00:39:52,430
>> 청중 : 그래서 만약해야
최소, 모든 that--해야하지 그

818
00:39:52,430 --> 00:39:55,424
루프의 첫 번째 내부에?

819
00:39:55,424 --> 00:39:57,340
ANDI 펭 : 아니, 때문에
당신은 여전히​​ 테스트 할.

820
00:39:57,340 --> 00:40:00,329
당신은 모든 비교를 수행 할
시간, 당신은 그것을 통해 실행 후에도.

821
00:40:00,329 --> 00:40:02,620
당신은 그것을 할 싶지 않아
첫 번째 통과에.

822
00:40:02,620 --> 00:40:05,240
당신은 그것을 수행 할
다시 각각의 추가 패스.

823
00:40:05,240 --> 00:40:07,198
그래서 당신은 확인하려면
내부 당신의 상태.

824
00:40:07,198 --> 00:40:11,610

825
00:40:11,610 --> 00:40:13,746
그래서 우리는 그냥 갈거야
여기를 통해 실행 유지.

826
00:40:13,746 --> 00:40:17,337

827
00:40:17,337 --> 00:40:18,420
나는 사람들에게 당신에게 힌트를 줄 것이다.

828
00:40:18,420 --> 00:40:23,910
그것은 사실과 관련이있다 때
당신은, 당신의 조건을 확인하고

829
00:40:23,910 --> 00:40:26,600
당신은 확인하지 않을
올바른 인덱스.

830
00:40:26,600 --> 00:40:32,510
그래서 지금 당신은 검사하고
J의 배열 인덱스 배열 미만인

831
00:40:32,510 --> 00:40:33,970
나는의 인덱스입니다.

832
00:40:33,970 --> 00:40:36,580
하지만 당신은에서까지 일을
루프의 시작?

833
00:40:36,580 --> 00:40:38,260
당신은 내가 동일한 J를 설정하지 않는거야?

834
00:40:38,260 --> 00:40:41,260

835
00:40:41,260 --> 00:40:45,415
>> 그래, 그래서 우리는 실제로 수
여기에 디버거를 종료합니다.

836
00:40:45,415 --> 00:40:47,040
그럼 우리의 의사 살펴 보자.

837
00:40:47,040 --> 00:40:50,070

838
00:40:50,070 --> 00:40:52,580
For-- 우리가 갈거야
내가 0 일에서 시작합니다.

839
00:40:52,580 --> 00:40:54,760
우리는 1 N 마이너스까지 갈 것입니다.

840
00:40:54,760 --> 00:40:58,040
의 확인하자, 우리는 그 권리가 있었나요?

841
00:40:58,040 --> 00:40:59,580
네, 맞아요했다.

842
00:40:59,580 --> 00:41:02,080
>> 그래서 여기에 내부에, 우리는있어
최소값을 만들려고

843
00:41:02,080 --> 00:41:03,630
그리고 난에 그와 동일하게 설정.

844
00:41:03,630 --> 00:41:04,950
우리는 그렇게 했습니까?

845
00:41:04,950 --> 00:41:06,270
그래, 그했다.

846
00:41:06,270 --> 00:41:10,430
지금 우리의 내면에 대한 루프에서, 우리는있어
J 할 거하면 내가 n을 뺀 1과 같다.

847
00:41:10,430 --> 00:41:11,950
우리는 그렇게 했습니까?

848
00:41:11,950 --> 00:41:15,540
사실, 우리는 그것을했다.

849
00:41:15,540 --> 00:41:19,922
>> 그래서 그러나, 우리는 여기에 무엇을 비교하는거야?

850
00:41:19,922 --> 00:41:20,925
>> 청중 : J 플러스 1.

851
00:41:20,925 --> 00:41:21,716
ANDI 펭 : 맞아요.

852
00:41:21,716 --> 00:41:24,184

853
00:41:24,184 --> 00:41:27,350
그리고 당신은 설정하려는거야
J 플러스 1뿐만 아니라 동일한 최소.

854
00:41:27,350 --> 00:41:31,057

855
00:41:31,057 --> 00:41:32,640
그래서 정말 신속하게 높아졌습니다.

856
00:41:32,640 --> 00:41:36,190
너희들은 이해합니까
왜 J 플러스 1입니까?

857
00:41:36,190 --> 00:41:36,890
그래.

858
00:41:36,890 --> 00:41:40,700
>> 당신의 배열에 따라서
를 통해 첫 번째 패스,

859
00:41:40,700 --> 00:41:44,850
루프 용, 인터넷 용
내가 0에 해당,의를 바로 보자

860
00:41:44,850 --> 00:41:46,740
이 아직 변경되지 않은 가정합니다.

861
00:41:46,740 --> 00:41:53,180

862
00:41:53,180 --> 00:41:56,760
우리는 완전히의 배열을 가지고,
다만 4 정렬되지 않은 요소, 오른쪽?

863
00:41:56,760 --> 00:42:00,760
그래서 우리는 i가 0이 초기화 할 수 있습니다.

864
00:42:00,760 --> 00:42:03,650
그리고 난 것입니다 만
이 루프를 통해 실행합니다.

865
00:42:03,650 --> 00:42:08,560
그래서 첫 번째 패스에서, 우리는거야
"분"라는 변수를 초기화

866
00:42:08,560 --> 00:42:11,245
그 또한 있기 때문에, 나는 동일
우리는 최소의 값을 가질 수 없다.

867
00:42:11,245 --> 00:42:12,870
그래서뿐만 아니라 0으로 현재와 동일합니다.

868
00:42:12,870 --> 00:42:16,182

869
00:42:16,182 --> 00:42:17,640
그리고 우리는 통과 될 것입니다.

870
00:42:17,640 --> 00:42:19,270
그리고 우리는 다시 반복합니다.

871
00:42:19,270 --> 00:42:22,900
이제 우리는 발견 한 것이 무엇을 우리의 최소
우리는을 통해 반복 할이다

872
00:42:22,900 --> 00:42:25,190
그것을 비교하는 거라면 다시 오른쪽 볼?

873
00:42:25,190 --> 00:42:40,440
그래서 J, 여기, 것입니다
동일한 난에 0이다.

874
00:42:40,440 --> 00:42:46,320
그리고 만약 배열 J 플러스 I, 어떤
이하로, 다음 끝났어 하나는

875
00:42:46,320 --> 00:42:49,270
무엇 현재 최소값보다
값은 교환 할 것이다.

876
00:42:49,270 --> 00:42:56,850
>> 그래서 그냥 우리가했습니다 말을하자
2, 5, 1, 8, 마찬가지로 얻었다.

877
00:42:56,850 --> 00:43:01,610
지금, 난과 동일
0 j는 0과 동일하다.

878
00:43:01,610 --> 00:43:05,210
그리고 그것은 우리의 최소값입니다.

879
00:43:05,210 --> 00:43:09,950
배열-J의 경우 플러스 난 - 하나 그렇다면
그것은 우리가보고있는 한 후입니다

880
00:43:09,950 --> 00:43:13,450
그것은 이전보다 크다
이 최소가 될 것입니다.

881
00:43:13,450 --> 00:43:18,120
>> 그래서 여기에 우리가 5 볼
그 이상이다.

882
00:43:18,120 --> 00:43:19,730
그래서 5를하지 않을거야.

883
00:43:19,730 --> 00:43:23,580
우리는 1, 오른쪽 미만임을 알?

884
00:43:23,580 --> 00:43:32,970
그래서 지금 우리는 우리의 최소 것을 알고
0, 1, 2의 인덱스 값이 될 것.

885
00:43:32,970 --> 00:43:34,030
그래?

886
00:43:34,030 --> 00:43:39,170
그리고 당신은 여기 내려 할 때
올바른 값을 바꿀 수 있습니다.

887
00:43:39,170 --> 00:43:42,610
>> 그래서 너희들은 J를 가진 때
전에, 당신은 하나보고되지 않았다

888
00:43:42,610 --> 00:43:43,260
그 후.

889
00:43:43,260 --> 00:43:44,520
당신은보고 있었다
동일한 값, 어느

890
00:43:44,520 --> 00:43:46,290
그냥 아무것도되지 않은 이유입니다.

891
00:43:46,290 --> 00:43:49,721
즉 모든 사람에게 의미가 있는가,
왜 우리는 플러스가 1이 필요?

892
00:43:49,721 --> 00:43:50,220
그래.

893
00:43:50,220 --> 00:43:53,345
지금은 확인을 통해 그냥 실행하자
확인 코드의 나머지 부분은 올바른 것입니다.

894
00:43:53,345 --> 00:44:04,424

895
00:44:04,424 --> 00:44:05,340
그 이유는 일이?

896
00:44:05,340 --> 00:44:14,780

897
00:44:14,780 --> 00:44:16,364
아, 그것은 바로 여기 분입니다.

898
00:44:16,364 --> 00:44:17,780
우리는 잘못된 값을 비교 하​​였다.

899
00:44:17,780 --> 00:44:24,944

900
00:44:24,944 --> 00:44:25,906
오.

901
00:44:25,906 --> 00:44:30,720

902
00:44:30,720 --> 00:44:33,482
>> 오, 그래, 여기까지 우리는 있었다
뿐만 아니라 잘못된 값을 교환.

903
00:44:33,482 --> 00:44:34,940
우리는 i와 j보고 있었다 때문에.

904
00:44:34,940 --> 00:44:36,440
사람들은 우리가 확인 된 것들입니다.

905
00:44:36,440 --> 00:44:39,160
우리는 실제로 교체 할
최소한, 현재 최소

906
00:44:39,160 --> 00:44:40,550
무엇 이건 하나 밖에이다.

907
00:44:40,550 --> 00:44:59,510

908
00:44:59,510 --> 00:45:05,402
그리고 너희들은 아래로 볼 수있다
여기에, 우리는 정렬 된 배열을 가지고있다.

909
00:45:05,402 --> 00:45:07,110
그냥 함께 할 수 있었다
사실 때

910
00:45:07,110 --> 00:45:09,350
우리를 검사했다
우리가 비교 한 값으로,

911
00:45:09,350 --> 00:45:11,226
우리는 오른쪽 값을보고하지 않았다.

912
00:45:11,226 --> 00:45:13,850
우리는 같은 일을보고 있었다
여기에, 실제로 그것을 교환하지.

913
00:45:13,850 --> 00:45:17,135
당신은 다음 중 하나를보고있다
그와 당신은 교체 할 수 있습니다.

914
00:45:17,135 --> 00:45:19,260
그래서 가지 뭔지
전에 우리의 코드를 도청.

915
00:45:19,260 --> 00:45:22,460
그리고 제가 여기에 한 일은 모든입니다
디버거가 당신을 위해 할 수 있었다

916
00:45:22,460 --> 00:45:23,810
난 그냥 그것을했다
보드, 그것은 쉽게 때문에

917
00:45:23,810 --> 00:45:26,320
노력보다는 볼
디버거를 확대합니다.

918
00:45:26,320 --> 00:45:29,391
그 모두에게 의미가 있습니까?

919
00:45:29,391 --> 00:45:29,890
쿨.

920
00:45:29,890 --> 00:45:34,800

921
00:45:34,800 --> 00:45:35,410
>> 괜찮아.

922
00:45:35,410 --> 00:45:41,070
우리는 이야기에 이동할 수 있습니다
점근 표기법, 어떤

923
00:45:41,070 --> 00:45:44,580
말의 단지 멋진 방법입니다
이러한 종류의 모든 런타임.

924
00:45:44,580 --> 00:45:47,650
그래서 강의에서 다윗을 알고,
런타임에 만졌다.

925
00:45:47,650 --> 00:45:52,124
그리고 그는 전체 식을 통해 갔다
의 런타임을 계산하는 방법에 대해 설명합니다.

926
00:45:52,124 --> 00:45:53,040
그것에 대해 걱정하지 않습니다.

927
00:45:53,040 --> 00:45:54,660
당신이 정말로 궁금하다면
그 작동 방법에 대한,

928
00:45:54,660 --> 00:45:55,810
섹션 후 나에게 이야기 주시기 바랍니다.

929
00:45:55,810 --> 00:45:57,560
우리는을 통해 걸을 수
함께 공식.

930
00:45:57,560 --> 00:46:00,689
그러나 모든 너희들은 정말로를해야
알고는 n이 2 이상 제곱이다

931
00:46:00,689 --> 00:46:01,980
n은 제곱 같은 일이다.

932
00:46:01,980 --> 00:46:04,710
가장 큰 수 있기 때문에,
지수는 가장 성장.

933
00:46:04,710 --> 00:46:06,590
그래서 우리의 목적을 위해,
우리가 걱정하는 모든

934
00:46:06,590 --> 00:46:09,470
성장하고 그 거대한 숫자입니다.

935
00:46:09,470 --> 00:46:13,340
>> 그래서 가장 좋은 경우입니다
선택 정렬의 런타임?

936
00:46:13,340 --> 00:46:15,830
당신은 할 거라면
목록을 반복합니다

937
00:46:15,830 --> 00:46:18,712
다음을 통해 반복
이 목록의 나머지 부분,

938
00:46:18,712 --> 00:46:20,420
얼마나 많은 시간이다
당신은 아마로 이동

939
00:46:20,420 --> 00:46:24,612
최악의 case--에
경우 가장 통해 실행 sorry--?

940
00:46:24,612 --> 00:46:27,070
어쩌면 더 나은 질문은
묻고, 최악의 경우 무엇

941
00:46:27,070 --> 00:46:28,153
선택 정렬의 런타임.

942
00:46:28,153 --> 00:46:29,366
청중 : N 제곱.

943
00:46:29,366 --> 00:46:30,740
ANDI 펭 : 그것은 N 오른쪽 제곱입니다.

944
00:46:30,740 --> 00:46:36,986
이처럼 너무 쉽게 생각하는,
당신은 루프 중첩 된 두가 언제,

945
00:46:36,986 --> 00:46:38,110
그것은 N 제곱 될 것입니다.

946
00:46:38,110 --> 00:46:40,386
당신입니다뿐만 아니라 때문에
다시 한번 통해 실행,

947
00:46:40,386 --> 00:46:42,260
당신은 돌아 가야
주위와 그것을 통해 실행

948
00:46:42,260 --> 00:46:44,980
다시 한 번 모든 값에 대한 내부.

949
00:46:44,980 --> 00:46:48,640
이 경우에 따라서, 당신은 N을 실행하는
배 N, 미안 is--하는 제곱

950
00:46:48,640 --> 00:46:50,505
n 번 N, N- 제곱 같아지는.

951
00:46:50,505 --> 00:46:53,230

952
00:46:53,230 --> 00:46:56,360
>> 그리고 종류도 조금입니다
의미에서 독특한

953
00:46:56,360 --> 00:46:59,774
이들 경우 문제가되지 않습니다
값은 순서대로 이미.

954
00:46:59,774 --> 00:47:01,440
아직 어쨌든 통해 실행하는 것입니다.

955
00:47:01,440 --> 00:47:03,872
그냥이 1, 2, 3, 4이었다 가정 해 봅시다.

956
00:47:03,872 --> 00:47:07,080
관계없이으로되었는지 여부의
순서, 그것은 여전히​​ 통해 실행했을 것이다

957
00:47:07,080 --> 00:47:08,620
여전히 최소 값을 조사했다.

958
00:47:08,620 --> 00:47:10,100
그것은 만들었을 것입니다
수표 동일한 개수

959
00:47:10,100 --> 00:47:12,780
매 시간, 심지어 경우
실제로 아무것도 만지지 않았다.

960
00:47:12,780 --> 00:47:16,940
>> 이러한 경우에 따라서, 가장 최악
런타임은 실제로 동일합니다.

961
00:47:16,940 --> 00:47:19,160
그래서 예상 런타임
선택 정렬,

962
00:47:19,160 --> 00:47:23,790
이는 우리가 기호로 지정
세타, 쎄타,이 경우,

963
00:47:23,790 --> 00:47:24,790
또한 N 제곱 될 것이다.

964
00:47:24,790 --> 00:47:26,480
이 세 가지 모두는 N 제곱 될 것이다.

965
00:47:26,480 --> 00:47:29,653
왜 모든 사람이 분명하다
런타임은 N 제곱?

966
00:47:29,653 --> 00:47:33,360

967
00:47:33,360 --> 00:47:33,980
>> 괜찮아.

968
00:47:33,980 --> 00:47:39,120
그래서 난 그냥 빨리 실행하는거야
종류의 나머지 부분을 통해.

969
00:47:39,120 --> 00:47:41,137
위한 알고리즘
거품, 기억 sort--

970
00:47:41,137 --> 00:47:43,220
이것은 제였다
다윗은 강의에 갔다.

971
00:47:43,220 --> 00:47:46,000
기본적으로, 당신은 단계
전체 목록을

972
00:47:46,000 --> 00:47:48,950
당신은 당신을 swap--
한 번에 두 가지를 비교합니다.

973
00:47:48,950 --> 00:47:51,350
그리고 하나 더 있다면
당신보다 그냥 교환합니다.

974
00:47:51,350 --> 00:47:53,590
이러한 큰 경우에 따라서, 당신은 교환 것이다.

975
00:47:53,590 --> 00:47:56,180
나는 바로 여기에 공식있어.

976
00:47:56,180 --> 00:47:59,100
>> 그럼 당신이 8, 6, 4, 2를 가지고 가정 해 봅시다.

977
00:47:59,100 --> 00:48:00,571
당신은 8과 6 비교 것입니다.

978
00:48:00,571 --> 00:48:01,570
당신은 그 (것)를 교환 할 필요가 것입니다.

979
00:48:01,570 --> 00:48:02,610
당신은 8, 4 비교 것이다.

980
00:48:02,610 --> 00:48:03,609
당신은 그 (것)를 교환 할 필요가 것입니다.

981
00:48:03,609 --> 00:48:07,000
당신이 (8)을 교체해야하는 경우와
2뿐만 아니라 변경합니다.

982
00:48:07,000 --> 00:48:10,760
그런 의미에서 그래서, 당신은 볼 수 있습니다
장기간에 걸쳐 펼쳐,

983
00:48:10,760 --> 00:48:13,730
어떻게 거품의 값의 종류
이다 끝, 우리는 그것을 왜 전화

984
00:48:13,730 --> 00:48:15,320
거품 정렬.

985
00:48:15,320 --> 00:48:19,950
>> 우리는 다시 통해 실행됩니다
우리의 두 번째 패스, 그리고 세 번째 패스,

986
00:48:19,950 --> 00:48:21,150
우리의 네 번째.

987
00:48:21,150 --> 00:48:25,820
기본적으로, 버블 정렬 바로 실행
당신은 더 이상 스왑을하지 않습니다 때까지.

988
00:48:25,820 --> 00:48:31,109
그런 의미에서 그래서, 이것은 단지입니다
그것의 일반 의사.

989
00:48:31,109 --> 00:48:32,650
걱정은,이 모든 온라인 수 없습니다.

990
00:48:32,650 --> 00:48:34,990
우리는 실제로이 이상 갈 필요가 없습니다.

991
00:48:34,990 --> 00:48:38,134
>> 우리는 단지 카운터를 초기화
0에서 시작 변수입니다.

992
00:48:38,134 --> 00:48:39,800
그리고 우리는 전체 배열을 통해 반복.

993
00:48:39,800 --> 00:48:43,420
그리고 하나의 값이있는 경우가 말한 데로라면
값은, 그 값보다 크면

994
00:48:43,420 --> 00:48:44,610
당신이 그들을 바꿀 것입니다.

995
00:48:44,610 --> 00:48:46,860
그리고 당신은있어
계속 것.

996
00:48:46,860 --> 00:48:47,970
그리고 당신은 계산하는 것입니다.

997
00:48:47,970 --> 00:48:50,845
그리고 당신은 일을 계속하는거야
이 카운터는 큰 반면

998
00:48:50,845 --> 00:48:53,345
것을 의미한다 0보다
때마다 당신은 교체해야

999
00:48:53,345 --> 00:48:55,220
당신은 당신이 가고 싶은 알고
다시 다시 확인합니다.

1000
00:48:55,220 --> 00:48:59,510
당신은 당신이 알고있을 때까지 검사를 계속하려면
것을 더 이상 교체 할 필요가 없습니다.

1001
00:48:59,510 --> 00:49:05,570
>> 그래서 최고와 최악의 무엇입니까
경우 거품 정렬을 위해 런타임은?

1002
00:49:05,570 --> 00:49:09,300
그리고 hint--이 실제로 다른
의미에서 선택 정렬에서

1003
00:49:09,300 --> 00:49:11,810
이 두 가지 답변은 동일하지 않습니다 것을.

1004
00:49:11,810 --> 00:49:14,709
에 무슨 일이 일어날 지 생각 해봐
경우 그것은 이미 정렬 된 경우.

1005
00:49:14,709 --> 00:49:16,500
그리고 어떻게 생각하는지
그것이 경우에 일어날 것

1006
00:49:16,500 --> 00:49:18,372
경우에 어떤에서 정렬되지 않았습니다.

1007
00:49:18,372 --> 00:49:20,580
그리고 당신은 가지 실행할 수 있습니다
이유를 통해 그 무슨 일이 일어나고.

1008
00:49:20,580 --> 00:49:22,954
나는, 30 등, 너희들을 줄 것이다
초 그것에 대해 생각합니다.

1009
00:49:22,954 --> 00:49:52,330

1010
00:49:52,330 --> 00:49:53,540
>> 그래.

1011
00:49:53,540 --> 00:49:57,462
사람이 무엇에 추측이 있습니까
버블 정렬의 최악의 경우 런타임은?

1012
00:49:57,462 --> 00:49:57,962
그래.

1013
00:49:57,962 --> 00:50:07,810
>> 청중 : 그것은, 같은, n 번 것
N 마이너스 같은 1 또는 뭔가?

1014
00:50:07,810 --> 00:50:10,650
마찬가지로,이 실행될 때마다,
그것은 하나의 스왑 이하, 같은 단지

1015
00:50:10,650 --> 00:50:10,960
무엇 이건 그것은이었다.

1016
00:50:10,960 --> 00:50:12,668
>> ANDI 펭 : 네, 그래서
당신은 완전히 맞아.

1017
00:50:12,668 --> 00:50:15,940
그리고이있는 경우 귀하
대답은 실제로 더 복잡

1018
00:50:15,940 --> 00:50:17,240
하나보다 우리가 제공 할 필요가있다.

1019
00:50:17,240 --> 00:50:19,772
그래서 난 run-- 것
여기에 모든이를 지울 것.

1020
00:50:19,772 --> 00:50:20,480
모두가 좋은가요?

1021
00:50:20,480 --> 00:50:21,869
나는이를 지울 수 있습니까?

1022
00:50:21,869 --> 00:50:22,368
그래.

1023
00:50:22,368 --> 00:50:27,904

1024
00:50:27,904 --> 00:50:30,320
당신은 N을 통해 실행하는거야
시간이 처음으로, 오른쪽?

1025
00:50:30,320 --> 00:50:33,200
그리고 그들은을 통해 실행하는거야
N 마이너스 1 번째, 오른쪽?

1026
00:50:33,200 --> 00:50:37,130
그리고 당신은 유지하는거야
n 개의 광산 2, 등등, 가고.

1027
00:50:37,130 --> 00:50:40,210
다윗은 어디 강의에서 이런 짓을,
당신은 모든 값을 추가 한 경우,

1028
00:50:40,210 --> 00:50:48,080
당신이 뭔가를 얻을 그때 엔 yeah--
본질적으로 감소 2, 이상

1029
00:50:48,080 --> 00:50:49,784
N까지 제곱.

1030
00:50:49,784 --> 00:50:51,700
당신은을받을거야
거기에 이상한 부분.

1031
00:50:51,700 --> 00:50:53,892
그래서 그냥 알고
N은 항상 제곱

1032
00:50:53,892 --> 00:50:55,350
분수보다 우선합니다.

1033
00:50:55,350 --> 00:50:58,450
그리고이 경우, 최악
런타임은 N 제곱 될 것이다.

1034
00:50:58,450 --> 00:51:00,210
그것은 내림차순에있는 경우
순서는, 당신,를 생각

1035
00:51:00,210 --> 00:51:02,530
스왑 매번 확인해야합니다.

1036
00:51:02,530 --> 00:51:05,170
>> 잠재적으로 무엇을 할 것입니다,
최상의 경우 런타임?

1037
00:51:05,170 --> 00:51:08,580
목록이 이미 있다면, 그냥 가정 해 봅시다
위해, 런타임은 어떤 것입니까?

1038
00:51:08,580 --> 00:51:09,565
>> 청중 : N.

1039
00:51:09,565 --> 00:51:10,690
ANDI 펭 : 그것은 정확히, N이다.

1040
00:51:10,690 --> 00:51:11,600
그리고 왜 n은?

1041
00:51:11,600 --> 00:51:13,850
청중 : 당신 때문에 단지
각 한 번 확인해야합니다.

1042
00:51:13,850 --> 00:51:14,770
ANDI 펭 : 맞아요.

1043
00:51:14,770 --> 00:51:17,150
, 최적의 런타임 그래서
이 목록은 이미있는 경우

1044
00:51:17,150 --> 00:51:20,270
sorted--,의 1, 2, 3을 가정 해 봅시다 4-- 당신은
단지를 통해 갈 것입니다, 당신은 확인 것

1045
00:51:20,270 --> 00:51:21,720
당신은 오, 그들은 모두 밖으로 팬, 볼 것입니다.

1046
00:51:21,720 --> 00:51:22,636
나는 교환 할 필요가 없었다.

1047
00:51:22,636 --> 00:51:23,370
나는 끝났어요.

1048
00:51:23,370 --> 00:51:26,500
그래서 이러한 경우에, 단지 N있어
또는 단계의 수 방금

1049
00:51:26,500 --> 00:51:29,870
첫 번째 목록에서 확인했다.

1050
00:51:29,870 --> 00:51:33,990
>> 그리고 후에, 우리는 지금 히트
삽입 정렬,

1051
00:51:33,990 --> 00:51:39,260
알고리즘은 분할에 본질적으로
그것은 정렬 및 정렬되지 않은 부분에.

1052
00:51:39,260 --> 00:51:42,810
그리고 하나 하나,
정렬되지 않은 값은

1053
00:51:42,810 --> 00:51:46,880
자신의 적절한 삽입
목록의 시작 부분에 위치.

1054
00:51:46,880 --> 00:51:52,120
>> 그래서 예를 들어, 우리는이
목록 3, 5, 2, 6, 4 다시.

1055
00:51:52,120 --> 00:51:54,750
우리는 현재의 알고
정렬되지 않은 우리가했기 때문에

1056
00:51:54,750 --> 00:51:57,030
그것을보고 시작했다.

1057
00:51:57,030 --> 00:52:00,610
우리가 살펴보고 우리가 알고
첫 번째 값은 오른쪽 정렬?

1058
00:52:00,610 --> 00:52:04,190
당신은 단지의 배열을보고하는 경우
크기 하나는, 당신은 그것을 정렬 있다는 것을 알고있다.

1059
00:52:04,190 --> 00:52:08,230
>> 그래서 우리는 알고
다른 네 가지 분류되지 않은 있습니다.

1060
00:52:08,230 --> 00:52:10,980
우리는 통과하고 우리는 그 값을 참조하십시오.

1061
00:52:10,980 --> 00:52:11,730
의 돌아 가자.

1062
00:52:11,730 --> 00:52:13,130
(5)의 값을 참조하십시오?

1063
00:52:13,130 --> 00:52:14,110
우리는 좀 봐.

1064
00:52:14,110 --> 00:52:15,204
우리는 3과 비교.

1065
00:52:15,204 --> 00:52:17,870
우리는보다 큰 것을 알고있어
3, 그래서 우리는 그 정렬 있다는 것을 알고있다.

1066
00:52:17,870 --> 00:52:22,940
그래서 우리가 지금 알고 처음 두
정렬 마지막 세 아니다.

1067
00:52:22,940 --> 00:52:24,270
>> 우리는 2를보십시오.

1068
00:52:24,270 --> 00:52:25,720
우리는 먼저 5를 확인합니다.

1069
00:52:25,720 --> 00:52:26,700
이 5보다 작은가요?

1070
00:52:26,700 --> 00:52:27,240
그것은 아니다.

1071
00:52:27,240 --> 00:52:29,510
그래서 우리는 아래로 계속 찾고 있습니다.

1072
00:52:29,510 --> 00:52:30,940
그런 다음 3 떨어져 2를 확인합니다.

1073
00:52:30,940 --> 00:52:31,850
그것은 이하인가?

1074
00:52:31,850 --> 00:52:32,350
아니.

1075
00:52:32,350 --> 00:52:35,430
그래서 2가 삽입되어야한다 알고
전면에, 3 및 5

1076
00:52:35,430 --> 00:52:38,200
모두 밀어해야합니다.

1077
00:52:38,200 --> 00:52:42,190
6 4 다시이 작업을 수행합니다.

1078
00:52:42,190 --> 00:52:48,962
그리고 우리는, 본질적으로 계속 확인
우리가 확인하는 경우, 확인 확인합니다.

1079
00:52:48,962 --> 00:52:51,170
그리고 오른쪽에 때까지
위치, 우리 종류의 단지

1080
00:52:51,170 --> 00:52:54,890
올바른 위치에 삽입,
이는 그것의 이름이 어디​​에서 온 것입니다.

1081
00:52:54,890 --> 00:52:59,830
>> 그래서 그냥 알고리즘이다,
의사 자체, 가지,

1082
00:52:59,830 --> 00:53:04,990
우리가 구현하는 방법에
삽입 정렬.

1083
00:53:04,990 --> 00:53:05,954
의사 코드는 여기에있다.

1084
00:53:05,954 --> 00:53:06,620
그것은 모든 온라인입니다.

1085
00:53:06,620 --> 00:53:10,720
걱정하지 너희들이있는 경우
이 아래로 복사하려고합니다.

1086
00:53:10,720 --> 00:53:14,500
그래서 다시 한 번, 같은 question-- 무엇
최고와 최악의 런타임을 것

1087
00:53:14,500 --> 00:53:16,120
삽입 정렬을 검색 하시나요?

1088
00:53:16,120 --> 00:53:17,750
그것은 마지막 질문에 매우 유사하다.

1089
00:53:17,750 --> 00:53:20,479
나는, 30 등, 너희들을 줄 것이다
초뿐만 아니라 이것에 대해 생각합니다.

1090
00:53:20,479 --> 00:53:47,150

1091
00:53:47,150 --> 00:53:50,071
>> 사람이 원하는 않습니다 확인
나에게 최악의 런타임을 제공?

1092
00:53:50,071 --> 00:53:50,570
그래.

1093
00:53:50,570 --> 00:53:51,490
>> 청중 : N 제곱.

1094
00:53:51,490 --> 00:53:52,573
>> ANDI 펭 : 그것은 N 제곱입니다.

1095
00:53:52,573 --> 00:53:53,730
그리고 왜 N 제곱?

1096
00:53:53,730 --> 00:53:57,562
>> 청중 :에 있기 때문에
역순으로, 당신은

1097
00:53:57,562 --> 00:54:02,619
is--하는 N 배 통과 n으로

1098
00:54:02,619 --> 00:54:03,660
ANDI 펭 : 네, 정확히.

1099
00:54:03,660 --> 00:54:06,610
거품 분류 그래서 같은 일.

1100
00:54:06,610 --> 00:54:08,720
이 목록에있는 경우
내림차순, 당신이있어

1101
00:54:08,720 --> 00:54:11,240
먼저 번을 확인해야 할 것.

1102
00:54:11,240 --> 00:54:13,470
그리고 그와 함께 모든
부가 가치, 당신이있어

1103
00:54:13,470 --> 00:54:16,390
가지고가는에 대해 그것을 확인
바로 모든 단일 값?

1104
00:54:16,390 --> 00:54:20,290
그리고 모두, 당신은 할거야
N 통과 시간은 또 다른 N, 통과하는

1105
00:54:20,290 --> 00:54:21,750
N 제곱된다.

1106
00:54:21,750 --> 00:54:22,860
무엇 최상의 경우는 어떻습니까?

1107
00:54:22,860 --> 00:54:24,360
그래.

1108
00:54:24,360 --> 00:54:28,840
>> 청중 : N 마이너스 1, 때문에
첫 번째는 이미 제곱된다.

1109
00:54:28,840 --> 00:54:30,270
>> ANDI 펭 : 그래서, 부근에 있습니다.

1110
00:54:30,270 --> 00:54:31,850
대답은 실제로 N이다.

1111
00:54:31,850 --> 00:54:37,189
첫 번째 인 반면 때문에
분류, 그것을 ... 사실상하지 않을 수 있습니다

1112
00:54:37,189 --> 00:54:38,980
우리는 단지에, 밖으로 운도
그 예를 들어, 그 2

1113
00:54:38,980 --> 00:54:40,930
가장 작은 숫자로 일어났다.

1114
00:54:40,930 --> 00:54:43,680
그러나 항상 그런 것은 없습니다.

1115
00:54:43,680 --> 00:54:48,040
(2)는 이미 시작으로 정렬되어있는 경우
하지만,보고 여기에 1 거기

1116
00:54:48,040 --> 00:54:49,144
1은 범프 것입니다.

1117
00:54:49,144 --> 00:54:51,060
그리고 그것은 끝 것
최대 어쨌든 충돌된다.

1118
00:54:51,060 --> 00:54:56,250
>> 최선의 시나리오에 따라서
실제로 단지 N 될 것.

1119
00:54:56,250 --> 00:54:59,090
아래와 같은 경우 1, 2, 3,
4, 5, 6, 7, 8에는있어

1120
00:54:59,090 --> 00:55:00,940
를 통해 실행하는 것
그 전체 목록을 한 번

1121
00:55:00,940 --> 00:55:03,430
모든 게 잘 있는지 확인합니다.

1122
00:55:03,430 --> 00:55:07,390
실행중인 모든 사람이 분명하다
뿐만 아니라 선택의 시간?

1123
00:55:07,390 --> 00:55:09,960
내가 통해 갈거야 알고
이 정말 빨리.

1124
00:55:09,960 --> 00:55:13,330
그러나 당신이 알고있는 경우 알고
일반적인 개념은, 당신이 잘되어야합니다.

1125
00:55:13,330 --> 00:55:16,070
그래.

1126
00:55:16,070 --> 00:55:19,790
그래서 난 그냥 같은, 어쩌면 너희들을 줄 것이다,
분은 이웃에게 이야기하기

1127
00:55:19,790 --> 00:55:21,890
무엇 단지 일부에
주요 차이점

1128
00:55:21,890 --> 00:55:23,540
종류의 이러한 종류의 사이.

1129
00:55:23,540 --> 00:56:24,571

1130
00:56:24,571 --> 00:56:25,570
우리는 곧 갈 거예요.

1131
00:56:25,570 --> 00:56:26,444
청중 : OK, 오.

1132
00:56:26,444 --> 00:56:27,320
ANDI 펭 : 네.

1133
00:56:27,320 --> 00:56:28,380
그래.

1134
00:56:28,380 --> 00:56:33,420
쿨,의 클래스로 재 소집 할 수 있습니다.

1135
00:56:33,420 --> 00:56:34,330
그래.

1136
00:56:34,330 --> 00:56:37,579
그래서이이었다 종류의
의미에서 개방형 질문

1137
00:56:37,579 --> 00:56:39,120
그들에 대한 답변을 많이가있다.

1138
00:56:39,120 --> 00:56:40,746
그리고 우리는 잠시 그​​ 중 일부를 통해 이동합니다.

1139
00:56:40,746 --> 00:56:43,411
난 그냥 너희들을 얻고 싶었다
차별화 된 무엇에 대해 생각

1140
00:56:43,411 --> 00:56:44,530
세 종류의 타입.

1141
00:56:44,530 --> 00:56:47,440
그리고, 또한, 훌륭한 들었다
무엇을 일종의 병합 않습니다 question--?

1142
00:56:47,440 --> 00:56:50,110
좋은 질문, 그 때문에
우리는 다음 취재하고 있습니다.

1143
00:56:50,110 --> 00:56:52,850
>> 그래서 종류입니다 병합
그 기능을 하나의 종류

1144
00:56:52,850 --> 00:56:56,100
매우 다르게 다른 종류에서.

1145
00:56:56,100 --> 00:56:58,180
너희들은 see-- 수 있듯이
다윗은 그 데모를 짓

1146
00:56:58,180 --> 00:57:01,130
그는 모든 멋진 있었다 곳
병합 방법 보는 소리

1147
00:57:01,130 --> 00:57:04,010
일종의 무한 같은, 실행
다른 두 유형보다 빠르게?

1148
00:57:04,010 --> 00:57:04,510
그래.

1149
00:57:04,510 --> 00:57:07,580
그래서 병합 때문이다
일종의 그 격차를 구현

1150
00:57:07,580 --> 00:57:11,020
우리가했습니다 개념을 정복
강의에 많은 이야기.

1151
00:57:11,020 --> 00:57:14,550
우리가 일을하고 싶은 그런 의미에서
똑똑, 당신은 분할 할 때, 열심히

1152
00:57:14,550 --> 00:57:18,120
문제를 정복하고 휴식
다운 한 후, 이들을 함께 넣어

1153
00:57:18,120 --> 00:57:19,930
좋은 일이 항상 일어난다.

1154
00:57:19,930 --> 00:57:21,960
>> 병합하는 방식 그래서
종류 본질적으로 작동

1155
00:57:21,960 --> 00:57:24,660
이 분할이다
반에서 정렬되지 않은 배열입니다.

1156
00:57:24,660 --> 00:57:26,500
그리고 그것은 배열의 두 반쪽을 가지고있다.

1157
00:57:26,500 --> 00:57:28,220
그리고 그것은 단지 그 두 부분을 정렬합니다.

1158
00:57:28,220 --> 00:57:31,750
그것은 단지에서 반으로 나누어 유지
절반, 절반으로 모든 것이 분류 할 때까지

1159
00:57:31,750 --> 00:57:33,680
다음 재귀
모두 함께 넣습니다.

1160
00:57:33,680 --> 00:57:36,550
>> 그래서 정말 추상적이다.

1161
00:57:36,550 --> 00:57:38,750
그래서 이것은 의사의 조금이다.

1162
00:57:38,750 --> 00:57:41,040
그에서 의미가 있습니까
그것이 실행의 방법은?

1163
00:57:41,040 --> 00:57:43,870
그래서 당신이이 말을하자
n 개의 요소의 배열, 오른쪽?

1164
00:57:43,870 --> 00:57:45,450
n이 2보다 작은 경우, 당신은 반환 할 수 있습니다.

1165
00:57:45,450 --> 00:57:49,040
당신이 알고 있기 때문이 있다면
단 한 가지, 그것은 분류해야합니다.

1166
00:57:49,040 --> 00:57:52,600
그 밖에, 당신은 왼쪽 절반을 정렬
다음은 오른쪽 절반을 정렬

1167
00:57:52,600 --> 00:57:54,140
그리고 당신은 병합합니다.

1168
00:57:54,140 --> 00:57:56,979
>> 그 정말 쉽게 보이지만 그래서,
현실에서, 그것에 대해 생각하는 것은이다

1169
00:57:56,979 --> 00:58:00,270
어려운 가지. 당신이 좋아하는 것 때문에,
물론, 그 종류의 자체에서 실행합니다.

1170
00:58:00,270 --> 00:58:00,769
권리?

1171
00:58:00,769 --> 00:58:02,430
그것은 그 자체에서 실행합니다.

1172
00:58:02,430 --> 00:58:05,479
그래서 그런 의미에서, 다윗은 감동
클래스의 재귀시.

1173
00:58:05,479 --> 00:58:07,270
그리고 그 개념의
우리는 더 많은 얘기하자.

1174
00:58:07,270 --> 00:58:11,430
그것은이 그 다음 두 라인의
여기에, 실제로 단지 프로그램입니다

1175
00:58:11,430 --> 00:58:13,860
그것을 말하는 것은 자신을 실행
다른 입력과 함께.

1176
00:58:13,860 --> 00:58:17,230
오히려 자신을 실행보다
N 엘리먼트의 전체가,

1177
00:58:17,230 --> 00:58:20,530
당신은에 그것을 파괴 할 수 있습니다
좌측 절반과 우측 절반

1178
00:58:20,530 --> 00:58:22,680
다음 다시 실행하십시오.

1179
00:58:22,680 --> 00:58:26,050
>> 그리고 우리는 시각적으로 볼 것이다
나는 시각적 학습자이기 때문에.

1180
00:58:26,050 --> 00:58:27,270
그것은 나를 위해 잘 작동.

1181
00:58:27,270 --> 00:58:29,890
그래서 우리는 여기에 시각적 인 예를 살펴 보겠습니다.

1182
00:58:29,890 --> 00:58:36,237
>> 여섯의 우리가 배열이 있다고 가정 해 봅시다
요소, 3, 5, 2, 6, 4, 1, 정렬되지.

1183
00:58:36,237 --> 00:58:37,820
좋아,이 페이지에 많이있다.

1184
00:58:37,820 --> 00:58:43,179
너희들이 볼 수 있다면
여기에서 첫 번째 단계, 3, 5, 2, 6, 4, 1,

1185
00:58:43,179 --> 00:58:44,220
당신은 반으로 분할 할 수 있습니다.

1186
00:58:44,220 --> 00:58:45,976
사용자는 3, 5, 2, 6, 4, 1을 갖는다.

1187
00:58:45,976 --> 00:58:48,850
당신이 당신을 aren't-- 것을 알고있다
그들은 분류하거나하지 않는 경우 모르겠어요,

1188
00:58:48,850 --> 00:58:52,517
그래서 당신은 반으로 그들을 파괴 유지,
절반, 절반, 결국 때까지,

1189
00:58:52,517 --> 00:58:53,600
당신은 단지 하나의 요소가 있습니다.

1190
00:58:53,600 --> 00:58:56,790
그리고 하나의 요소는 항상 오른쪽 정렬?

1191
00:58:56,790 --> 00:59:01,560
>> 우리가 알고있는 3, 5, 2, 4, 6,
(1)는, 그 자체로 정렬됩니다.

1192
00:59:01,560 --> 00:59:05,870
그리고 지금 우리는 그들을 함께 다시 넣을 수 있습니다.

1193
00:59:05,870 --> 00:59:07,510
그래서 우리는 3, 5를 알고있다.

1194
00:59:07,510 --> 00:59:08,510
우리는 함께 그했습니다.

1195
00:59:08,510 --> 00:59:09,617
우리는이 정렬 알고.

1196
00:59:09,617 --> 00:59:10,450
여전히 2의.

1197
00:59:10,450 --> 00:59:11,830
우리는 함께 4와 6을 넣을 수 있습니다.

1198
00:59:11,830 --> 00:59:13,996
우리는 그 정렬 것 알고
그래서 우리는 함께 그했습니다.

1199
00:59:13,996 --> 00:59:14,940
그리고 1가있다.

1200
00:59:14,940 --> 00:59:18,720
>> 그리고 당신은 단지보고
여기이 두 반쪽.

1201
00:59:18,720 --> 00:59:21,300
사용자는 3, 5, 2, 2, 3, 5를 갖는다.

1202
00:59:21,300 --> 00:59:23,465
당신은 비교할 수 있습니다
모든 것의 시작.

1203
00:59:23,465 --> 00:59:26,340
이 정렬되는 것을 알고 있기 때문에
그리고 당신은 그 정렬 있다는 것을 알고있다.

1204
00:59:26,340 --> 00:59:29,360
그럼 당신은 필요 없어
(5)를 비교, 당신은 단지 3를 비교합니다.

1205
00:59:29,360 --> 00:59:32,070
그리고 2 그래서, 3 미만
당신은 2가 결국 가야 알고있다.

1206
00:59:32,070 --> 00:59:33,120
>> 저기 같은 것.

1207
00:59:33,120 --> 00:59:34,740
(1) 여기 가야한다.

1208
00:59:34,740 --> 00:59:37,330
당신이 갈 때 그리고 넣어
함께 두 값,

1209
00:59:37,330 --> 00:59:39,950
이 정렬되어 있는지 알고
당신은이 정렬됩니다 것을 알고있다.

1210
00:59:39,950 --> 00:59:43,240
그럼 1
도 2는,도 1은 2 개 미만이다.

1211
00:59:43,240 --> 00:59:45,570
즉, 1 수 있음을 알려줍니다
이것의 단부에 가야

1212
00:59:45,570 --> 00:59:47,480
도 3 또는 5 보지 않고.

1213
00:59:47,480 --> 00:59:50,100
그리고 4, 당신은 할 수 있습니다
그것은 여기에 바로 간다 확인합니다.

1214
00:59:50,100 --> 00:59:51,480
당신은 5에서 볼 필요가 없습니다.

1215
00:59:51,480 --> 00:59:52,570
(6)와 같은 것.

1216
00:59:52,570 --> 00:59:55,860
당신은 알고 6-- 그것은 단지를 그
보고 할 필요가 없습니다.

1217
00:59:55,860 --> 00:59:57,870
>> 그래서 그런 식으로, 당신은있어
단지 자신을 절약

1218
00:59:57,870 --> 00:59:59,526
많은 단계 당신은 비교 할 때.

1219
00:59:59,526 --> 01:00:02,150
당신은 모든 비교 할 필요가 없습니다
다른 요소에 대한 요소입니다.

1220
01:00:02,150 --> 01:00:05,230
당신은 그들에 대해 비교
당신에 대해 그것을 비교할 필요가있다.

1221
01:00:05,230 --> 01:00:06,870
그래서 추상적 인 개념 가지입니다.

1222
01:00:06,870 --> 01:00:10,540
걱정하지 그렇지 않은 경우
꽤 괜찮 아직 타격.

1223
01:00:10,540 --> 01:00:14,740
그러나 일반적이다
방법을 병합 정렬이 작동합니다.

1224
01:00:14,740 --> 01:00:17,750
질문, 빠른 질문,
나는에 이동하기 전에?

1225
01:00:17,750 --> 01:00:18,550
그래.

1226
01:00:18,550 --> 01:00:22,230
>> 청중 : 그래서 당신은 당신이 걸릴 것이라고 말했다
(1) 다음 (4) 및 (6)

1227
01:00:22,230 --> 01:00:23,860
과에 넣어.

1228
01:00:23,860 --> 01:00:26,800
그래서 those--가되지 않습니다 없습니다
당신은 그들을보고

1229
01:00:26,800 --> 01:00:28,544
전체가 아니라 별도의 요소로?

1230
01:00:28,544 --> 01:00:29,210
ANDI 펭 : 네.

1231
01:00:29,210 --> 01:00:32,020
그래서 무슨 일이 일어나고 있는지
당신이이 기본적으로

1232
01:00:32,020 --> 01:00:33,650
새로운 배열을 만들 수 있습니다.

1233
01:00:33,650 --> 01:00:36,690
그래서, 여기, 내가 가진 것을 알고있다
크기 3의 두 배열, 오른쪽?

1234
01:00:36,690 --> 01:00:39,600
그래서 당신은 알고 내 정렬 된 배열
여섯 요소를 가질 필요가있다.

1235
01:00:39,600 --> 01:00:42,270
그래서 당신은 단지를 만들
메모리의 새로운 양.

1236
01:00:42,270 --> 01:00:44,270
그래서 당신은 종류의 같은거야
메모리 낭비되고

1237
01:00:44,270 --> 01:00:46,186
하지만 그건 중요하지 않습니다
너무 작다 때문이다.

1238
01:00:46,186 --> 01:00:48,590
그래서 당신은 1 봐
당신은 2 봐.

1239
01:00:48,590 --> 01:00:50,770
그리고 당신은 1 미만 2 것을 알고 있습니다.

1240
01:00:50,770 --> 01:00:53,840
그래서 당신은 1에 가야 알고
그 모든 시작.

1241
01:00:53,840 --> 01:00:55,850
>> 당신은 할 필요가 없습니다
(3)과 (5)를 봐주세요.

1242
01:00:55,850 --> 01:00:57,400
그래서 당신은 1이 간다 알고있다.

1243
01:00:57,400 --> 01:00:59,300
그럼 당신은 기본적으로 1을 잘라.

1244
01:00:59,300 --> 01:01:00,370
그것은 우리에게 죽은, 같은입니다.

1245
01:01:00,370 --> 01:01:03,690
그런 다음 우리는 단지 2가,
3, 5, 4, 6 다음.

1246
01:01:03,690 --> 01:01:06,270
그리고 당신은, 당신을 알고
비교 (4) 및 (2)

1247
01:01:06,270 --> 01:01:07,560
오, (2)는 거기에 가야한다.

1248
01:01:07,560 --> 01:01:09,685
그래서 당신이 아래로 풍덩, 당신은 그것을 떨어져 들어온다.

1249
01:01:09,685 --> 01:01:12,060
그럼 당신은 단지 3가
및 (4) 및 (6) (5).

1250
01:01:12,060 --> 01:01:14,650
그리고 당신은 그것을 떨어져 자르고 유지
당신은 배열에 넣어 때까지.

1251
01:01:14,650 --> 01:01:17,110
>> 청중 : 그래서 당신은 항상있어
[들리지]를 비교?

1252
01:01:17,110 --> 01:01:17,710
>> ANDI 펭 : 맞아요.

1253
01:01:17,710 --> 01:01:19,590
그래서 그런 의미에서, 당신은있어
다만 비교 본질적

1254
01:01:19,590 --> 01:01:21,240
다른 번호에 대해 하나의 번호.

1255
01:01:21,240 --> 01:01:22,990
그리고 당신이 알고 있기 때문에
그것은 당신을 분류 있다고

1256
01:01:22,990 --> 01:01:24,350
를 통해 볼 필요가 없습니다
숫자의 모든.

1257
01:01:24,350 --> 01:01:25,870
당신은 첫 번째로보고있다.

1258
01:01:25,870 --> 01:01:27,582
그리고 당신은 그냥 풍덩 수 있습니다
그 아래로, 당신이 알고 있기 때문에

1259
01:01:27,582 --> 01:01:29,640
자신이 속한하기 위해 필요로하는 곳에 그들은 속한다.

1260
01:01:29,640 --> 01:01:31,030
그래.

1261
01:01:31,030 --> 01:01:32,920
좋은 질문.

1262
01:01:32,920 --> 01:01:35,290
>> 그리고 당신의있는 경우
조금 야심,

1263
01:01:35,290 --> 01:01:38,660
이 코드를 살펴 주시기 바랍니다.

1264
01:01:38,660 --> 01:01:40,680
이것은 사실이다
물리적 구현

1265
01:01:40,680 --> 01:01:42,150
우리가 병합 정렬을 작성하는 방법.

1266
01:01:42,150 --> 01:01:44,070
그리고 당신은 매우 짧다 볼 수 있습니다.

1267
01:01:44,070 --> 01:01:46,310
뒤에 그러나 아이디어
꽤 복잡하다.

1268
01:01:46,310 --> 01:01:50,865
그래서 당신은이를 그리기 같은 느낌 경우
숙제 오늘 밤에, 주시기 바랍니다.

1269
01:01:50,865 --> 01:01:54,050

1270
01:01:54,050 --> 01:01:54,740
>> 그래.

1271
01:01:54,740 --> 01:01:58,070
그래서 다윗은 또한 강의에서이 이상했다.

1272
01:01:58,070 --> 01:02:00,660
최상의 경우 무엇입니까
런타임, 최악의 경우 런타임,

1273
01:02:00,660 --> 01:02:05,680
및 병합 정렬의 예상 런타임?

1274
01:02:05,680 --> 01:02:07,260
몇 초 생각합니다.

1275
01:02:07,260 --> 01:02:11,198
이 꽤 어렵지만, 가지
당신은 그것에 대해 직관적으로 생각합니다.

1276
01:02:11,198 --> 01:02:20,090

1277
01:02:20,090 --> 01:02:23,054
괜찮아.

1278
01:02:23,054 --> 01:02:25,269
>> 청중 : 최악의 경우 N 로그 N인가?

1279
01:02:25,269 --> 01:02:26,060
ANDI 펭 : 맞아요.

1280
01:02:26,060 --> 01:02:29,380
그리고 왜 N N를 기록한다.

1281
01:02:29,380 --> 01:02:32,230
>> 청중 : 그것은 아닌가요 그것 때문에
기하 급수적으로 빨라집니다

1282
01:02:32,230 --> 01:02:35,390
그래서 그 기능처럼
대신 간단하게 해당되는

1283
01:02:35,390 --> 01:02:37,529
제곱 또는 무엇인가?

1284
01:02:37,529 --> 01:02:38,320
ANDI 펭 : 맞아요.

1285
01:02:38,320 --> 01:02:40,750
그래서 이유
이에 런타임은 N 로그입니다

1286
01:02:40,750 --> 01:02:44,310
당신이 무엇인가 이유는 - n은
모든 단계에서 무엇을?

1287
01:02:44,310 --> 01:02:46,190
당신은 바로, 반으로 자르고있어?

1288
01:02:46,190 --> 01:02:48,750
그래서 우리는 일을 할 때
그것을하고있어 모든 것을 기록

1289
01:02:48,750 --> 01:02:53,150
절반으로 분할되는 문제,
절반, 절반, 더 반쪽에.

1290
01:02:53,150 --> 01:02:56,430
그리고 그런 의미에서, 당신은 종류의 수
선형 모델의 제거

1291
01:02:56,430 --> 01:02:57,510
것을 우리는 사용하고있다.

1292
01:02:57,510 --> 01:03:00,254
당신이 들어온다 때 때문에
반에서 일,이 로그입니다.

1293
01:03:00,254 --> 01:03:02,420
그건 그냥 수학의
그것을 표현하는 방법.

1294
01:03:02,420 --> 01:03:06,310
>> 다음 마지막 끝 부분에서는있어
다만 마지막 패스를 통해 제작

1295
01:03:06,310 --> 01:03:07,930
오른쪽 순서대로 모두 넣어?

1296
01:03:07,930 --> 01:03:10,330
그래서 당신은 단지에있는 경우
한 가지를 확인, 그것은 N입니다.

1297
01:03:10,330 --> 01:03:13,420
그래서 당신은 종류의 것
두 개의 서로를 곱하여.

1298
01:03:13,420 --> 01:03:17,660
당신이 최종있어 같은 그건
N의 로그 여기 아래로 n 개의 확인

1299
01:03:17,660 --> 01:03:18,390
여기.

1300
01:03:18,390 --> 01:03:21,060
그리고 당신은 곱하면
그들, 즉 N N 로그입니다.

1301
01:03:21,060 --> 01:03:26,100
>> 그리고 최상의 경우와 최악
케이스 및 모든 N N를 기록하고 있습니다 기대했다.

1302
01:03:26,100 --> 01:03:27,943
그것은 다른 종류의 같은이기도합니다.

1303
01:03:27,943 --> 01:03:30,090
그것은 선택 정렬처럼
그 의미에서

1304
01:03:30,090 --> 01:03:32,131
무슨 상관하지 않는
목록은 그냥 무슨이다

1305
01:03:32,131 --> 01:03:34,801
같은 일을 매번해야 할 일.

1306
01:03:34,801 --> 01:03:35,300
그래.

1307
01:03:35,300 --> 01:03:39,950
비록, 너희들이 볼 수 그래서
우리는 N through-- 갔어요 종류

1308
01:03:39,950 --> 01:03:41,660
제곱, 그것은 매우 효율적이 아니다.

1309
01:03:41,660 --> 01:03:47,060
심지어이 N 로그 n은
가장 효율적인 없습니다.

1310
01:03:47,060 --> 01:03:49,720
너희들이 궁금하면,
정렬 메커니즘이있다

1311
01:03:49,720 --> 01:03:54,310
그들이있어 너무 효율적이
거의 본질적으로 평면 런타임.

1312
01:03:54,310 --> 01:03:55,420
>> 당신은 몇 가지 로그 N의를 가지고있다.

1313
01:03:55,420 --> 01:03:58,190
당신은 몇 가지 로그 로그 N의를 가지고있다.

1314
01:03:58,190 --> 01:04:00,330
우리는 그들에게 만지지 마세요
지금이 클래스.

1315
01:04:00,330 --> 01:04:02,663
하지만 너희들이 궁금하면,
무슨 일이야, 구글 주시기

1316
01:04:02,663 --> 01:04:04,392
가장 효율적인 정렬 메커니즘.

1317
01:04:04,392 --> 01:04:06,350
나는 거기 몰라
정말 재미있는 것,

1318
01:04:06,350 --> 01:04:09,860
그때 엔 정말이있다
사람들이 만드는 재미 것.

1319
01:04:09,860 --> 01:04:12,210
그리고 당신은 궁금해 그들이
지금까지 그 생각.

1320
01:04:12,210 --> 01:04:15,730
당신은 몇 가지 여분을 가지고 있다면, 구글
시간에, 몇 가지 재미있는 방법은 무엇인가

1321
01:04:15,730 --> 01:04:17,730
그뿐만 아니라 people--
효율적인 ways-- 사람들

1322
01:04:17,730 --> 01:04:20,371
정렬을 구현할 수 있었다.

1323
01:04:20,371 --> 01:04:20,870
그래.

1324
01:04:20,870 --> 01:04:22,880
그리고 여기 그냥 쉽고 간단한 차트입니다.

1325
01:04:22,880 --> 01:04:26,850
나는, 그 퀴즈 0 전에, 여러분 모두를 알고있다
객실에서 아마 시도를 할 것이다

1326
01:04:26,850 --> 01:04:27,960
그 기억합니다.

1327
01:04:27,960 --> 01:04:30,940
그래서 너희들 거기에 좋다.

1328
01:04:30,940 --> 01:04:37,120
그냥 made-- 논리를 잊지 마세요
왜 그 숫자가 발생했다.

1329
01:04:37,120 --> 01:04:39,870
당신은 항상 분실하는 경우, 단지 확인
확실히 당신은 종류가 무엇인지 알고있다.

1330
01:04:39,870 --> 01:04:40,820
그리고 당신은을 통해 실행할 수 있습니다
당신의 마음에 그

1331
01:04:40,820 --> 01:04:42,903
왜 사람들을 알아낼
답변은 그 대답입니다.

1332
01:04:42,903 --> 01:04:46,250

1333
01:04:46,250 --> 01:04:47,600
>> 괜찮아.

1334
01:04:47,600 --> 01:04:49,680
그래서 우리는 이동하는거야
마지막으로, 검색,에.

1335
01:04:49,680 --> 01:04:51,638
때문에 당신의 것과 같은
누가 PSET을 읽고,

1336
01:04:51,638 --> 01:04:55,175
또한 검색의 일부
이번 주 문제는 설정합니다.

1337
01:04:55,175 --> 01:04:57,300
당신은 실행하라는 메시지가 표시됩니다
두 가지 유형의 검색.

1338
01:04:57,300 --> 01:05:00,070
하나는 선형 검색하며
하나는 이진 검색이다.

1339
01:05:00,070 --> 01:05:01,760
>> 그래서 선형 검색은 매우 간단합니다.

1340
01:05:01,760 --> 01:05:04,070
당신은 요소를 검색 할
당신이 그것을 얻을 경우 목록으로 볼 수 있습니다.

1341
01:05:04,070 --> 01:05:05,444
당신은을 통해 반복해야합니다.

1342
01:05:05,444 --> 01:05:08,170
그리고 뭔가를 동일한 경우,
당신이 바로, 그것을 반환 할 수 있습니까?

1343
01:05:08,170 --> 01:05:10,890
그러나 한 우리는 대부분의 걸
이야기에 관심

1344
01:05:10,890 --> 01:05:14,550
이진 검색은 인 권리이다
분할기구를 정복하는

1345
01:05:14,550 --> 01:05:18,190
다윗은 강의에서 입증되었다.

1346
01:05:18,190 --> 01:05:20,810
>> 전화 번호부 예 기억
그는 양육 유지하는 것이,

1347
01:05:20,810 --> 01:05:23,960
그는 종류의 고투 한
지난 해에 조금,

1348
01:05:23,960 --> 01:05:27,530
만약 반 문제를 분할하는 경우,
절반, 절반, 또 다시,

1349
01:05:27,530 --> 01:05:30,730
당신은 당신이 원하는 것을 찾을 때까지?

1350
01:05:30,730 --> 01:05:33,727
그리고 당신이있어
뿐만 아니라 그 실행.

1351
01:05:33,727 --> 01:05:35,810
그리고 당신이 볼 수있는, 그것은이다
훨씬 더 효율적

1352
01:05:35,810 --> 01:05:39,080
검색은 임의의 다른 타입보다.

1353
01:05:39,080 --> 01:05:41,880
>> 그래서 우리가 갈 것이다 방법
이진 검색을 구현

1354
01:05:41,880 --> 01:05:46,510
, 우리가 배열이 있다면,
인덱스 0-6, 일곱 요소,

1355
01:05:46,510 --> 01:05:49,790
우리는 right--, 중간에 볼 수 있습니다
죄송합니다, 우리의 질문 경우 first--

1356
01:05:49,790 --> 01:05:53,840
우리가 질문을하려는 경우, 수행
배열은, (7)의 요소를 포함

1357
01:05:53,840 --> 01:05:56,840
분명히, 인간을 존재하고, 필요
작은 배열과 같은, 그것은 우리를 위해 쉽게

1358
01:05:56,840 --> 01:05:58,210
네 대답.

1359
01:05:58,210 --> 01:06:05,750
그러나이 방법을 구현하는 이진
검색 중간에보고 될 것이다.

1360
01:06:05,750 --> 01:06:08,020
>> 우리는 색인 3 것을 알고
중간, 우리 때문에

1361
01:06:08,020 --> 01:06:09,270
일곱 요소가 알고있다.

1362
01:06:09,270 --> 01:06:10,670
무엇 7은 2로 나눈?

1363
01:06:10,670 --> 01:06:12,850
당신은 추가 한 것을 잘라낼 수 있습니다.

1364
01:06:12,850 --> 01:06:14,850
당신은 중간에 3을 가지고있다.

1365
01:06:14,850 --> 01:06:17,590
그래서 7과 동일한 3의 배열입니다?

1366
01:06:17,590 --> 01:06:18,900
그것은 바로, 아니다?

1367
01:06:18,900 --> 01:06:21,050
그러나 우리는 검사의 몇 가지 작업을 수행 할 수 있습니다.

1368
01:06:21,050 --> 01:06:25,380
3 이하 7 이상 또는 배열
7보다 큰 3의 배열입니다?

1369
01:06:25,380 --> 01:06:27,240
>> 그리고 우리는 덜 7보다 있다는 것을 알고있다.

1370
01:06:27,240 --> 01:06:30,259
그래서 우리는 알고 오, 그것은해야합니다, 그
왼쪽 절반을지지 않습니다.

1371
01:06:30,259 --> 01:06:32,300
우리는해야합니다 알고
오른쪽 절반에, 오른쪽?

1372
01:06:32,300 --> 01:06:34,662
그래서 우리는 절반 배열을 절단 할 수 있습니다.

1373
01:06:34,662 --> 01:06:36,370
우리는 심지어 필요가 없습니다
더 이상 봐.

1374
01:06:36,370 --> 01:06:38,711
우리는 것을 알고 있기 때문에
우리의 problem--의 절반

1375
01:06:38,711 --> 01:06:41,210
우리는 대답에 있음을 알고있다
우리의 문제의 오른쪽 절반.

1376
01:06:41,210 --> 01:06:42,580
그래서 우리는 지금 막 봐.

1377
01:06:42,580 --> 01:06:44,860
>> 그래서 지금 우리가보고
남은 것의 중간.

1378
01:06:44,860 --> 01:06:46,880
즉, 인덱스 5.

1379
01:06:46,880 --> 01:06:50,200
우리는 다시 같은 검사를 할
우리는 작다 것을 알 수있다.

1380
01:06:50,200 --> 01:06:52,050
그래서 우리는 그 왼쪽에 보인다.

1381
01:06:52,050 --> 01:06:53,430
그리고 우리는 그 검사를 참조하십시오.

1382
01:06:53,430 --> 01:06:57,600
배열 값에서인가
7 동일한 인덱스 4?

1383
01:06:57,600 --> 01:06:58,260
그것은.

1384
01:06:58,260 --> 01:07:03,580
그래서 우리는, true를 돌려 때문에 수
우리는 우리의 목록에서 값을 발견했다.

1385
01:07:03,580 --> 01:07:06,738
내가 겪었 방법을합니까
모두에게 그 말이?

1386
01:07:06,738 --> 01:07:08,760
그래.

1387
01:07:08,760 --> 01:07:11,670
나는 같은, 어쩌면 너희들을 줄 것이다
셋, 넷 분 알아낼

1388
01:07:11,670 --> 01:07:13,270
방법이를 의사합니다.

1389
01:07:13,270 --> 01:07:18,070
>> 그래서 나는 쓰기를 요청 상상
반환 기능이라고 검색 ()

1390
01:07:18,070 --> 01:07:20,640
값, 부울 값,
즉, 같은 사실 또는 false--

1391
01:07:20,640 --> 01:07:22,970
당신이 발견하는 경우는 true
값, 당신은하지 않았다 경우는 false.

1392
01:07:22,970 --> 01:07:25,230
그리고 당신은 있었다
값을 전달하면

1393
01:07:25,230 --> 01:07:28,410
값으로 찾고 된
array-- 오, 나는 확실히 넣어

1394
01:07:28,410 --> 01:07:29,410
잘못된 위치에있다.

1395
01:07:29,410 --> 01:07:29,580
그래.

1396
01:07:29,580 --> 01:07:31,829
어쨌든, 그것은이 있어야합니다
값의 오른쪽에 있었다.

1397
01:07:31,829 --> 01:07:36,280
다음 INT N은 숫자이며
그 배열의 요소.

1398
01:07:36,280 --> 01:07:39,430
어떻게 노력에 대해 갈 것
에서 그 문제를 의사가?

1399
01:07:39,430 --> 01:07:41,630
난 당신 같은 사람을 줄 것이다
삼분 그렇게 할 수 있습니다.

1400
01:07:41,630 --> 01:08:00,137

1401
01:08:00,137 --> 01:08:02,595
아니, 난 only-- 있다고 생각
그래, 바로 여기에 하나가있다.

1402
01:08:02,595 --> 01:08:03,261
청중 : 나는 할 수 있습니까?

1403
01:08:03,261 --> 01:08:04,388
ANDI 펭 : 그래, 난 당신을 얻었다.

1404
01:08:04,388 --> 01:08:09,410

1405
01:08:09,410 --> 01:08:11,050
그 작업인​​가?

1406
01:08:11,050 --> 01:08:12,290
그래 좋아.

1407
01:08:12,290 --> 01:10:43,590

1408
01:10:43,590 --> 01:10:44,720
>> 그래.

1409
01:10:44,720 --> 01:10:47,630
좋아 얘들 아, 우리는있어
그것을 억제 할 것.

1410
01:10:47,630 --> 01:10:49,730
그래.

1411
01:10:49,730 --> 01:10:54,020
그래서 우리는이 사랑스러운있어 가정
거기에 N 값이 작은 배열입니다.

1412
01:10:54,020 --> 01:10:55,170
나는 선을 그릴하지 않았다.

1413
01:10:55,170 --> 01:10:58,649
그러나 우리는에 대해 어떻게 갈 것
이 작성하려고?

1414
01:10:58,649 --> 01:11:00,440
사람이 원하는 않는다
나에게 첫 번째 라인을 제공?

1415
01:11:00,440 --> 01:11:02,814
당신은 나에게주고 싶은 경우
이 의사의 첫 번째 줄.

1416
01:11:02,814 --> 01:11:06,563

1417
01:11:06,563 --> 01:11:08,430
>> 청중 : [들리지]

1418
01:11:08,430 --> 01:11:10,138
청중 : 당신은 싶어
through-- 반복하는

1419
01:11:10,138 --> 01:11:11,094
청중 : 그냥 다른 루프?

1420
01:11:11,094 --> 01:11:11,760
청중 : --for.

1421
01:11:11,760 --> 01:11:15,880

1422
01:11:15,880 --> 01:11:17,780
>> ANDI 펭 : 그래서이 사람은 조금 까다로운.

1423
01:11:17,780 --> 01:11:23,130
당신이 원하는 비슷해 생각
이 루프를 계속 실행하기

1424
01:11:23,130 --> 01:11:27,950
또 다시 언제까지?

1425
01:11:27,950 --> 01:11:30,819
>> 청중 : [들리지]까지
값은 그 값과 같습니다.

1426
01:11:30,819 --> 01:11:31,610
ANDI 펭 : 맞아요.

1427
01:11:31,610 --> 01:11:33,900
그래서 당신은 실제로 단지 write-- 수 있습니다
우리는 더를 단순화 할 수 있습니다.

1428
01:11:33,900 --> 01:11:35,630
우리는 바로, while 루프를 할 수 있습니까?

1429
01:11:35,630 --> 01:11:39,380
그래서 당신은 loop-- 수 있습니다
우리는 잠시 있다는 것을 알고있다.

1430
01:11:39,380 --> 01:11:42,850
하지만 지금, 나는거야
무엇을 통해 - "루프"말을?

1431
01:11:42,850 --> 01:11:46,640
루프는 무엇 until--
우리의 종료 조건?

1432
01:11:46,640 --> 01:11:47,510
내가 들었 생각합니다.

1433
01:11:47,510 --> 01:11:48,530
나는 누군가가 말을 들었다.

1434
01:11:48,530 --> 01:11:51,255
>> 청중 : 값은 중간 같습니다.

1435
01:11:51,255 --> 01:11:52,255
ANDI 펭 : 다시 말해봐.

1436
01:11:52,255 --> 01:11:54,470
까지 또는 : 관객
값이 검색하는

1437
01:11:54,470 --> 01:11:58,470
위한 중간 값은 동일하다.

1438
01:11:58,470 --> 01:12:00,280
>> ANDI 펭 : 거기에없는 경우는 어떻게?

1439
01:12:00,280 --> 01:12:03,113
어떤 경우에는 당신이 검색하는 값
이 배열에 실제로 아니다?

1440
01:12:03,113 --> 01:12:05,890
청중 : 당신은 1을 반환합니다.

1441
01:12:05,890 --> 01:12:08,850
>> ANDI 펭 :하지만 우리는 무엇을 하시겠습니까?
우리는 조건이있는 경우까지 루프?

1442
01:12:08,850 --> 01:12:09,350
그래.

1443
01:12:09,350 --> 01:12:11,239
>> 청중 : 하나의 값이 될 때까지?

1444
01:12:11,239 --> 01:12:13,530
ANDI 펭 : 당신이 할 수있는 루프
until--은 그래서 당신은 당신이 거 알아

1445
01:12:13,530 --> 01:12:15,714
바로, 최대 값을해야 할 것?

1446
01:12:15,714 --> 01:12:18,130
그리고 당신은 당신이 가고 있다는 것을 알고있다
오른쪽 분 값을 가지고 있습니까?

1447
01:12:18,130 --> 01:12:20,379
또한, 그 무언가 때문에
내가 전에 말을 잊었다

1448
01:12:20,379 --> 01:12:22,640
의 뭔가
이진 검색에 대한 중요

1449
01:12:22,640 --> 01:12:24,182
당신의 배열이 이미 정렬되어 있다는 것입니다.

1450
01:12:24,182 --> 01:12:26,973
수행의 방법이 없기 때문에
이 그들은 단지 임의의 값을하는 경우.

1451
01:12:26,973 --> 01:12:29,190
하나가 있다면 당신은 몰라
다른 것보다 더 큰, 오른쪽?

1452
01:12:29,190 --> 01:12:32,720
>> 그래서 당신이 알고있는 당신의 최대 및
당신의 분은 바로 여기에있다?

1453
01:12:32,720 --> 01:12:35,590
당신이 조정 될 거라면
당신의 분, mid--에서 최대

1454
01:12:35,590 --> 01:12:38,470
그냥 가정하자 당신의
중간 값은 바로 here--입니다

1455
01:12:38,470 --> 01:12:43,910
당신은 기본적으로거야
루프가 최소가 될 때까지

1456
01:12:43,910 --> 01:12:47,510
오른쪽, 당신의 최대와 동일, 또는 약
당신의 최대는 분으로 동일하지 않은 경우.

1457
01:12:47,510 --> 01:12:48,040
권리?

1458
01:12:48,040 --> 01:12:51,340
그렇게되면 있기 때문에, 당신은 알고
당신은 결국 동일한 값을 부딪혔을.

1459
01:12:51,340 --> 01:12:59,135
그래서 당신은 당신의 분까지 루프를 원하는
보다 작거나 죄송합니다 이러시면 동일

1460
01:12:59,135 --> 01:13:01,510
아니보다 작거나 같음,
최대 around-- 다른 방법입니다.

1461
01:13:01,510 --> 01:13:15,110

1462
01:13:15,110 --> 01:13:16,160
>> 그 의미를 했습니까?

1463
01:13:16,160 --> 01:13:18,810
나는 그 권리를 얻기 위해 몇 가지 시도를했다.

1464
01:13:18,810 --> 01:13:21,869
그러나 루프 당신의 최대 값까지
본질적으로 거의 이하

1465
01:13:21,869 --> 01:13:23,410
이상 또는 최소 동일, 오른쪽?

1466
01:13:23,410 --> 01:13:25,201
당신이 알고있는 때이다
당신은 수렴했다고.

1467
01:13:25,201 --> 01:13:29,290
청중 : 때 것 최대
값은 최소값보다 작?

1468
01:13:29,290 --> 01:13:31,040
ANDI 펭 : 당신은 유지하는 경우
이를 조정하는

1469
01:13:31,040 --> 01:13:32,380
우리가가는 것입니다
이에서 일을합니다.

1470
01:13:32,380 --> 01:13:33,460
말이 돼?

1471
01:13:33,460 --> 01:13:35,750
최소 및 최대 단지이다
우리는 아마 정수

1472
01:13:35,750 --> 01:13:39,260
원하는가는 계속 만들 수
우리가 찾고있는 위치를 추적.

1473
01:13:39,260 --> 01:13:41,790
배열이 존재하기 때문에
에 관계없이 우리가 무슨 일을하는지의.

1474
01:13:41,790 --> 01:13:45,030
마찬가지로, 우리는 실제로 물리적 아니에요
오른쪽 배열 떨어져 자르고?

1475
01:13:45,030 --> 01:13:47,261
우리는 단지 조정하고
우리는 어디에서 찾고 있습니다.

1476
01:13:47,261 --> 01:13:48,136
말이 돼?

1477
01:13:48,136 --> 01:13:48,472
>> 청중 : 네.

1478
01:13:48,472 --> 01:13:49,110
>> ANDI 펭 : OK.

1479
01:13:49,110 --> 01:13:57,090
즉 우리의 루프의 조건의 경우에 따라서,
우리는이 루프의 내부에 무엇을 원하는가?

1480
01:13:57,090 --> 01:13:58,700
우리는 무엇을하고자하는 건가요?

1481
01:13:58,700 --> 01:14:02,390
그래서 지금, 우리는있어
최대 및 최소, 오른쪽,

1482
01:14:02,390 --> 01:14:04,962
아마 여기 어딘가에 만들었습니다.

1483
01:14:04,962 --> 01:14:07,170
우리는 아마 원하는거야
오른쪽 중간을 찾는 방법은?

1484
01:14:07,170 --> 01:14:08,450
우리는 어떻게 할거야
중간을 찾을 수?

1485
01:14:08,450 --> 01:14:09,491
mathematical--은 무엇인가

1486
01:14:09,491 --> 01:14:11,079
청중 : 맥스 플러스 2로 나눈 분.

1487
01:14:11,079 --> 01:14:11,870
ANDI 펭 : 맞아요.

1488
01:14:11,870 --> 01:14:20,300

1489
01:14:20,300 --> 01:14:21,620
말이 돼?

1490
01:14:21,620 --> 01:14:25,780
그리고 너희들은 왜 우리를 볼 수 있습니까
우리가 이런 짓을 왜 그냥 use--하지 않았다

1491
01:14:25,780 --> 01:14:27,850
대신 일을 바로 N 2로 나눈?

1492
01:14:27,850 --> 01:14:30,310
n은 값이 그것 때문에
즉 동일하게 유지하는 것입니다.

1493
01:14:30,310 --> 01:14:30,979
권리?

1494
01:14:30,979 --> 01:14:34,020
그러나 우리는 우리의 최소한을 조정하고
최대 값, 그들은 변경 될 것입니다.

1495
01:14:34,020 --> 01:14:36,040
결과적으로, 우리의 중간
너무 바꿀 것입니다.

1496
01:14:36,040 --> 01:14:37,873
우리가 원하는 이유 그래서입니다
여기에이 권리를 할 수 있습니다.

1497
01:14:37,873 --> 01:14:38,510
그래.

1498
01:14:38,510 --> 01:14:41,600
>> 그리고, 지금
우리는 그래 our-- 발견했습니다.

1499
01:14:41,600 --> 01:14:44,270
>> 청중 : 그냥 빨리 question--
때 최소 및 최대 말,

1500
01:14:44,270 --> 01:14:46,410
우리는 가정된다
그것은 이미 정렬이야?

1501
01:14:46,410 --> 01:14:48,400
>> ANDI 펭이 : 네, 사실입니다
이진 검색을위한 전제 조건,

1502
01:14:48,400 --> 01:14:49,816
당신이 가지고이 분류 것을 알고 있습니다.

1503
01:14:49,816 --> 01:14:53,660
왜 일종 인 당신은 쓸 당신의
문제는 이진 검색하기 전에 설정합니다.

1504
01:14:53,660 --> 01:14:55,910
그래.

1505
01:14:55,910 --> 01:14:58,876
그래서 지금 우리가 어디에서 우리의 중간 점을 알고
, 당신은 무엇을 여기에서하고 싶어한다?

1506
01:14:58,876 --> 01:15:01,789

1507
01:15:01,789 --> 01:15:04,319
>> 청중 : 우리는 비교하려는
다른 하나에있다.

1508
01:15:04,319 --> 01:15:05,110
ANDI 펭 : 맞아요.

1509
01:15:05,110 --> 01:15:12,280
그래서 당신은 비교거야
값으로 중간, 오른쪽?

1510
01:15:12,280 --> 01:15:14,900

1511
01:15:14,900 --> 01:15:18,670
그리고 그 무엇을 말해 주는가
우리에게 우리가 비교할 때?

1512
01:15:18,670 --> 01:15:22,226
우리는 무엇을 나중에 수행 할 수 있습니까?

1513
01:15:22,226 --> 01:15:25,389
>> 청중 : 값이 큰 경우
중반보다, 우리는 그것을 차단합니다.

1514
01:15:25,389 --> 01:15:26,180
ANDI 펭 : 맞아요.

1515
01:15:26,180 --> 01:15:33,940
값이 너무 크면
중반보다, 우리는있어

1516
01:15:33,940 --> 01:15:36,550
이러한 변경하려는 것
최소 maxes, 오른쪽?

1517
01:15:36,550 --> 01:15:38,980
우리는 무엇을 변경 하시겠습니까?

1518
01:15:38,980 --> 01:15:42,145
우리가 알고있는 경우에 따라서 값은 어딘가에
여기, 우리가 변경할 수 무엇?

1519
01:15:42,145 --> 01:15:44,758
우리는 우리를 변경하려면
최소 오른쪽, 중앙 수 있습니까?

1520
01:15:44,758 --> 01:15:49,420

1521
01:15:49,420 --> 01:15:54,292
그리고 또,이에 있다면
반, 우리는 무엇을 변경 하시겠습니까?

1522
01:15:54,292 --> 01:15:55,306
>> 청중 : 최대.

1523
01:15:55,306 --> 01:15:55,972
ANDI 펭 : 네.

1524
01:15:55,972 --> 01:16:02,597

1525
01:16:02,597 --> 01:16:04,680
그리고 당신은거야
, 오른쪽 반복 유지?

1526
01:16:04,680 --> 01:16:08,920
지금 때문에, 하나의 반복 후
을 통해, 당신은 여기에 최대를 가지고있다.

1527
01:16:08,920 --> 01:16:10,760
그리고 당신은 중반을 다시 계산할 수 있습니다.

1528
01:16:10,760 --> 01:16:11,990
그리고 당신은 비교할 수 있습니다.

1529
01:16:11,990 --> 01:16:14,766
그리고 당신은 계속거야
분, maxes까지

1530
01:16:14,766 --> 01:16:15,890
기본적으로 통합했다.

1531
01:16:15,890 --> 01:16:17,890
당신이 알고 때 그건
당신은 그것의 끝을 공격했습니다.

1532
01:16:17,890 --> 01:16:20,280
그리고 어느 쪽이든 당신은 그것을 발견했습니다
또는 당신은 그 시점에서하지 않았습니다.

1533
01:16:20,280 --> 01:16:23,170
>> 이것은 모두에게 의미가 있습니까?

1534
01:16:23,170 --> 01:16:26,020

1535
01:16:26,020 --> 01:16:26,770
그래.

1536
01:16:26,770 --> 01:16:27,900
이것은 매우 중요하다
당신은 할 것이기 때문에

1537
01:16:27,900 --> 01:16:29,760
코드 오늘 밤에이를 작성합니다.

1538
01:16:29,760 --> 01:16:32,660
그러나 너희들은 꽤 좋은가
당신이 일을해야 무엇을 의미,

1539
01:16:32,660 --> 01:16:34,051
하는 것이 좋다.

1540
01:16:34,051 --> 01:16:34,550
그래.

1541
01:16:34,550 --> 01:16:38,840
그래서 우리는 일곱에 대해있어
분 섹션을 떠났다.

1542
01:16:38,840 --> 01:16:43,170
그래서 우리는에 대해 이야기하는거야
우리가 일을 할 것이다이 PSET.

1543
01:16:43,170 --> 01:16:46,410
그래서 PSET은 두 부분으로 나누어 져 있습니다.

1544
01:16:46,410 --> 01:16:50,230
상반기 포함
찾기를 구현

1545
01:16:50,230 --> 01:16:54,210
하는 당신은 선형 검색 쓰기,
이진 검색하고 정렬 알고리즘.

1546
01:16:54,210 --> 01:16:56,690
>> 그래서이 처음이다
PSET 곳에서 시간

1547
01:16:56,690 --> 01:17:00,050
라고 우리는 너희들을주고있을거야
분포 코드, 코드는

1548
01:17:00,050 --> 01:17:02,740
우리는 미리 작성된 것으로,
하지만 방금 일부 조각을 왼쪽으로

1549
01:17:02,740 --> 01:17:04,635
에 대한 당신은 글을 마칩니다.

1550
01:17:04,635 --> 01:17:07,510
이 봐 너희들, 그래서
코드, 당신은 정말 겁 있습니다.

1551
01:17:07,510 --> 01:17:08,630
당신은, 아, 내가 좋아하는 그냥하는 경우
그 무엇을하는지 모른다,

1552
01:17:08,630 --> 01:17:11,670
내가 좋아하는, 즉 것, 모르는
너무 복잡, 아, 휴식.

1553
01:17:11,670 --> 01:17:12,170
괜찮아요.

1554
01:17:12,170 --> 01:17:12,930
사양을 참조하십시오.

1555
01:17:12,930 --> 01:17:16,920
사양은 정확하게 당신에게 설명 할 것
이 모든 프로그램은 무엇을하고 있습니다.

1556
01:17:16,920 --> 01:17:20,560
>> 예를 들어, generate.c는 프로그램이다
그게 당신의 PSET 함께 올 것이다.

1557
01:17:20,560 --> 01:17:24,060
당신은 실제로 그것을 터치해야하지만하지 않습니다
당신은 무엇을하고 있는지 이해해야합니다.

1558
01:17:24,060 --> 01:17:28,550
그리고 generate.c, 그것은하고있어 모든입니다
중 임의의 숫자를 생성

1559
01:17:28,550 --> 01:17:32,400
또는 당신처럼, 그것을 씨앗을 제공 할 수 있습니다
걸리는 사전에 조정 번호,

1560
01:17:32,400 --> 01:17:34,140
그리고 이상의 숫자를 생성한다.

1561
01:17:34,140 --> 01:17:37,170
그래서 특정 방식이있다
generate.c을 구현하는

1562
01:17:37,170 --> 01:17:42,760
당신은 단지 숫자의 무리를 만들 수 있습니다
당신은 다른 방법에 테스트를 위해.

1563
01:17:42,760 --> 01:17:45,900
>> 그래서 당신이 원하는 경우에 대한
예를 들어, 당신의 발견을 테스트

1564
01:17:45,900 --> 01:17:48,970
당신이 generate.c을 실행하려는 것이다,
숫자의 무리를 생성

1565
01:17:48,970 --> 01:17:50,880
다음 헬퍼 함수를​​ 실행합니다.

1566
01:17:50,880 --> 01:17:53,930
당신이있어 어디 도우미 기능입니다
실제로 물리적으로 코드를 작성.

1567
01:17:53,930 --> 01:17:59,330
그리고 라이브러리 파일로 헬퍼 생각
당신은 찾기가 호출 쓰고있어.

1568
01:17:59,330 --> 01:18:02,950
그래서 helpers.c 내에서, 당신은거야
검색 및 정렬 할.

1569
01:18:02,950 --> 01:18:06,500
>> 그리고 당신은 본질적으로거야
그냥 모두 함께 넣어.

1570
01:18:06,500 --> 01:18:10,350
방법에 대한 사양은 당신을 말할 것이다
명령 행에 해당했습니다.

1571
01:18:10,350 --> 01:18:14,880
그리고 당신이 있는지 여부를 테스트 할 수 있습니다 또는
아닌 정렬 및 검색이 노력하고 있습니다.

1572
01:18:14,880 --> 01:18:15,870
쿨.

1573
01:18:15,870 --> 01:18:18,720
사람이 이미 시작하고
발생하는 문제 또는 질문

1574
01:18:18,720 --> 01:18:20,520
그들은이와 지금이?

1575
01:18:20,520 --> 01:18:21,020
그래.

1576
01:18:21,020 --> 01:18:21,476
>> 청중 : 기다립니다.

1577
01:18:21,476 --> 01:18:21,932
나는 질문이 있습니다.

1578
01:18:21,932 --> 01:18:22,844
>> ANDI 펭 : 네.

1579
01:18:22,844 --> 01:18:28,390
>> 청중 : 그래서 나는 일을 시작
helpers.c의 선형 검색

1580
01:18:28,390 --> 01:18:29,670
그리고 그것은 정말로 작동되지 않았습니다.

1581
01:18:29,670 --> 01:18:34,590
그러나 나중에, 우리 단지를 발견
을 삭제하고 이진 검색을 할 수 있습니다.

1582
01:18:34,590 --> 01:18:36,991
그것이 작동하지 않는 경우에 따라서는 문제가 무엇입니까?

1583
01:18:36,991 --> 01:18:39,700

1584
01:18:39,700 --> 01:18:41,510
>> ANDI 펭 : 짧은 대답은 no입니다.

1585
01:18:41,510 --> 01:18:42,642
하지만 이후 우리는 싫든있어

1586
01:18:42,642 --> 01:18:44,350
청중 :하지만 아무도
실제로 검사합니다.

1587
01:18:44,350 --> 01:18:46,058
ANDI 펭 : 우리는 결코 것 없​​다
것을 볼 것.

1588
01:18:46,058 --> 01:18:49,590
하지만 당신은 아마 만들고 싶어
확인 검색이 노력하고 있습니다.

1589
01:18:49,590 --> 01:18:51,700
당신의 선형 경우 때문에
검색이 작동하지 않습니다,

1590
01:18:51,700 --> 01:18:54,410
다음 기회는 당신의 바이너리
검색이 잘 작동하지 않을.

1591
01:18:54,410 --> 01:18:56,646
당신은 비슷한 가지고 있기 때문에
그 양자의 논리.

1592
01:18:56,646 --> 01:18:58,020
그리고 아니, 정말 중요하지 않습니다.

1593
01:18:58,020 --> 01:19:01,300
그래서 유일한 사람은 당신이 설정합니다
에 정렬과 이진 검색입니다.

1594
01:19:01,300 --> 01:19:02,490
그래.

1595
01:19:02,490 --> 01:19:06,610
>> 또한, 아이들이 많이 있었다
helpers.c를 컴파일하려고합니다.

1596
01:19:06,610 --> 01:19:09,550
당신은 실제로 허용하지 않을
, 그렇게 helpers.c 때문에하기

1597
01:19:09,550 --> 01:19:11,200
주요 기능이 없습니다.

1598
01:19:11,200 --> 01:19:13,550
그래서 당신은해야
실제로 컴파일 할 수

1599
01:19:13,550 --> 01:19:18,670
전화를 찾을 수 있기 때문에, 생성하고 찾을 수
helpers.c과 그 안에 기능.

1600
01:19:18,670 --> 01:19:20,790
그 디버깅을하게 그래서
엉덩이에 통증이.

1601
01:19:20,790 --> 01:19:22,422
하지만 우리가해야 할 일이다.

1602
01:19:22,422 --> 01:19:23,880
청중 : 당신은 바로, 모든을?

1603
01:19:23,880 --> 01:19:27,290
ANDI 펭 : 당신은 할 수 있습니다
네,뿐만 아니라 모든합니다.

1604
01:19:27,290 --> 01:19:28,060
그래.

1605
01:19:28,060 --> 01:19:32,570
그래서 어떤면에서 그것 뿐이다
PSET 여러분 모두가해야 할 요구하고있다.

1606
01:19:32,570 --> 01:19:35,160
당신은 질문이있는 경우에는, 느낌
섹션 후 나에게 물어 주시기.

1607
01:19:35,160 --> 01:19:37,580
나는 20 분, 같은, 여기있을거야.

1608
01:19:37,580 --> 01:19:40,500
>> 그리고 그래, PSET의의
정말 나쁘지 않다.

1609
01:19:40,500 --> 01:19:41,680
너희들은 확인해야합니다.

1610
01:19:41,680 --> 01:19:43,250
이, 그냥 지침을 따르십시오.

1611
01:19:43,250 --> 01:19:47,840
종류의 논리적의 감각을 가지고, 어떤
해야이 일어나고있는 당신은 괜찮을거야.

1612
01:19:47,840 --> 01:19:48,690
너무 무서워하지 마십시오.

1613
01:19:48,690 --> 01:19:50,220
많은 코드가있다
이미 작성.

1614
01:19:50,220 --> 01:19:53,011
그렇게하지 ​​않으면 너무 무서워하지 마라
그 모두가 무엇을 의미하는지 이해합니다.

1615
01:19:53,011 --> 01:19:54,749
이 많이 있다면, 그것은 완전히 괜찮아요.

1616
01:19:54,749 --> 01:19:55,790
그리고 근무 시간에 온다.

1617
01:19:55,790 --> 01:19:57,520
우리는 당신을 살펴 도움이됩니다.

1618
01:19:57,520 --> 01:20:00,810
>> 청중 : 추가로
기능, 우리는 사람들을 찾아 볼 수 있습니까?

1619
01:20:00,810 --> 01:20:03,417
>> ANDI 펭 : 네, 그 코드에 있습니다.

1620
01:20:03,417 --> 01:20:05,750
15 게임, 절반의에서
이미 당신을 위해 작성합니다.

1621
01:20:05,750 --> 01:20:09,310
그래서 그 기능은
이미 코드.

1622
01:20:09,310 --> 01:20:12,020
네.

1623
01:20:12,020 --> 01:20:12,520
괜찮아.

1624
01:20:12,520 --> 01:20:14,000
그럼, 행운을 빈다.

1625
01:20:14,000 --> 01:20:15,180
그것은 역겨운 일이다.

1626
01:20:15,180 --> 01:20:19,370
그래서 희망 너희들은 너무 생각하지 않습니다
내부 체재 및 코딩에 대한 나쁜.

1627
01:20:19,370 --> 01:20:22,133