1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [주 6]

2
00:00:02,000 --> 00:00:04,000
[데이비드 J. Malan] [하버드 대학]

3
00:00:04,000 --> 00:00:08,000
[이 CS50 수 있습니다.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> 이 CS50이며,이 주 6의 시작입니다

5
00:00:12,000 --> 00:00:16,000
있도록 새로운 도구의 부부는 이제 활용 할 수 있습니다

6
00:00:16,000 --> 00:00:19,000
그 중 첫 번째는 CS50 스타일이라고합니다.

7
00:00:19,000 --> 00:00:22,000
당신이 또는 교육 친구들의 같은 경우 확률은

8
00:00:22,000 --> 00:00:26,000
당신은 아마 그의 스타일과 같은 작은 선물을 보이는 프로그램을 봤어요.

9
00:00:26,000 --> 00:00:30,000
, 아마 당신은 밤 늦게 일부 모서리를 절단 시작하거나 나중에 해결 하죠

10
00:00:30,000 --> 00:00:32,000
그리고 TF 또는 CA는 근무 시간 중에 이상이 있습니다.

11
00:00:32,000 --> 00:00:34,000
우리 읽기 그리고는 어렵습니다.

12
00:00:34,000 --> 00:00:38,000
음,이 코드는 구문 올바른이며, 컴파일하고, 실제로 실행됩니다.

13
00:00:38,000 --> 00:00:40,000
그러나 확실히 스타일 5 없습니다.

14
00:00:40,000 --> 00:00:45,000
>> 하지만 지금은 우리가이 디렉토리에 가면 여기

15
00:00:45,000 --> 00:00:48,000
내가 가지고 conditions2.c -를 발견

16
00:00:48,000 --> 00:00:55,000
그리고, 입력이 파일 conditions2.c에이 새로운 명령, style50를 실행

17
00:00:55,000 --> 00:00:57,000
그냥 그대로두면 양식화 된 것을 내게 알려 있다는 것을.

18
00:00:57,000 --> 00:01:00,000
Gedit는 파일이 디스크에 변경되었습니다 것으로 나타났습니다

19
00:01:00,000 --> 00:01:08,000
제가 새로 고침을 클릭한다면, 모든 문제는 현재 자동화되어 있습니다.

20
00:01:08,000 --> 00:01:15,000
[박수]

21
00:01:15,000 --> 00:01:17,000
우리가 이번 주말 짓을 한 일 중 하나입니다.

22
00:01:17,000 --> 00:01:20,000
몇 가지 코드가 있기 때문에 그 불완전한 것을 실현

23
00:01:20,000 --> 00:01:23,000
단순히 완벽하게 어떤 양식에 일치시키다 할 수,하지 않습니다

24
00:01:23,000 --> 00:01:26,000
하지만 실현이 이제의 이점을 누리 실 수 있습니다 도구입니다

25
00:01:26,000 --> 00:01:33,000
경우에만 더 잘못 될 수 있네, 비유하자면 배치 중괄호 최대 깔끔한 일부와 같은합니다.

26
00:01:33,000 --> 00:01:36,000
>> 하지만 좀 더 설득력 지금은 CS50 확인합니다.

27
00:01:36,000 --> 00:01:39,000
CS50 확인을 통해, 당신은 실제로 같은 정확성 검사를 수행 할 수 있습니다

28
00:01:39,000 --> 00:01:42,000
교육 친구들이 할 수 있다는 자신의 코드에.

29
00:01:42,000 --> 00:01:44,000
이 어플라이언스에 나왔고, 명령 줄 유틸리티입니다

30
00:01:44,000 --> 00:01:46,000
최대한 빨리 당으로 update50을로

31
00:01:46,000 --> 00:01:49,000
pset 4 사양이 다음과 같이 본질적를 사용합니다.

32
00:01:49,000 --> 00:01:51,000
당신은 명령 check50을 실행합니다.

33
00:01:51,000 --> 00:01:56,000
그런 다음 당신은 명령 줄 인수를 전달, 또는 좀 더 일반적으로 스위치 또는 깃발로 알려져 있습니다.

34
00:01:56,000 --> 00:01:58,000
일반적으로 하이픈이 물건은 스위치라고합니다

35
00:01:58,000 --> 00:02:02,000
명령 줄 프로그램에 따라서-C를 지정

36
00:02:02,000 --> 00:02:04,000
당신이 실행하려는 확인합니다.

37
00:02:04,000 --> 00:02:07,000
>> 당신이 실행하려는 테스트는 독특하게이 문자열에 의해 식별됩니다

38
00:02:07,000 --> 00:02:10,000
2012/pset4/resize.

39
00:02:10,000 --> 00:02:13,000
즉, 그냥 임의하지만 고유 한 문자열입니다

40
00:02:13,000 --> 00:02:18,000
우리는 고유 pset 4의 정확성 검사를 식별하는 데 사용하는.

41
00:02:18,000 --> 00:02:21,000
그리고 당신이 업로드 할 파일을 공백으로 구분 목록을 지정

42
00:02:21,000 --> 00:02:24,000
분석을위한 CS50 확인합니다.

43
00:02:24,000 --> 00:02:29,000
예를 들어, 나는 여기를 내 솔루션에 가면 resize.c -

44
00:02:29,000 --> 00:02:31,000
내가 더 큰 터미널 윈도우를 열어

45
00:02:31,000 --> 00:02:42,000
내가 가서 해의를 실행하는 것은 check50-C 2012/pset4/resize는 말

46
00:02:42,000 --> 00:02:46,000
그리고 나는 가서 파일의 이름을 지정합니다

47
00:02:46,000 --> 00:02:49,000
resize.c, 다음, 그 압축, Enter 키를 누르

48
00:02:49,000 --> 00:02:53,000
가 업로드, 그것은 확인하고, 난 그냥 테스트를 왕창 실패했습니다.

49
00:02:53,000 --> 00:02:59,000
왼쪽 상단 붉은 색의 하나는 resize.c와 BMP가 존재 있다고 말한다.

50
00:02:59,000 --> 00:03:01,000
그 테스트했습니다. 우리가 묻는 질문이었다.

51
00:03:01,000 --> 00:03:04,000
답변이 잘못했기 때문에 그리고 행복입니다.

52
00:03:04,000 --> 00:03:08,000
그 아래의 흰색 텍스트가 존재하는 bmp.h 기대라고, 그 단순히 내 잘못이야.

53
00:03:08,000 --> 00:03:11,000
, 내가 업로드하는 걸 잊어 버려서 내가 두 파일을 업로드 할 필요가

54
00:03:11,000 --> 00:03:14,000
resize.c 및 bmp.h.

55
00:03:14,000 --> 00:03:17,000
사람들이 실행되지 않았기 때문에 그러나 지금은 다른 모든 테스트 노란색에를 발견,

56
00:03:17,000 --> 00:03:21,000
그는도 행복도 슬픔이기 때문에 그래서 웃는 얼굴이 수직

57
00:03:21,000 --> 00:03:25,000
그러나 우리는 다른 검사를 실행하기 전에 빨간색으로 그 문제를 교정해야합니다.

58
00:03:25,000 --> 00:03:27,000
>> 내가이 문제를 해결 보자.

59
00:03:27,000 --> 00:03:30,000
또한 bmp.h와 함께, 제가 축소이를 다시 실행이 시간을 보자

60
00:03:30,000 --> 00:03:34,000
모두가 잘되면 명령 줄에서 지금 입력하고

61
00:03:34,000 --> 00:03:38,000
당신의 홀드 결과를 확인하고 반환하는거야 숨을 -

62
00:03:38,000 --> 00:03:42,000
지금까지 pset 4 정말 잘하고있어 의미 모두 녹색.

63
00:03:42,000 --> 00:03:44,000
여기를보고 설명 텍스트에서 추측 할 수

64
00:03:44,000 --> 00:03:47,000
우리가 테스트를 정확히.

65
00:03:47,000 --> 00:03:49,000
우리는 먼저 파일이 존재 테스트?

66
00:03:49,000 --> 00:03:51,000
우리는 resize.c 컴파일을 수행 테스트?

67
00:03:51,000 --> 00:03:58,000
그런 다음 우리는 N, 크기 조정 계수가 1 인 경우는 1x1 픽셀 BMP의 크기를 변경하지 않습니다 테스트.

68
00:03:58,000 --> 00:04:01,000
당신이 N이 뭔지는 전혀 감이 없다면, 당신은 일단, pset (4) 내로 잠수합니다

69
00:04:01,000 --> 00:04:04,000
하지만 그건 단순히 크​​기를 조정하지 있는지 확인하기 위해 정신 검사입니다

70
00:04:04,000 --> 00:04:08,000
크기 조정 계수가 1이면 전혀 이미지입니다.

71
00:04:08,000 --> 00:04:14,000
반면, 제대로 2x2로 1x1 픽셀 BMP로 1x1 픽셀 크기를 조절하는 경우

72
00:04:14,000 --> 00:04:19,000
n은 2 때 다음 비슷하게, 나의 따라 형성한다.

73
00:04:19,000 --> 00:04:22,000
>> 즉, 이것은 하나에 의미, 횡단 손가락을

74
00:04:22,000 --> 00:04:25,000
바로 전에 방정식의 밖으로 pset를 제출합니다.

75
00:04:25,000 --> 00:04:28,000
당신은 당신 TF 곧 알 수 정확히 알 수

76
00:04:28,000 --> 00:04:30,000
당신은 이러한 문제 세트의 일부를 제출하는 방법을 갈 때,

77
00:04:30,000 --> 00:04:34,000
또한 교육학 동기 넣어 정말

78
00:04:34,000 --> 00:04:37,000
당신이 사전에 알 수 있도록 당신의 앞에있는 기회

79
00:04:37,000 --> 00:04:39,000
코드에서 버그와 전달되지 않을 테스트는있을거야

80
00:04:39,000 --> 00:04:43,000
당신은 그 문제를 해결하기 위해 눈 앞에 더 효과적인 시간에 넣을 수 있습니다

81
00:04:43,000 --> 00:04:45,000
포인트를 잃게보다는, 당신의 TF의 의견을

82
00:04:45,000 --> 00:04:48,000
그리고 그 알아 낸 것처럼 "아"를 이동합니다.

83
00:04:48,000 --> 00:04:50,000
지금 적어도 당신이 그렇게을 찾는 데 도움이되는 도구가 있습니다.

84
00:04:50,000 --> 00:04:52,000
그것은 버그가 어디에 지적하지 않을거야,하지만 당신을 알려줍니다

85
00:04:52,000 --> 00:04:54,000
그것의 증상 일 수 있습니다.

86
00:04:54,000 --> 00:04:57,000
>> 이제 시험이 반드시 철저한하지 않습니다 알고 있습니다.

87
00:04:57,000 --> 00:04:59,000
당신은 녹색 웃는 얼굴 전체 화면을해서

88
00:04:59,000 --> 00:05:02,000
코드가 완벽한 의미하지 않습니다,하지만 의미

89
00:05:02,000 --> 00:05:06,000
이 사양에 의해 규정 특정 테스트를 통과했다고.

90
00:05:06,000 --> 00:05:08,000
때때로 우리는 수표를 공개하지 않습니다.

91
00:05:08,000 --> 00:05:10,000
예를 들어, 추리 소설, pset (4)의 측면 중 하나

92
00:05:10,000 --> 00:05:15,000
우리는 당신에게 실망 종류의를 제공하는 경우

93
00:05:15,000 --> 00:05:18,000
그게 뭘하고 공개하는 방법에는 여러가지가 아니라 답변

94
00:05:18,000 --> 00:05:21,000
사람은 붉은 색 노이즈에 사람입니다.

95
00:05:21,000 --> 00:05:24,000
사양은 항상 pset 5 이후의 미래에 지정합니다

96
00:05:24,000 --> 00:05:26,000
당신을 위해 존재를 확인합니다 무엇.

97
00:05:26,000 --> 00:05:28,000
당신은 맨 아래에있는 흰색 URL가 표시됩니다.

98
00:05:28,000 --> 00:05:30,000
지금이 바로 진단 결과입니다.

99
00:05:30,000 --> 00:05:33,000
해당 URL을 방문 할 경우, 당신은 미쳤어, 암호화 된 메시지의 전체 무리 가져올 게

100
00:05:33,000 --> 00:05:36,000
당신은을 통해 볼 수는 있습니다하지만 직원 대부분이라고

101
00:05:36,000 --> 00:05:41,000
그래서 우리는 진단하고 check50 자체에 버그를 디버깅 할 수 있는지 확인하십시오.

102
00:05:41,000 --> 00:05:46,000
>> ADO없이,의 우리가 그만 둔 곳으로 이동하세요.

103
00:05:46,000 --> 00:05:48,000
일부 주 동안 부여를 위해 우리가했다 CS50 도서관,

104
00:05:48,000 --> 00:05:52,000
하지만 지난 주, 우리는 그것의 레이어 중 하나를 다시 필링 시작했다.

105
00:05:52,000 --> 00:05:55,000
우리는 대신에 무엇을 찬성 문자열을 따로 넣어 시작?

106
00:05:55,000 --> 00:05:57,000
[학생] 문자.

107
00:05:57,000 --> 00:05:59,000
항상 숯불 * 된 문자 *,,

108
00:05:59,000 --> 00:06:03,000
지금 우리는 실제 데이터 형식 문자열입니다 척 할 필요가 없습니다.

109
00:06:03,000 --> 00:06:06,000
오히려,이, 숯불 *에 대한 종류의 동의어있었습니다

110
00:06:06,000 --> 00:06:09,000
그리고 문자열은 문자의 순서입니다

111
00:06:09,000 --> 00:06:14,000
그래서 왜 숯불 * S로 문자열을 표현하기 위해 이해합니까?

112
00:06:14,000 --> 00:06:20,000
숯불 *는 문자열이 개념의 맥락에서 무엇을 나타 냅니까?

113
00:06:20,000 --> 00:06:23,000
그래. >> [학생]의 첫 번째 문자입니다.

114
00:06:23,000 --> 00:06:25,000
좋아, 첫 번째 문자는 아니지만 매우 첫 번째 문자입니다.

115
00:06:25,000 --> 00:06:27,000
이-[학생] 주소입니다.

116
00:06:27,000 --> 00:06:29,000
좋아, 첫 번째 문자의 주소입니다.

117
00:06:29,000 --> 00:06:33,000
컴퓨터의 메모리에 문자열을 표현하기 위해 필요 모든

118
00:06:33,000 --> 00:06:36,000
단지 매우 첫 번째 바이트의 고유 한 주소입니다.

119
00:06:36,000 --> 00:06:38,000
당신은 얼마나 오래 알 필요는 없습니다

120
00:06:38,000 --> 00:06:42,000
어떻게 동적으로 그 방법을 찾아 내야 할 수 있기 때문에?

121
00:06:42,000 --> 00:06:44,000
[학생] 문자열의 길이.

122
00:06:44,000 --> 00:06:48,000
당신은 문자열 길이, 훌륭한,하지만 어떻게 문자열 길이 작동합니까를 호출 할 수 있습니다?

123
00:06:48,000 --> 00:06:50,000
는 무엇입니까? 그래.

124
00:06:50,000 --> 00:06:52,000
[학생] 당신은 당신의 널 문자를 얻을 때까지 계속 해요.

125
00:06:52,000 --> 00:06:54,000
네, 정확히, 그냥 동안 루프, 루프와 반복

126
00:06:54,000 --> 00:06:57,000
*에서 끝으로 무엇이든, 끝하는 것은 표현

127
00:06:57,000 --> 00:07:01,000
\ 0으로, 소위 빵점 문자 빵점,

128
00:07:01,000 --> 00:07:05,000
포인터가 널 (null),과 혼동 할 수 없습니다

129
00:07:05,000 --> 00:07:07,000
이는 오늘날 다시 대화에 올 것이다.

130
00:07:07,000 --> 00:07:11,000
>> , 우리는 다시 GetInt의 층을 벗겨, 그리고 나서 우리는 GetString를 살펴 봤네

131
00:07:11,000 --> 00:07:14,000
그리고 그 그 기능을 모두, 또는 정말 기억

132
00:07:14,000 --> 00:07:18,000
GetString, 특정 기능을 사용했습니다

133
00:07:18,000 --> 00:07:21,000
실제로 구문 분석,,, 사용자의 입력을 읽거나 분석하게된다.

134
00:07:21,000 --> 00:07:25,000
그리고 새로운 기능은 무엇입니까?

135
00:07:25,000 --> 00:07:27,000
Scanf 또는 sscanf. 사실은 몇 가지 다른 맛에 있습니다.

136
00:07:27,000 --> 00:07:31,000
scanf가있어, sscanf있어, fscanf가 있습니다.

137
00:07:31,000 --> 00:07:35,000
지금은하지만, 어디 하나 가장 쉽게 설명에 초점을 맞춰 보자

138
00:07:35,000 --> 00:07:38,000
이 날 진행하고 어플라이언스에서 열어

139
00:07:38,000 --> 00:07:41,000
이 같은 파일 scanf1.c.

140
00:07:41,000 --> 00:07:43,000
이것은 슈퍼 간단한 프로그램입니다

141
00:07:43,000 --> 00:07:46,000
하지만 그게 우리가 본적이 없어요 일을 수행

142
00:07:46,000 --> 00:07:48,000
CS50 라이브러리의 도움없이.

143
00:07:48,000 --> 00:07:51,000
이 사용자로부터 정수를 얻을 수 있습니다. 어떻게 작동합니까?

144
00:07:51,000 --> 00:07:53,000
음, 행이 16,

145
00:07:53,000 --> 00:07:56,000
우리가 정수라고 x를 선언하는 것을, 그리고 그 이야기의이 시점에서,

146
00:07:56,000 --> 00:07:58,000
x의 값은 무엇인가?

147
00:07:58,000 --> 00:08:00,000
[안 들리게 학생 응답]

148
00:08:00,000 --> 00:08:02,000
[데이비드 M.]는 오른쪽, 누가 알아, 일부 쓰레기 값이 될 가능성이 있으므로 17에, 우리는 사용자에게

149
00:08:02,000 --> 00:08:06,000
제발, 나에게 전화 번호를 알려하고, 지금부터가 진짜 재미있는 부분 단계 18입니다.

150
00:08:06,000 --> 00:08:11,000
Scanf는 따옴표에서 이러한 형식의 코드를 사용하는 점에서 printf에서 아이디어를 빌려 보인다.

151
00:08:11,000 --> 00:08:13,000
% d 개는 물론 10 진수입니다.

152
00:08:13,000 --> 00:08:21,000
하지만 내가 왜 & X 대신 단지 X에서 합격 이유는 무엇입니까?

153
00:08:21,000 --> 00:08:24,000
전이 정확합니다. 그래.

154
00:08:24,000 --> 00:08:26,000
[안 들리게 학생 응답]

155
00:08:26,000 --> 00:08:31,000
맞아요, 경우이 프로그램의 목적, 기능 GetInt 자체처럼,

156
00:08:31,000 --> 00:08:34,000
사용자의 정수를 얻을 나는 기능을 전달할 수있다

157
00:08:34,000 --> 00:08:38,000
모든 변수는 내가 원하는,하지만 난 참조하여 합격하지 않은 경우

158
00:08:38,000 --> 00:08:41,000
또는 포인터 주소를하거나, 오늘의 목적에 대한 모든 동의어,

159
00:08:41,000 --> 00:08:46,000
해당 기능은 해당 변수의 내용을 변경 할 능력이 없습니다.

160
00:08:46,000 --> 00:08:49,000
이것은 단지 스왑 버그 버전의 같은 사본에 통과 것

161
00:08:49,000 --> 00:08:51,000
우리는 이제 몇 번 얘기를 한.

162
00:08:51,000 --> 00:08:54,000
>> 대신, 일 및 X가, 실은 무엇에 전달 돼?

163
00:08:54,000 --> 00:08:57,000
[학생] 주소. x의 주소를 >>.

164
00:08:57,000 --> 00:09:01,000
그것은 scanf라는 함수에 대한지도를 그리기 여기 말하는 것과 같 잖아요

165
00:09:01,000 --> 00:09:04,000
이것들은 컴퓨터의 메모리 덩어리에 약도가 있어요

166
00:09:04,000 --> 00:09:07,000
당신이 꼭 어떤 정수를 저장할 갈 수 있다는

167
00:09:07,000 --> 00:09:10,000
위해 sscanf를 위해 지금 그렇게 할 수

168
00:09:10,000 --> 00:09:13,000
어떤 연산자, 문법 어떤 부분이 사용하려고합니다

169
00:09:13,000 --> 00:09:19,000
다른 사람이이 기능을 쓴 있기 때문에 우리는 그것을 볼 수없는 경우에도?

170
00:09:19,000 --> 00:09:21,000
즉 - 그게 뭔데?

171
00:09:21,000 --> 00:09:23,000
[학생] X 읽어보십시오.

172
00:09:23,000 --> 00:09:27,000
몇 가지 읽기 수있을거야,하지만이 X에 관한있어.

173
00:09:27,000 --> 00:09:30,000
scanf는 X의 주소를 전달하는 경우는,

174
00:09:30,000 --> 00:09:35,000
통 사적으로, 어떤 연산자는 어딘가에 존재하는 바인딩

175
00:09:35,000 --> 00:09:38,000
내부 scanf의 구현의 때문에 scanf

176
00:09:38,000 --> 00:09:42,000
실제로 해당 주소로 숫자 2를 쓸 수 있나요?

177
00:09:42,000 --> 00:09:44,000
그래, *.

178
00:09:44,000 --> 00:09:47,000
*은 기본적으로 거기에 갈 수 있다는 우리의 역 참조 연산자, 즉 기억합니다.

179
00:09:47,000 --> 00:09:50,000
>> 경우는 여기로 후에는, 주소를 넘겨 봤는데

180
00:09:50,000 --> 00:09:53,000
scanf는 우리가 실제로는 원본을 둘러 보았다됩니다 아마도 경우 코드

181
00:09:53,000 --> 00:09:59,000
* X 또는 실제로 그 주소로 가서, 거기서 좀 값을 넣어 동등한을 다하고 있습니다.

182
00:09:59,000 --> 00:10:02,000
지금과 같은 scanf는 키보드에서 입력을 도착 방법에 대한,

183
00:10:02,000 --> 00:10:04,000
우리는 오늘 우리의 손을 흔들 수 있습니다.

184
00:10:04,000 --> 00:10:07,000
그냥 운영 체제가 얘기 할 sscanf 수 있다고 가정

185
00:10:07,000 --> 00:10:11,000
사용자의 키보드, 지금 라인 (19)이 시점에서,

186
00:10:11,000 --> 00:10:14,000
우리가 단순히 X를 인쇄 할 때, 그것은 경우 것 같다

187
00:10:14,000 --> 00:10:17,000
그 scanf는 x에 정수를 넣어있다.

188
00:10:17,000 --> 00:10:19,000
그게 바로 scanf가 어떻게 작동하는지, 그리고 지난 주 기억

189
00:10:19,000 --> 00:10:25,000
그게 정확히 어떻게 GetString 및 GetInt와 기능의 다른 가족

190
00:10:25,000 --> 00:10:28,000
궁극적으로, sscanf와 같은 약간의 변화와 함께이라도 작동

191
00:10:28,000 --> 00:10:31,000
하는 대신 키보드의 문자열을 스캔을 의미합니다.

192
00:10:31,000 --> 00:10:33,000
그러나가이 작은 차이를 살펴 보자.

193
00:10:33,000 --> 00:10:37,000
scanf2에서, 사실은 실패 했어.

194
00:10:37,000 --> 00:10:42,000
무슨 문제 - 그리고 나는 설명으로 많이를 주석들을 숨기 겠어

195
00:10:42,000 --> 00:10:47,000
버전 2는이 프로그램과 함께 도대체 뭐가 문제 야?

196
00:10:47,000 --> 00:10:55,000
이 시간 가능한 기술한다.

197
00:10:55,000 --> 00:10:57,000
그것은 아주 잘 보입니다.

198
00:10:57,000 --> 00:11:03,000
그것은 잘 들여 쓰기,하지만 -있어

199
00:11:03,000 --> 00:11:07,000
좋아, 방법에 대한의는 짧은 질문에 내려 치기 까?

200
00:11:07,000 --> 00:11:17,000
선 16. 정확한 그러나 기술적 인 영어로하는 선 (16)는 무엇입니까?

201
00:11:17,000 --> 00:11:20,000
조금 어색한 것 뿐이야. 예, 마이클.

202
00:11:20,000 --> 00:11:25,000
[학생] 그것은 문자열의 첫 글자를 가리키는있어.

203
00:11:25,000 --> 00:11:27,000
>> 좋아요, 가까이. 저 조금 조정할 보자.

204
00:11:27,000 --> 00:11:33,000
문자열의 첫 글자를 가리키는, 당신은라는 변수 버퍼를 확정되었습니다

205
00:11:33,000 --> 00:11:36,000
즉, 문자열의 첫 번째 주소로 연결됩니다

206
00:11:36,000 --> 00:11:39,000
또는 오히려, 그게 더 구체적으로 숯불로 연결됩니다.

207
00:11:39,000 --> 00:11:42,000
더 할당 연산자가 없기 때문에 실제로 어느 가리 안납니다.

208
00:11:42,000 --> 00:11:46,000
더 등호이 없다, 우리가하는 모든 변수 호출 버퍼를 할당집니다.

209
00:11:46,000 --> 00:11:49,000
이 포인터이기 때문에 그것은 32 비트에서 일어나는

210
00:11:49,000 --> 00:11:52,000
와 버퍼의 내용을 아마 결국

211
00:11:52,000 --> 00:11:57,000
문자의 주소를 포함 할 것입니다하지만 지금은, 버퍼에 포함 된 무엇입니까?

212
00:11:57,000 --> 00:11:59,000
그냥 가짜는 누가 알아, 일부 쓰레기 값,

213
00:11:59,000 --> 00:12:03,000
우리가 명시 적으로 초기화하지 않았기 때문에, 그래서 우리는 아무 것도 가정해서는 안됩니다.

214
00:12:03,000 --> 00:12:06,000
그럼 이제 라인 17 - 어떻게되어 줄 17하나요?

215
00:12:06,000 --> 00:12:08,000
어쩌면 그게이 일을 따뜻하게합니다.

216
00:12:08,000 --> 00:12:10,000
그것은 바로, 문자열을 인쇄?

217
00:12:10,000 --> 00:12:12,000
이 문자열하시기 바랍니다 출력합니다.

218
00:12:12,000 --> 00:12:15,000
>> 라인 18 우리가이 차이를 본 지금의 친숙한 종류의 것입니다

219
00:12:15,000 --> 00:12:18,000
하지만 다른 형식의 코드를, 그래서 라인 18에,

220
00:12:18,000 --> 00:12:23,000
우리가 여기서 scanf을 말하는지는 메모리의 청크의 주소입니다.

221
00:12:23,000 --> 00:12:27,000
당신이로 % s에서 암시, 문자열에 전화 해달라고

222
00:12:27,000 --> 00:12:32,000
하지만 문제는 우리가 여기서 몇 가지만하지 않은 것입니다.

223
00:12:32,000 --> 00:12:35,000
문제 중 하나는 무엇입니까?

224
00:12:35,000 --> 00:12:38,000
[학생] 그것은 역 참조에 null 포인터를하려고합니다.

225
00:12:38,000 --> 00:12:41,000
좋아, 널 (null) 또는 기타 알 수없는 포인터.

226
00:12:41,000 --> 00:12:45,000
당신은 scanf에게 주소를주고 있지만 당신은 좀 전에 말

227
00:12:45,000 --> 00:12:49,000
우리가 실제로 아무것도에 할당하지 않았기 때문에 해당 주소 일부 쓰레기 값입니다

228
00:12:49,000 --> 00:12:53,000
그리고 당신은 scanf를 효과적으로 여기에 문자열을 넣어 갈 건가

229
00:12:53,000 --> 00:12:56,000
아직 여기 어디에 우리는 몰라

230
00:12:56,000 --> 00:12:59,000
그래서 우리는 실제로 버퍼에 대한 메모리를 할당하지 않았습니다.

231
00:12:59,000 --> 00:13:03,000
또한, 당신은 심지어 scanf를 말하지 않은 또 뭐야?

232
00:13:03,000 --> 00:13:06,000
이 메모리의 덩어리 였고, 그, 쓰레기 값이 아닙니다 겠지

233
00:13:06,000 --> 00:13:09,000
하지만 당신은 여전히​​ scanf 중요한 무언가를 이야기하지 않았 소.

234
00:13:09,000 --> 00:13:12,000
[학생] 실제로 어디에, 앰퍼샌드.

235
00:13:12,000 --> 00:13:15,000
앰퍼샌드,이 경우에, 괜찮아.

236
00:13:15,000 --> 00:13:18,000
버퍼가 이미 포인터로 선언되어 있기 때문에

237
00:13:18,000 --> 00:13:22,000
구문의 * 기사와 함께, 우리는 앰퍼샌드를 사용할 필요가 없습니다

238
00:13:22,000 --> 00:13:25,000
때문에 이미 주소하지만 난 여기에 들었어 생각합니다.

239
00:13:25,000 --> 00:13:27,000
[학생] 크기가 얼마나 돼요?

240
00:13:27,000 --> 00:13:29,000
좋아, 우리는,이 버퍼가 얼마나 큰 scanf를 이야기하지 않았

241
00:13:29,000 --> 00:13:32,000
그 때문에 버퍼 포인터이라도 의미

242
00:13:32,000 --> 00:13:35,000
우리는, scanf 말을 여기에 문자열을 넣어하는

243
00:13:35,000 --> 00:13:38,000
하지만 여기에 2 바이트가 될 수는 10 바이트가 될 수는 메가 바이트가 될 수 있습니다.

244
00:13:38,000 --> 00:13:41,000
Scanf 아무 생각이 없다,이 메모리의 덩어리이기 때문에

245
00:13:41,000 --> 00:13:43,000
아마, 아직 문자열이 아닙니다.

246
00:13:43,000 --> 00:13:48,000
당신은 문자와 메모리의 청크에 \ 0을 쓸 일단은 문자열입니다.

247
00:13:48,000 --> 00:13:51,000
지금은 그냥 메모리의 일부 덩어리입니다.

248
00:13:51,000 --> 00:13:55,000
Scanf는 주소로 편지를 멈출 때를 알 수 없습니다.

249
00:13:55,000 --> 00:13:59,000
>> 당신은 내가 무작위로 키보드에서 입력 한 과거에 몇 가지 예제를 기억하는 경우

250
00:13:59,000 --> 00:14:03,000
오버 플로우 버퍼를에 노력하고, 우리는 정확히 그 얘기 금요일 했어요.

251
00:14:03,000 --> 00:14:07,000
상대는 어떻게 든 여러분의 프로그램에 훨씬 더 큰 단어를 삽입하는 경우

252
00:14:07,000 --> 00:14:10,000
또는 문장이나 구문 그런 다음 당신은 오버런 수 있습니다 기대했던

253
00:14:10,000 --> 00:14:13,000
나쁜 결과를 가질 수 있습니다 메모리의 덩어리,

254
00:14:13,000 --> 00:14:15,000
전체 프로그램 자체 인계처럼.

255
00:14:15,000 --> 00:14:17,000
우리는 어떻게 든이 문제를 해결해야합니다.

256
00:14:17,000 --> 00:14:20,000
나 축소하고이 프로그램의 버전 3으로 가자.

257
00:14:20,000 --> 00:14:22,000
그건 조금 낫다.

258
00:14:22,000 --> 00:14:24,000
이 버전에서는, 그 차이를 확인합니다.

259
00:14:24,000 --> 00:14:27,000
라인 16에서, 다시,라는 변수 버퍼를 선언 했어

260
00:14:27,000 --> 00:14:29,000
하지만 지금은 무엇입니까?

261
00:14:29,000 --> 00:14:33,000
이 16 문자의 배열입니다.

262
00:14:33,000 --> 00:14:36,000
지금 scanf 말할 수 의미하기 때문에이 좋다

263
00:14:36,000 --> 00:14:39,000
여기에 메모리의 실제 덩어리입니다.

264
00:14:39,000 --> 00:14:42,000
당신은 거의 지금 포인터하다고 배열을 생각할 수

265
00:14:42,000 --> 00:14:44,000
실제로 동등한하지 않더라도.

266
00:14:44,000 --> 00:14:47,000
그들은 서로 다른 상황에서 다르게 행동합니다.

267
00:14:47,000 --> 00:14:50,000
그러나 확실히 버퍼가 참조되는 경우입니다

268
00:14:50,000 --> 00:14:53,000
16 연속 문자 그게 무슨 배열되어 있기 때문에

269
00:14:53,000 --> 00:14:55,000
지금 몇 주 동안있다.

270
00:14:55,000 --> 00:14:59,000
>> 여기, 여기 scanf을 말해 줄려고하면 메모리의 덩어리입니다.

271
00:14:59,000 --> 00:15:01,000
이번에는, 사실은 메모리의 덩어리입니다

272
00:15:01,000 --> 00:15:07,000
하지만 왜이 프로그램은 여전히​​ 악용입니까?

273
00:15:07,000 --> 00:15:11,000
아직 무슨 일이야?

274
00:15:11,000 --> 00:15:14,000
나는 나에게 16 바이트 만 -을 제공 말했듯이

275
00:15:14,000 --> 00:15:16,000
[학생] 그들이 이상 16 입력하면?

276
00:15:16,000 --> 00:15:20,000
정확히 어떤 17 자 또는 1700 문자로 사용자가 형식면?

277
00:15:20,000 --> 00:15:23,000
사실, 지금 우리가 실수여 여행이 아니라 가능하면 보자.

278
00:15:23,000 --> 00:15:25,000
그것은 더 나은하지만, 완벽하지입니다.

279
00:15:25,000 --> 00:15:28,000
내가 가서이 프로그램을 컴파일 scanf3을 실행할 수 있습니다.

280
00:15:28,000 --> 00:15:34,000
안녕하세요, 우리는 괜찮을 것 같습니다 : 문자열, 제가 scanf3를 실행하십시오 보자.

281
00:15:34,000 --> 00:15:37,000
저 안녕하세요, 약간 이상을 시도해 보자.

282
00:15:37,000 --> 00:15:42,000
좋아요, 입력 오늘은 어떠세요, 안녕하세요 해보자.

283
00:15:42,000 --> 00:15:54,000
여기 운의 종류를 얻기 시작하자 어떻게 당신이 거기에 인사.

284
00:15:54,000 --> 00:15:56,000
젠장.

285
00:15:56,000 --> 00:16:03,000
좋아, 그럼 우리는 운이 좋았 군. 우리가이 문제를 해결할 수없는 경우 봅시다.

286
00:16:03,000 --> 00:16:06,000
아니, 나 복사 용납 할 수 없어.

287
00:16:06,000 --> 00:16:09,000
가 다시 해 보자.

288
00:16:09,000 --> 00:16:12,000
좋아, 대기하라.

289
00:16:12,000 --> 00:16:20,000
우리는 아직이 일을하는 동안 초점을 척 시간을 볼 수 있습니다.

290
00:16:20,000 --> 00:16:23,000
젠장. 그 사실은, 오히려 적절한입니다.

291
00:16:23,000 --> 00:16:26,000
우리는 간다.

292
00:16:26,000 --> 00:16:30,000
포인트했다.

293
00:16:30,000 --> 00:16:34,000
>> 이, 이건 또한 비록 창피하게, 또한 큰 혼란의 근원 중 하나입니다

294
00:16:34,000 --> 00:16:38,000
그들 자신을 되는거야 때문에 버그가 프로그램을 작성할 때

295
00:16:38,000 --> 00:16:40,000
한 번만 가끔 가죠.

296
00:16:40,000 --> 00:16:43,000
현실은, 심지어 코드가 완전히 깨진 경우 것입니다

297
00:16:43,000 --> 00:16:46,000
그는 완전히 가끔 끊어 될 수 있습니다

298
00:16:46,000 --> 00:16:49,000
때때로, 본질적으로 어떤 일이 생기하면 운영 체제를 할당하기 때문에

299
00:16:49,000 --> 00:16:52,000
당신보다 조금 더 많은 메모리는 실제로 어떤 이유로 필요

300
00:16:52,000 --> 00:16:57,000
그리고 다른 사람 말이 맞아, 16 자의 덩어리 후에 메모리를 사용하지 않습니다

301
00:16:57,000 --> 00:17:01,000
당신은 17, 18, 19,간에, 이러한 큰 문제가 아닌가요로 이동 그렇게하십시오.

302
00:17:01,000 --> 00:17:04,000
이제 컴퓨터가 그 시점에 충돌하지 않는 경우에도,

303
00:17:04,000 --> 00:17:09,000
결국 다른 무언가를 바이트 17 또는 18 19 사용할 수 있습니다,

304
00:17:09,000 --> 00:17:14,000
되는 것은 지나치게 긴이라도 당신이 거기 넣은 데이터를 가리

305
00:17:14,000 --> 00:17:18,000
다른 함수에 의해 잠재적으로 덮어 얻을 수 있습니다.

306
00:17:18,000 --> 00:17:21,000
그것은 반드시 그대로 유지하지 않을거야

307
00:17:21,000 --> 00:17:23,000
하지만 반드시 감금 오류가 발생하지 않습니다.

308
00:17:23,000 --> 00:17:26,000
그러나이 경우에는 드디어 충분한 문자를 제공

309
00:17:26,000 --> 00:17:29,000
나는 본질적으로, 메모리 내 세​​그먼트를 초과하고, 빵 것을

310
00:17:29,000 --> 00:17:33,000
운영 체제는 "죄송 해요, 더 좋은 세분화 잘못이 없다"고 말했다.

311
00:17:33,000 --> 00:17:38,000
>> 그리고 내 안에 남아있는 경우 지금 보자 디렉토리 -

312
00:17:38,000 --> 00:17:40,000
내가 여기 핵심이 파일이 있는지 확인합니다.

313
00:17:40,000 --> 00:17:42,000
이 다시 코어 덤프라고 것을 확인할 수 있습니다.

314
00:17:42,000 --> 00:17:46,000
그것은 본질적으로 프로그램의 메모리의 내용을 포함하는 파일입니다

315
00:17:46,000 --> 00:17:48,000
가 추락하는 시점에서,

316
00:17:48,000 --> 00:17:51,000
여기로 약간의 예를하려고 나를 여기에 보내

317
00:17:51,000 --> 00:17:57,000
그리고 핵심이라는 세 번째 인수를 지정 후 scanf3에 gdb를 실행하고

318
00:17:57,000 --> 00:18:01,000
여기 것을 내가 그 코드를 나열하면,

319
00:18:01,000 --> 00:18:06,000
우리는이 프로그램을 통해 도보로 시작하는 gdb를 평소와 같이 할 수 있습니다

320
00:18:06,000 --> 00:18:10,000
그리고 나는대로 치 등의 단계 명령을 즉시 실행 할 수 gdb를 -

321
00:18:10,000 --> 00:18:13,000
나는 큰 문자열을 입력 한 후, 잠재적 인 버그가 줄을 치 자마자

322
00:18:13,000 --> 00:18:16,000
사실 여기를 식별 할 수 있습니다.

323
00:18:16,000 --> 00:18:19,000
더이에,하지만 핵심 덤프의 관점에서 섹션에서

324
00:18:19,000 --> 00:18:22,000
그리고 실제로 코어 덤프 내부 주변 찌른 할 수 있도록 좋아

325
00:18:22,000 --> 00:18:27,000
그리고 프로그램이 실패 어떤 라인에서 참조하십시오.

326
00:18:27,000 --> 00:18:32,000
포인터에 및 주소에 대한 다음 질문?

327
00:18:32,000 --> 00:18:36,000
에서 오늘 때문에, 우리는 이러한 일들이 존재한다는 당연한 나타나기 시작 할거야

328
00:18:36,000 --> 00:18:40,000
우리는 그것들이 정확히 알지.

329
00:18:40,000 --> 00:18:42,000
예.

330
00:18:42,000 --> 00:18:46,000
>> [학생] 어떻게 옆에 앰퍼샌드를 뿌리지도 않았는데 올 파트

331
00:18:46,000 --> 00:18:48,000
좋은 질문입니다.

332
00:18:48,000 --> 00:18:51,000
어떻게 내가 이전에했던 것처럼 문자 배열 옆에 앰퍼샌드를 뿌리지도 않았는데 올

333
00:18:51,000 --> 00:18:53,000
우리 예제의 대부분과?

334
00:18:53,000 --> 00:18:55,000
짧은 대답은 배열이 좀 특별합니다.

335
00:18:55,000 --> 00:18:59,000
당신은 거의 실제 주소로서 버퍼를 생각할 수

336
00:18:59,000 --> 00:19:03,000
그리고 너무 경우로 그런 일이 일어날 대괄호 표기법

337
00:19:03,000 --> 00:19:06,000
우리가 브래킷 0, 받침대 1로 이동 할 수 있도록 편의를합니다

338
00:19:06,000 --> 00:19:10,000
* 기호를 사용하지 않고도 브래킷 2.

339
00:19:10,000 --> 00:19:13,000
이게 바로 백인 거짓말의 일부분 때문에 배열과 포인터

340
00:19:13,000 --> 00:19:17,000
사실 조금 다릅니다 만, 종종 있지만 항상 상호 교환 사용할 수 있습니다.

341
00:19:17,000 --> 00:19:21,000
한마디로, 함수의 메모리 덩어리에 대한 포인터를 기다리고 때,

342
00:19:21,000 --> 00:19:24,000
당신도 그것을 malloc에​​ 의해 반환 된 주소를 전달할 수 있습니다

343
00:19:24,000 --> 00:19:29,000
우리는 머지 않아 다시 malloc를 볼 수 있습니다, 또는 당신은 그것을 배열의 이름을 전달할 수 있습니다.

344
00:19:29,000 --> 00:19:32,000
이미이기 때문에 배열 앰퍼샌드를 할 필요가 없습니다

345
00:19:32,000 --> 00:19:34,000
본질적으로 주소를 좋아해요.

346
00:19:34,000 --> 00:19:36,000
한 가지 예외는 있습니다.

347
00:19:36,000 --> 00:19:39,000
대괄호 그들에게 특별합니다.

348
00:19:39,000 --> 00:19:41,000
>> 당신은 버퍼 옆에 앰퍼샌드를 넣어 수 있나요?

349
00:19:41,000 --> 00:19:43,000
하지만 이번 케이스는 아니군요.

350
00:19:43,000 --> 00:19:46,000
그래서이 코너 케이스 때문에 다시 동작하지 않을 것이다

351
00:19:46,000 --> 00:19:49,000
위치 배열은 매우 실제 주소가 아닙니다.

352
00:19:49,000 --> 00:19:54,000
하지만 우리는 아마 다른 예제 랑 오래 전부터으로 돌아올 거예요.

353
00:19:54,000 --> 00:19:56,000
의는 여기에 문제를 해결하려고 봅시다.

354
00:19:56,000 --> 00:20:00,000
우리는 배열로 알려져 얼마 동안 사용하고있는 데이터 구조를 갖추고 있습니다.

355
00:20:00,000 --> 00:20:02,000
점에서 사례, 그게 우리가했던 일이야.

356
00:20:02,000 --> 00:20:04,000
그러나 배열은 몇 가지 나름의​​ 매력과 단점이 있습니다.

357
00:20:04,000 --> 00:20:06,000
배열은 좋은 이유는 무엇인가요?

358
00:20:06,000 --> 00:20:11,000
당신이 좋아 -에게 한 가지 당신은 배열을 배열 - 좋아하는 범위는 무엇입니까?

359
00:20:11,000 --> 00:20:13,000
어떻게 그들에 대한 편리거야? 눈길을 끄는 무엇입니까?

360
00:20:13,000 --> 00:20:18,000
왜 우리는 처음에 소개 했죠?

361
00:20:18,000 --> 00:20:20,000
그래.

362
00:20:20,000 --> 00:20:27,000
[학생] 그들은 많은 양의 데이터를 저장할 수 있습니다, 그리고 전체 일을 사용할 필요가 없습니다.

363
00:20:27,000 --> 00:20:29,000
당신은 섹션을 사용할 수 있습니다.

364
00:20:29,000 --> 00:20:32,000
좋아, 당신은 많은 양의 데이터를 저장할 수있는 배열로,

365
00:20:32,000 --> 00:20:35,000
그리고, 당신은 반드시 그것을 모두 사용할 필요가 없습니다, 그래서 당신은 overallocate 수

366
00:20:35,000 --> 00:20:39,000
방법을 기대 할 일 많은이 사전에 모른다면 편리 할 수​​도 있습니다.

367
00:20:39,000 --> 00:20:41,000
>> GetString는 완벽한 예입니다.

368
00:20:41,000 --> 00:20:44,000
회사가 작성한 GetString는,,, 기대에 얼마나 많은 문자 아무 생각이 없습니다

369
00:20:44,000 --> 00:20:48,000
저희가 연속 메모리 덩어리를 할당 할 수 있다는 사실은 좋은 것입니다.

370
00:20:48,000 --> 00:20:51,000
배열은 또한 우리가 몇 주 전에 본 문제를 해결

371
00:20:51,000 --> 00:20:54,000
코드가 매우 저조한 설계 무언가로 바뀔하기 시작하는 위치.

372
00:20:54,000 --> 00:20:57,000
, 내가 다윗라는 학생 구조를 만든 기억

373
00:20:57,000 --> 00:21:00,000
그리고 그건하지만 실제로 대안

374
00:21:00,000 --> 00:21:04,000
라는 변수 이름과,​​ 내 생각 엔, 집이라는 또 다른 변수를 갖는까지,

375
00:21:04,000 --> 00:21:08,000
그 이야기에 제가 다른 일을 소개하고 있기 때문에 ID라는 또 다른 변수

376
00:21:08,000 --> 00:21:11,000
프로그램에 롭을 좋아 그래서 내가, 잠깐만 결정

377
00:21:11,000 --> 00:21:13,000
나는 이러한 변수의 이름을 변경해야합니다.

378
00:21:13,000 --> 00:21:16,000
자, 내 NAME1, ID1, house1를 호출합니다.

379
00:21:16,000 --> 00:21:20,000
하자 롭의 NAME2, house2, ID2를 호출합니다.

380
00:21:20,000 --> 00:21:22,000
하지만 무엇 토미 약 1 분을 기다려?

381
00:21:22,000 --> 00:21:24,000
그런 다음 세 이상 변수했다.

382
00:21:24,000 --> 00:21:27,000
우리는 다른 사람, 변수의 4 세트를 소개했다.

383
00:21:27,000 --> 00:21:30,000
세계는 매우 빠른 속도로 혼란스러워 질수 시작

384
00:21:30,000 --> 00:21:33,000
그래서 우리는 structs을 도입, 그리고이 구조체에 대한 독창적 인?

385
00:21:33,000 --> 00:21:39,000
C의 구조체는 당신이 무엇을하게됩니까?

386
00:21:39,000 --> 00:21:42,000
오늘은 정말 어색 있습니다.

387
00:21:42,000 --> 00:21:44,000
왜? >> [안 들리게 학생 응답]

388
00:21:44,000 --> 00:21:47,000
네, 특히, typedef는, 새로운 데이터 형식을 만들 수 있습니다

389
00:21:47,000 --> 00:21:51,000
와 구조체, 구조체 키워드는, 당신이 캡슐화 할 수 있습니다

390
00:21:51,000 --> 00:21:54,000
함께 데이터의 개념과 관련된 조각

391
00:21:54,000 --> 00:21:56,000
그리고 이후 그 학생이 같은 전화하십시오.

392
00:21:56,000 --> 00:21:58,000
>> 이제 우리가 모델링 할 수 있기 때문에 아주 좋았어

393
00:21:58,000 --> 00:22:03,000
변수에 학생의 더 이상 종류의 개념적 일관성 개념

394
00:22:03,000 --> 00:22:07,000
보다는 임의로 등등 문자열에 대해 한 ID에 대해 하나를 갖는합니다.

395
00:22:07,000 --> 00:22:10,000
그들은 우리가 코드를 청소 시작 할 수 있기 때문에 배열은 괜찮습니다.

396
00:22:10,000 --> 00:22:13,000
그런데이 배열의 현재 단점입니까?

397
00:22:13,000 --> 00:22:15,000
당신은 무엇을 할 수없는 이유는 무엇입니까? 그래.

398
00:22:15,000 --> 00:22:17,000
[학생] 당신은 얼마나 큰 알고 있습니다.

399
00:22:17,000 --> 00:22:19,000
당신이 얼마나 넓은 지해야 그 고통의 친절 때문에.

400
00:22:19,000 --> 00:22:21,000
당신의 그 이전 프로그래밍 경험을 알고 언어로 많은에

401
00:22:21,000 --> 00:22:24,000
자바처럼, 당신은 메모리의 덩어리, 특히 배열을 요청할 수 있습니다

402
00:22:24,000 --> 00:22:28,000
얼마나 큰 그렇게 말할 수있는 길이, 재산,와,이고, 그건 정말 편리하다.

403
00:22:28,000 --> 00:22:32,000
C에서는 더 일반적인 배열에 나 strlen을 호출 할 수 없습니다

404
00:22:32,000 --> 00:22:35,000
그 단어의 의미로 나 strlen 있기 때문에, 단지 문자열입니다

405
00:22:35,000 --> 00:22:39,000
당신은이 때문에 인간 협약의 문자열의 길이를 알아낼 수

406
00:22:39,000 --> 00:22:43,000
\ 0 있지만, 배열을 갖는의 더 총칭, 단지 메모리의 덩어리입니다.

407
00:22:43,000 --> 00:22:46,000
이 ints의 배열이라면, 일부 특수 문자가있을 않을거야

408
00:22:46,000 --> 00:22:48,000
끝에서 당신을 기다리고 있습니다.

409
00:22:48,000 --> 00:22:50,000
당신은 배열의 길이를 기억해야합니다.

410
00:22:50,000 --> 00:22:54,000
배열의 또 다른 단점은 그 자체를 GetString에 머리를 쳐.

411
00:22:54,000 --> 00:22:59,000
배열의 또 다른 단점은 무엇입니까?

412
00:22:59,000 --> 00:23:01,000
선생님, 당신과 나 오늘.

413
00:23:01,000 --> 00:23:04,000
[안 들리게 학생 응답] >>은 뭐?

414
00:23:04,000 --> 00:23:06,000
그것은 스택에 선언있어.

415
00:23:06,000 --> 00:23:09,000
좋아요, 스택에 선언했다. 왜 그렇게 맘에 안들어?

416
00:23:09,000 --> 00:23:13,000
[학생] 그것은 재사용됩니다 때문입니다.

417
00:23:13,000 --> 00:23:15,000
이 재사용됩니다.

418
00:23:15,000 --> 00:23:18,000
좋아, 메모리를 할당 할 배열을 사용하는 경우는,

419
00:23:18,000 --> 00:23:21,000
이 스택에이기 때문에 당신은 예를 들어, 그것을 반환 할 수 없습니다.

420
00:23:21,000 --> 00:23:23,000
그래, 그건 단점입니다.

421
00:23:23,000 --> 00:23:25,000
그리고 어떻게 배열과 다른 사람에 대한?

422
00:23:25,000 --> 00:23:28,000
당신이 그것을 할당되면, 당신은 더 많은 공간이 필요하면 가지 끝장 났어

423
00:23:28,000 --> 00:23:30,000
그 배열이보다.

424
00:23:30,000 --> 00:23:34,000
>> 그런 다음 우리는 우리에게 동적으로 메모리를 할당 할 수있는 능력을 준 리콜, malloc을 발표했다.

425
00:23:34,000 --> 00:23:37,000
하지만 우리는 모두 다른 세계를 어떻게하려고한다면?

426
00:23:37,000 --> 00:23:40,000
우리는 이러한 문제의 몇를 해결하기 위해 원하는 경우

427
00:23:40,000 --> 00:23:45,000
그래서 우리는 대신, 내 펜은 여기 잠든있다

428
00:23:45,000 --> 00:23:51,000
우리가 대신 기본적으로 다음과 같이 더 이상없는 세상을 만들기를 원한다면?

429
00:23:51,000 --> 00:23:56,000
이 배열이며, 물론, 이런 종류의, 우리가 배열의 끝을 누르 악화

430
00:23:56,000 --> 00:24:00,000
그리고 지금은 더 이상 다른 정수 또는 다른 문자에 대한 공간이 없습니다.

431
00:24:00,000 --> 00:24:03,000
우리는 종류의 preemptively 잘라고한다면, 왜 우리는 휴식을하지 않습니다 무엇입니까

432
00:24:03,000 --> 00:24:07,000
메모리의 모든 덩어리는 백업으로 돌아 가기 인접 것이 이러한 요구 사항

433
00:24:07,000 --> 00:24:10,000
그리고 왜 정수 또는 문자를 필요로 할 때, 안 그래요,

434
00:24:10,000 --> 00:24:12,000
단지 그들 중 하나에 저에게 공간을주지?

435
00:24:12,000 --> 00:24:14,000
그리고 또 다른 필요로 할 때, 나에게 또 다른 공간을 제공

436
00:24:14,000 --> 00:24:16,000
내가 다른 필요로 할 때, 다른 공간을 제공합니다.

437
00:24:16,000 --> 00:24:19,000
의 장점은 이제 경우 다른 사람입니다

438
00:24:19,000 --> 00:24:21,000
여기에 메모리, 더 큰 거래를 걸립니다.

439
00:24:21,000 --> 00:24:25,000
여기 그리고 이번 메모리의 추가 덩어리를합니다.

440
00:24:25,000 --> 00:24:28,000
>> 자, 여기 만 캐치는 내가 가지고있는 것처럼이 일이 거의 느낌이다

441
00:24:28,000 --> 00:24:30,000
다른 변수의 전체 무리.

442
00:24:30,000 --> 00:24:33,000
이 기능은 다섯 가지 변수 인 것 같아요.

443
00:24:33,000 --> 00:24:36,000
그러나 우리는 문자열에서 무슨 생각을 훔치는 경우

444
00:24:36,000 --> 00:24:41,000
내가이 짓을하면된다 우리는 어떻게 든 개념적 함께 이런 일을 연결, 그 다음엔?

445
00:24:41,000 --> 00:24:44,000
이건 내 매우 저조한 그린 화살표입니다.

446
00:24:44,000 --> 00:24:46,000
그러나 가정 기억의이 덩어리의 각

447
00:24:46,000 --> 00:24:52,000
다른 점을 지적하고,이 사람이, 누가 자신의 오른쪽에 아무런 형제 자매가 없다,

448
00:24:52,000 --> 00:24:54,000
이러한 화살표가 없습니다.

449
00:24:54,000 --> 00:24:56,000
이 연결리스트라는 것을 사실입니다.

450
00:24:56,000 --> 00:25:00,000
이것은 우리의 메모리 덩어리를 할당 할 수있는 새로운 데이터 구조입니다

451
00:25:00,000 --> 00:25:03,000
그리고 또 다른 한 다음 다른 다음, 다른 모든 시간은 우리가 원하는

452
00:25:03,000 --> 00:25:07,000
프로그램 동안, 우리는 그들 모두를 어떻게 든 관련있어 기억

453
00:25:07,000 --> 00:25:11,000
말 그대로 체인으로 같이, 우리는 pictorially 여기에 화살표가있는 것으로 했어요.

454
00:25:11,000 --> 00:25:15,000
그러나 코드에서, 어떻게, 당신은 어떻게 든 연결할 수있는을 통해 메커니즘 것

455
00:25:15,000 --> 00:25:20,000
거의 스크래치 같은, 다른 덩어리 한 덩어리?

456
00:25:20,000 --> 00:25:22,000
우리는 포인터를 마우스 오른쪽 사용할 수 있습니다?

457
00:25:22,000 --> 00:25:25,000
때문에 왼쪽 상단 광장에서 무슨 일 정말 화살표

458
00:25:25,000 --> 00:25:31,000
이 하나 여기이 사람은,이 광장의 안에 포함되어있을 수

459
00:25:31,000 --> 00:25:34,000
그냥 어떤 ints, 그냥 숯불하지,하지만 실제로 할당 된 경우 어떤

460
00:25:34,000 --> 00:25:37,000
그 그래서 지금 약간의 여분의 공간,

461
00:25:37,000 --> 00:25:41,000
이 날 대가를 치르게 될 경우에도 메모리 내 덩어리의 각,

462
00:25:41,000 --> 00:25:45,000
이제 좀 더 직사각형 모양있는 ​​메모리의 덩어리 중 하나

463
00:25:45,000 --> 00:25:47,000
숫자에 사용되며, 숫자 1과 같은,

464
00:25:47,000 --> 00:25:50,000
그리고이 사람은, 숫자 2를 저장하는 경우

465
00:25:50,000 --> 00:25:52,000
메모리의 다른 청크가, 화살에 사용됩니다

466
00:25:52,000 --> 00:25:54,000
이상 구체적으로, 포인터.

467
00:25:54,000 --> 00:25:59,000
그리고,이 그 사람에 가리 키도록 사용하는 동안 나는 여기에 숫자 3을 저장합니다 가정

468
00:25:59,000 --> 00:26:02,000
지금이 사람은, 어디 내가 메모리 만 세 등 덩어리가 필요하다고 가정하자.

469
00:26:02,000 --> 00:26:05,000
I는 null를 나타내는 그 줄을 그릴 수 있습니다.

470
00:26:05,000 --> 00:26:07,000
추가 문자가 없습니다.

471
00:26:07,000 --> 00:26:10,000
>> 사실, 우리가 구현에 대해 갈 수있는 방법입니다

472
00:26:10,000 --> 00:26:12,000
연결된 목록이라는 것을.

473
00:26:12,000 --> 00:26:18,000
연결리스트는 새로운 데이터 구조이며, 대한 디딤돌입니다

474
00:26:18,000 --> 00:26:21,000
문제를 해결하기 위해 시작 많은 애호가 데이터 구조

475
00:26:21,000 --> 00:26:23,000
페이스 북 형 문제의 라인 및 Google 형 문제 함께

476
00:26:23,000 --> 00:26:26,000
당신은 거대한 데이터 세트를 가지고 있고, 그걸 잘라하지 않습니다 곳

477
00:26:26,000 --> 00:26:29,000
contiguously 모든 저장하고 선형 검색과 같은 무언가를 사용하는

478
00:26:29,000 --> 00:26:31,000
이진 검색과 같은 또는 무언가.

479
00:26:31,000 --> 00:26:33,000
당신이 더 실행 시간을 싶습니다.

480
00:26:33,000 --> 00:26:37,000
사실, 성령 생물체 중 하나는 나중에 이번 주 또는 다음에 대해 얘기하자

481
00:26:37,000 --> 00:26:41,000
그의 실행 시간 일정 알고리즘입니다.

482
00:26:41,000 --> 00:26:44,000
즉, 항상 같은 시간에 상관없이 소요

483
00:26:44,000 --> 00:26:47,000
입력은, 그 참, 매력적인 것 얼마나 큰

484
00:26:47,000 --> 00:26:49,000
이상도 로그 무언가보다.

485
00:26:49,000 --> 00:26:51,000
여기가 화면에 무엇입니까?

486
00:26:51,000 --> 00:26:55,000
사각형의 각 난 그냥 손으로 그린​​ 그대로입니다.

487
00:26:55,000 --> 00:26:59,000
그러나 왼쪽에있는 모든 방법 것은 특별한 변수입니다.

488
00:26:59,000 --> 00:27:02,000
때문에 하나 잡았다는 하나의 포인터 될거야

489
00:27:02,000 --> 00:27:04,000
연결된 목록과, 이것들은 호출로하면,

490
00:27:04,000 --> 00:27:09,000
이 연결리스트의 한쪽 끝을에 끊지해야한다는 것입니다.

491
00:27:09,000 --> 00:27:13,000
>> 그냥 문자열에서와 마찬가지로, 당신은 첫 번째 문자의 주소를 알고 있습니다.

492
00:27:13,000 --> 00:27:15,000
링크 된 목록에 같은 거래.

493
00:27:15,000 --> 00:27:19,000
당신은 메모리의 첫 번째 청크의 주소를 알고 있어야

494
00:27:19,000 --> 00:27:25,000
거기서 있기 때문에, 당신은 다른 모든 하나를 도달 할 수 있습니다.

495
00:27:25,000 --> 00:27:27,000
단점.

496
00:27:27,000 --> 00:27:30,000
우리는 동적를 갖는이 기능성에 대해 어떤 가격을 지불

497
00:27:30,000 --> 00:27:34,000
상당한 데이터 구조 우리가 어느 더 많은 메모리가 필요하다면, 괜찮아요,

498
00:27:34,000 --> 00:27:37,000
한 번만 더 큰 덩어리를 할당하고 포인터를 내다

499
00:27:37,000 --> 00:27:39,000
목록의 새로운 꼬리에 나이는?

500
00:27:39,000 --> 00:27:41,000
그래.

501
00:27:41,000 --> 00:27:43,000
[학생]은 약 두 배 많은 공간이 소요됩니다.

502
00:27:43,000 --> 00:27:45,000
확실히 단점 인 것, 두 배 많은 공간을 차지하며 우리는이를 봤어요

503
00:27:45,000 --> 00:27:48,000
시간과 공간과 유연성 사이의 전 효율이 줄어

504
00:27:48,000 --> 00:27:51,000
지금까지, 우리는이 숫자의 각 32 비트 필요가 없습니다 곳.

505
00:27:51,000 --> 00:27:57,000
우리는 정말 포인터 64, 번호 32 및 32가 필요합니다.

506
00:27:57,000 --> 00:27:59,000
하지만 제겐 RAM의 2 기가 바이트 있습니다.

507
00:27:59,000 --> 00:28:02,000
여기와 여기에 또 다른 32 비트를 추가하면 거래의 큰 것 같습니다하지 않습니다.

508
00:28:02,000 --> 00:28:05,000
그러나 큰 데이터 세트에 대해, 확실히 그대로 두 배는 더까지 추가합니다.

509
00:28:05,000 --> 00:28:09,000
이제 어떻게 또 다른 단점이야, 아니면, 우리가 어떤 기능을 포기합니까

510
00:28:09,000 --> 00:28:12,000
우리는 연결리스트가 아닌 배열과 일의 목록을 나타냅니다? 경우

511
00:28:12,000 --> 00:28:14,000
[학생] 당신은 거꾸로을 통과 할 수 없습니다.

512
00:28:14,000 --> 00:28:16,000
당신은 거꾸로을 통과 할 수 없습니다, 당신이 걷는 경우 가지 망 너무

513
00:28:16,000 --> 00:28:19,000
왼쪽에서 오른쪽으로 루프 또는 동안 루프에 대한을 사용하는

514
00:28:19,000 --> 00:28:21,000
그리고 당신은 "아, 목록의 처음으로 돌아 가고 싶어요."실현

515
00:28:21,000 --> 00:28:26,000
화살표가 표시 한대로이 포인터는 왼쪽에서 오른쪽으로 갈 수 때문입니다.

516
00:28:26,000 --> 00:28:29,000
>> 지금, 당신은 다른 변수 목록의 시작을 기억할 수

517
00:28:29,000 --> 00:28:31,000
하지만 그건 염두에 두어야하는 복잡성입니다.

518
00:28:31,000 --> 00:28:35,000
배열은, 당신이 가서 얼마나 멀리 상관없이, 당신은 항상 마이너스 마이너스, 마이너스하지, 마이너스 수

519
00:28:35,000 --> 00:28:37,000
당신이 생겨난 돌아갑니다.

520
00:28:37,000 --> 00:28:40,000
또 다른 단점은 뭐죠? 그래.

521
00:28:40,000 --> 00:28:43,000
[안 들리게 학생 질문]

522
00:28:43,000 --> 00:28:47,000
당신은 그래서 당신은 실제로, 이중 연결리스트라는 데이터 구조를 제안 텐데

523
00:28:47,000 --> 00:28:50,000
그리고 실제로,이 사각형의 각에 다른 포인터를 추가

524
00:28:50,000 --> 00:28:53,000
다른 방향을가는, 거꾸로 중

525
00:28:53,000 --> 00:28:55,000
당신이 앞뒤로 탐색 할 수 있습니다 지금

526
00:28:55,000 --> 00:28:59,000
우리 예전처럼의 단점은 지금은 많은 메모리로 세 번 사용하고 있습니다

527
00:28:59,000 --> 00:29:04,000
그리고 또한 바로를 얻을 작성해야하는 코드의 관점에서 복잡성을 추가 할 수도 있습니다.

528
00:29:04,000 --> 00:29:08,000
반전이 더 중요한 경우 그러나 이것들은 모든 아마 매우 합리적인 tradeoffs 있습니다.

529
00:29:08,000 --> 00:29:10,000
그래.

530
00:29:10,000 --> 00:29:12,000
[학생] 당신은 또한 2D 연결 목록을 가질 수 없습니다.

531
00:29:12,000 --> 00:29:16,000
좋아, 당신은 정말 2D 연결리스트를 가질 수 없습니다.

532
00:29:16,000 --> 00:29:18,000
당신은 수. 이 배열만큼 쉬운 일이 아닙니다.

533
00:29:18,000 --> 00:29:21,000
배열처럼, 오픈 브래킷, 폐쇄 브래킷, 오픈 브래킷 브래킷을 닫았을 할

534
00:29:21,000 --> 00:29:23,000
그리고 다른 2 차원 구조를.

535
00:29:23,000 --> 00:29:26,000
당신은 2 차원 연결리스트를 구현 할 수

536
00:29:26,000 --> 00:29:29,000
당신은 추가 등 이런 것들을 각 셋째 포인터를 제안한다면

537
00:29:29,000 --> 00:29:34,000
당신이 다른 목록에 대해 생각한다면 당신 3D 스타일을 올

538
00:29:34,000 --> 00:29:40,000
화면에서 우리 모두에게, 어떤은 어떤 종류의 또 다른 체인입니다.

539
00:29:40,000 --> 00:29:45,000
우리가 할 수 있지만, 오픈 브래킷, 대괄호를 입력처럼 단순한 게 아닙니다. 그래.

540
00:29:45,000 --> 00:29:48,000
[안 들리게 학생 질문]

541
00:29:48,000 --> 00:29:50,000
좋아요, 그럼이 재미있는 것입니다.

542
00:29:50,000 --> 00:29:54,000
>> 우리가 이진 검색, 오 같은 이상 pined 한 이러한 알고리즘,

543
00:29:54,000 --> 00:29:57,000
당신은 보드에 숫자의 배열을 검색 할 수 있습니다

544
00:29:57,000 --> 00:30:01,000
또는 전화 번호부가 너무 빨리 사용하는 경우 분할 및 정복

545
00:30:01,000 --> 00:30:05,000
그리고 이진 검색 알고리즘,하지만 이진 검색은 두 가정을 필요합니다.

546
00:30:05,000 --> 00:30:09,000
데이터가 정렬되었는지 하나.

547
00:30:09,000 --> 00:30:11,000
이제, 우리는 아마도,이 정렬 유지할 수

548
00:30:11,000 --> 00:30:14,000
아마 그 문제 아니지만, 이진 검색은 가정

549
00:30:14,000 --> 00:30:18,000
당신은 번호의 목록에 랜덤 액세스가 있다는

550
00:30:18,000 --> 00:30:21,000
와 배열은, 당신이 랜덤 액세스를 할 수 있으며, 랜덤 액세스하여

551
00:30:21,000 --> 00:30:24,000
난 당신이 배열을 제공하는 경우, 그것이 당신이 얼마나 많은 시간이 걸립니까 의미

552
00:30:24,000 --> 00:30:26,000
브래킷 0 말야?

553
00:30:26,000 --> 00:30:29,000
하나의 작업으로, 당신은 단지 [0] 사용하고 거기하고 있습니다.

554
00:30:29,000 --> 00:30:33,000
위치 10까지 도착하는 데 얼마나 많은 단계가 걸리나요?

555
00:30:33,000 --> 00:30:36,000
한 단계는, 당신은 당신이 거기있는 걸 [10]로 이동합니다.

556
00:30:36,000 --> 00:30:40,000
대조적으로, 어떻게 연결된 목록에서 10 정수로 어떻게해야합니까?

557
00:30:40,000 --> 00:30:42,000
만 기억 때문에 당신은 처음부터 시작해야

558
00:30:42,000 --> 00:30:45,000
단지 문자열과 같은 연결리스트의 시작 부분은 기억하고 있습니다

559
00:30:45,000 --> 00:30:48,000
첫 번째 문자의 주소에 의해, 그 열째 INT를 찾을 수

560
00:30:48,000 --> 00:30:53,000
또는 문자열에서 해당 문자 열째, 당신은 모든 빌어 먹을 것을 검색 할 수 있습니다.

561
00:30:53,000 --> 00:30:55,000
>> 다시 말하지만, 우리는 우리의 모든 문제를 해결하지.

562
00:30:55,000 --> 00:31:00,000
우리는 새로운 사람을 소개하고 있지만 정말 당신이 설계하려는 일에 따라 달라집니다.

563
00:31:00,000 --> 00:31:04,000
이 구현의 측면에서, 우리는 그 학생의 구조에서 아이디어를 대여하실 수 있습니다.

564
00:31:04,000 --> 00:31:07,000
구문은 현재를 제외하고 매우 비슷 아이디어는 조금 더 추상적입니다

565
00:31:07,000 --> 00:31:09,000
보다 집 이름과 ID.

566
00:31:09,000 --> 00:31:13,000
하지만 우리가 C에서 데이터 구조를 가질 수 있다는 제안

567
00:31:13,000 --> 00:31:17,000
노드라고 그, 슬라이드의 마지막 단어가 제시 등

568
00:31:17,000 --> 00:31:21,000
노드의 내부, 그리고 노드는 컴퓨터 과학 일반 컨테이너입니다.

569
00:31:21,000 --> 00:31:25,000
그것은 일반적으로 원이나 우리가 한로 광장 또는 사각형으로 그려있어.

570
00:31:25,000 --> 00:31:27,000
그리고이 데이터 구조에, 우리는 정수, N을 가지고

571
00:31:27,000 --> 00:31:29,000
그래서 내가 저장할 수 있습니다.

572
00:31:29,000 --> 00:31:36,000
그러나 두 번째 줄, 구조체 노드가 * 다음은 무엇인가?

573
00:31:36,000 --> 00:31:40,000
왜이 정확한지 확인하거나 역할은이 일을 플레이 무엇을

574
00:31:40,000 --> 00:31:42,000
그것은 먼저 눈에 약간 이상한이지만?

575
00:31:42,000 --> 00:31:44,000
그래.

576
00:31:44,000 --> 00:31:46,000
[안 들리게 학생 응답]

577
00:31:46,000 --> 00:31:50,000
맞아요, 그래서 일종의 포인터 부패의 * 정렬 없잖아.

578
00:31:50,000 --> 00:31:53,000
이 포인터의 이름은 임의로 옆에 있습니다

579
00:31:53,000 --> 00:32:00,000
우리는 그것을 우리가 원하는 건 다 신고 할 수도 있지만이 포인터 지점은 무엇을 할 수 있습니까?

580
00:32:00,000 --> 00:32:03,000
[학생] 또 다른 노드가. >> 그건 정확히 같은 또 다른 노드로 가리 킵니다.

581
00:32:03,000 --> 00:32:05,000
>> 자, 여기 C.의 호기심의 일종입니다

582
00:32:05,000 --> 00:32:09,000
, C는 왼쪽에서 오른쪽으로, 아래로 컴파일러 상단에서 읽을 것을 기억

583
00:32:09,000 --> 00:32:13,000
-이 경우 우리가 학생들과 무슨 짓을했는지 약간 다릅니다 어느 의미합니다.

584
00:32:13,000 --> 00:32:16,000
우리는 학생을 정의 할 때, 우리는 실제로이 단어를 넣지 않았다.

585
00:32:16,000 --> 00:32:18,000
단지 typedef 말했다.

586
00:32:18,000 --> 00:32:20,000
그럼 우리가 INT ID, 문자열 이름, 문자열 하우스를했다

587
00:32:20,000 --> 00:32:23,000
다음 구조체의 맨 아래에있는 학생.

588
00:32:23,000 --> 00:32:26,000
이 선언이 조금 다르기 때문에,

589
00:32:26,000 --> 00:32:28,000
다시 C 컴파일러는 약간 바보입니다.

590
00:32:28,000 --> 00:32:30,000
단지, 위에서 아래로 읽을거야

591
00:32:30,000 --> 00:32:33,000
여기 2 호선에 도달하므로 경우

592
00:32:33,000 --> 00:32:37,000
다음은 선언하고보고되는​​ 오, 여기 다음이라는 변수입니다.

593
00:32:37,000 --> 00:32:39,000
이 구조체 노드에 대한 포인터입니다.

594
00:32:39,000 --> 00:32:42,000
컴파일러는 구조체 노드 무엇인지 깨닫게거야?

595
00:32:42,000 --> 00:32:44,000
나는 전에이 일을 한 번도 들어 본 적이 없어요

596
00:32:44,000 --> 00:32:47,000
단어 노드는 달리 표시하지 않을 수 있기 때문에

597
00:32:47,000 --> 00:32:49,000
맨 아래까지,이 중복성이 있습니다.

598
00:32:49,000 --> 00:32:53,000
당신이 나중에에서 단축 할 수있는, 여기를 구조체 노드를 얘기해야

599
00:32:53,000 --> 00:32:56,000
여기 typedef 덕분에 있지만,이 때문

600
00:32:56,000 --> 00:33:02,000
우리는 내부 구조의 구조 자체를 참조하고 있습니다.

601
00:33:02,000 --> 00:33:05,000
거기있는 한 잡았다입니다.

602
00:33:05,000 --> 00:33:07,000
>> 일부 흥미로운 문제가 발생하는 것입니다.

603
00:33:07,000 --> 00:33:09,000
우리는 숫자의 목록이 있어요. 우리는에 어떻게 삽입합니까?

604
00:33:09,000 --> 00:33:11,000
우리가 어떻게 그것을 어떻게 검색합니까? 우리는에서 어떻게 삭제합니까?

605
00:33:11,000 --> 00:33:13,000
특히 지금 우리가이 포인터를 관리해야한다는.

606
00:33:13,000 --> 00:33:15,000
당신은 포인터가 정신 벤딩의 일종이라고 생각

607
00:33:15,000 --> 00:33:17,000
당신이했을 때 그 중 하나가 여기에 정수를 읽는.

608
00:33:17,000 --> 00:33:20,000
이제 우리는 전체 목록의 가치를 조작해야합니다.

609
00:33:20,000 --> 00:33:22,000
왜 우리가 여기 5 분 휴식을 취하지 않으며, 다음에 우리가 가지고 갈 게요

610
00:33:22,000 --> 00:33:34,000
무대에 일부 사람들은 정확히 할 수 있습니다.

611
00:33:34,000 --> 00:33:36,000
>> C 그것이 밖으로 행동있어 훨씬 더 재미있을 것입니다.

612
00:33:36,000 --> 00:33:39,000
누구는 말 그대로 처음 하시겠습니까?

613
00:33:39,000 --> 00:33:41,000
자, 어서 올라 와요. 먼저입니다.

614
00:33:41,000 --> 00:33:44,000
누구는 9 삭제 하시겠습니까? 좋아요, 9.

615
00:33:44,000 --> 00:33:46,000
어떻게 구 요? 17?

616
00:33:46,000 --> 00:33:51,000
여기 좀 도당. 그 앞 행의 22 26.

617
00:33:51,000 --> 00:33:53,000
그리고 사람을 거기에서 얼마나 지적된다.

618
00:33:53,000 --> 00:33:57,000
당신이 34입니다. 알았어,에 34, 있습니다.

619
00:33:57,000 --> 00:33:59,000
우선은 저기 있어요. 그래, 너희 모두 넷.

620
00:33:59,000 --> 00:34:01,000
그리고 우리가 9 누구인지 말 했어요?

621
00:34:01,000 --> 00:34:04,000
우리 구가 누구야?

622
00:34:04,000 --> 00:34:07,000
누가 정말 구가되기를 원하는가? 좋아, 9 할에 있습니다.

623
00:34:07,000 --> 00:34:10,000
여기 우리는 간다.

624
00:34:10,000 --> 00:34:13,000
34, 우리는 거기서 만나자.

625
00:34:13,000 --> 00:34:17,000
첫 번째 부분은 자신이 그렇게 보이게됩니다.

626
00:34:17,000 --> 00:34:21,000
26, 22, 17, 좋아.

627
00:34:21,000 --> 00:34:25,000
우리가 순간에서 당신을 malloc 할거야 때문에 당신이 옆에 서있다 할 수 있습니다.

628
00:34:25,000 --> 00:34:29,000
>> 좋아, 좋아.

629
00:34:29,000 --> 00:34:32,000
좋아요, 우수한 있으니, 여기에 몇 가지 질문을 보자.

630
00:34:32,000 --> 00:34:34,000
그리고 사실, 이름이 뭐야? >> 애니타.

631
00:34:34,000 --> 00:34:37,000
아니타, 그래, 어서와.

632
00:34:37,000 --> 00:34:41,000
아니타는 우리가 약간 먼저 하나가 매우 간단한 질문을 해결하는 데 도움 것입니다

633
00:34:41,000 --> 00:34:44,000
이것은 어떻게 값이 목록에 있는지 여부를 찾을 수 있습니까입니까?

634
00:34:44,000 --> 00:34:48,000
자, 먼저 여기 루카스으로 표현하는 것을

635
00:34:48,000 --> 00:34:52,000
조금 다른, 그래서 종이 그의 조각은 의도적으로 옆입니다

636
00:34:52,000 --> 00:34:55,000
상당히으로 크지 않아 많은 비트로 차지하지 않기 때문에

637
00:34:55,000 --> 00:34:58,000
비록 기술적으로 그는 단지 회전 용지의 같은 크기가 있습니다.

638
00:34:58,000 --> 00:35:01,000
그러나 그는 포인터 만 32 비트, 그게은 조금 다릅니다

639
00:35:01,000 --> 00:35:05,000
그리고이 사람들이 모든 포인터 이분의 일있는 번호입니다 이분의 일 중 64 비트,입니다.

640
00:35:05,000 --> 00:35:08,000
그러나 포인터는, 그래서 묘사되지 않은 너희들이 수 다소 어색 경우

641
00:35:08,000 --> 00:35:12,000
당신 옆에있는 사람에 가리 키도록 왼손을 사용합니다.

642
00:35:12,000 --> 00:35:14,000
그리고 당신은 34이야. 이름이 무엇입니까?

643
00:35:14,000 --> 00:35:16,000
아리.

644
00:35:16,000 --> 00:35:19,000
아리, 그래서 사실은, 오른쪽 손으로 종이를 보유하고 왼손은 똑바로 내려갑니다.

645
00:35:19,000 --> 00:35:21,000
당신은 왼쪽에있는 null을 나타냅니다.

646
00:35:21,000 --> 00:35:24,000
>> 지금 우리 인간의 그림은 매우 일치합니다.

647
00:35:24,000 --> 00:35:26,000
이 포인터는 어떻게 작동하는지 실제로 있습니다.

648
00:35:26,000 --> 00:35:29,000
그리고 방법은 아니야 있도록 조금 이런 식으로 오독 오독 깨물다 할 수 있습니다.

649
00:35:29,000 --> 00:35:34,000
여기 아니타, 저에게 22 번을 찾아

650
00:35:34,000 --> 00:35:40,000
하지만 인간이 종이 조각을 들고 않는 제약을 가정,

651
00:35:40,000 --> 00:35:43,000
하지만이 목록이며, 만 루카스가로 시작해야

652
00:35:43,000 --> 00:35:46,000
그는 말 그대로 첫 번째 포인터이기 때문이다.

653
00:35:46,000 --> 00:35:51,000
당신은 자신이 포인터이며, 따라서 너무 무언가를 가리 할 수​​있는 능력을 가지고 있다고 가정 해 보겠습니다.

654
00:35:51,000 --> 00:35:56,000
왜 루카스가에서 가리키는 정확히 겨누고부터 시작해 볼까요?

655
00:35:56,000 --> 00:35:58,000
좋아,이 날 여기에이 일을 제정 보자.

656
00:35:58,000 --> 00:36:04,000
그냥 토론을 위해서, 제가 여기에 빈 페이지를 하세.

657
00:36:04,000 --> 00:36:06,000
어떻게 당신의 이름을 철자합니까? >> 애니타.

658
00:36:06,000 --> 00:36:08,000
좋아요, 애니타.

659
00:36:08,000 --> 00:36:18,000
하자 노드 * 아니타 = 루카스를 말한다.

660
00:36:18,000 --> 00:36:22,000
음, 우리는 당신 루카스 전화 안됩니다. 우리는 먼저 전화를해야합니다.

661
00:36:22,000 --> 00:36:25,000
왜 여기 현실과 일치 사실입니까?

662
00:36:25,000 --> 00:36:27,000
하나는 먼저 이미 존재합니다.

663
00:36:27,000 --> 00:36:30,000
첫째는 어딘가 여기에 아마 할당되었습니다.

664
00:36:30,000 --> 00:36:35,000
노드는 * 우선, 그리고 그것은 어떻게 든 목록을 배정하고있어.

665
00:36:35,000 --> 00:36:37,000
그런 일이 어떻게 일어난 건지 모르겠어요. 수업이 시작되기 전에 그런 일이 일어날.

666
00:36:37,000 --> 00:36:40,000
인간의이 연결 목록이 생성되었습니다.

667
00:36:40,000 --> 00:36:44,000
그리고 지금 이야기 -이 다들 페이스 북이 벌어지고있는이 시점에서 나중에 -

668
00:36:44,000 --> 00:36:49,000
이야기의 시점에서 아니타는 첫 번째 같도록 초기화되었습니다

669
00:36:49,000 --> 00:36:51,000
이는 루카스의 아니타 점을 의미하지는 않습니다.

670
00:36:51,000 --> 00:36:53,000
오히려, 그녀는 그가에서 지적하는 일에 지적

671
00:36:53,000 --> 00:36:57,000
때문에 루카스의 32 비트의 안에 동일한 주소 - 1, 2, 3 -

672
00:36:57,000 --> 00:37:01,000
1, 2, 3 - 또한 현재 내부 아니타의 32 비트입니다.

673
00:37:01,000 --> 00:37:05,000
>> 지금 22를 찾으십시오. 어떻게이 일을 어떻게해야합니까?

674
00:37:05,000 --> 00:37:07,000
무엇이든에 그? >> 포인트는 무엇입니까.

675
00:37:07,000 --> 00:37:11,000
무엇이든을 가리 킵니다, 그래서 가서 여기 최대한으로 연기.

676
00:37:11,000 --> 00:37:15,000
좋아, 좋아, 지금 당신은 포인팅하는에 - 당신의 이름이 22이야?

677
00:37:15,000 --> 00:37:18,000
라몬. >> 라몬, 라몬 22까지 개최 될 수 있도록.

678
00:37:18,000 --> 00:37:20,000
이제 수표을 다하고 있습니다.

679
00:37:20,000 --> 00:37:24,000
만약 그렇다면 라몬 == 22 그리고 예를 들어, 우리는 진정한 돌아갈 수 않습니다.

680
00:37:24,000 --> 00:37:26,000
- 날 동안하자 놈들이 어색 - 다소 여기 서

681
00:37:26,000 --> 00:37:32,000
찾아 나 BOOL처럼 빠르게 무언가를 해봅시다.

682
00:37:32,000 --> 00:37:37,000
나는 (노드 * 목록, INT n)이 가서 말거야.

683
00:37:37,000 --> 00:37:39,000
당신이 사람들과 함께 곧 돌아 올게요. 난 그냥 몇 가지 코드를 작성해야합니다.

684
00:37:39,000 --> 00:37:45,000
그리고 이제 가서이, 노드 * 아니타 = 목록을 할거야.

685
00:37:45,000 --> 00:37:51,000
그리고 가서 인사하고 올게요 동안 (아니타! = NULL).

686
00:37:51,000 --> 00:37:57,000
>> 여기에 비유가 좀 늘어지고 있지만, (아니타! = NULL), 내가 뭘 원하는거야 동안?

687
00:37:57,000 --> 00:38:03,000
나는 참조의 일부 방법이 필요합니다

688
00:38:03,000 --> 00:38:05,000
아니타가 가리키고되는 정수.

689
00:38:05,000 --> 00:38:08,000
과거에는, 우리는 노드가있는 구조를했을 때,

690
00:38:08,000 --> 00:38:11,000
우리는 점 표기법을 사용하고, 우리가 뭔가 이렇게 말할 것입니다

691
00:38:11,000 --> 00:38:15,000
여기 anita.n하지만, 문제는 아니타는 구조체 이라기보다는되지 않는 것입니다.

692
00:38:15,000 --> 00:38:17,000
그녀는 무엇인가요?

693
00:38:17,000 --> 00:38:21,000
우리가이 점을 사용하려는 경우 그녀는, 그래서 정말 포인터입니다 표기법을

694
00:38:21,000 --> 00:38:23,000
이 일부러 좀 봐 것입니다 암호화 -

695
00:38:23,000 --> 00:38:28,000
우리가 어떤 아니타의 왼쪽으로 이동과 같은 작업을 수행 할 일은에서 가리키고

696
00:38:28,000 --> 00:38:31,000
그리고 다음에 n이라는 필드를 얻을.

697
00:38:31,000 --> 00:38:35,000
아니타는 포인터이지만, * 아니타는 무엇인가?

698
00:38:35,000 --> 00:38:38,000
당신은 아니타가에서 가리키고 있는지에 갈 때 무엇을 찾을 수 있습니까?

699
00:38:38,000 --> 00:38:42,000
구조체, 노드와 노드, 리콜, N라는 필드가 있습니다

700
00:38:42,000 --> 00:38:47,000
가, 기억했기 때문에,이 두 분야, 다음과 n,

701
00:38:47,000 --> 00:38:50,000
우리는 바로 여기 좀 전에 본 적이.

702
00:38:50,000 --> 00:38:53,000
>> 사실, 코드에서이 작업을 모방하려면

703
00:38:53,000 --> 00:39:02,000
우리는이 작업을 수행하고 말할 수있는 경우 ((* 아니타). N == n)이, 내가 찾는 그 N.

704
00:39:02,000 --> 00:39:04,000
함수가 내 관심 숫자에서 통과 된 것을 확인할 수 있습니다.

705
00:39:04,000 --> 00:39:10,000
그럼 내가 TRUE를 반환과 같이 가서 할 수 있습니다.

706
00:39:10,000 --> 00:39:12,000
그런 경우가 아니라면 다른, 내가 뭘할까요?

707
00:39:12,000 --> 00:39:19,000
어떻게 아니타가 목록을 도보로 매우 직관적으로 무슨 짓을했는지 코드를로 번역해야합니까?

708
00:39:19,000 --> 00:39:26,000
나는 아니타는 왼쪽으로, 왼쪽에 해당 단계를 그 단계를 복용 시뮬레이션 여기서 뭘를해야합니까?

709
00:39:26,000 --> 00:39:28,000
[안 들리게 학생 응답] >> 그게 뭐야?

710
00:39:28,000 --> 00:39:30,000
[안 들리게 학생 응답]

711
00:39:30,000 --> 00:39:34,000
아닌 나쁜 생각하지만, 과거에, 우리는 이런 짓을했을 때, 우리는 좋은 한 아니타 + +

712
00:39:34,000 --> 00:39:37,000
그 아니타에 숫자 1을 추가하기 때문에하면,

713
00:39:37,000 --> 00:39:40,000
어떤 일반적으로, 라몬처럼, 다음 사람에 지정 것

714
00:39:40,000 --> 00:39:44,000
또는 그 옆에있는 사람, 또는 사람 아래로 선을 그에게 다음.

715
00:39:44,000 --> 00:39:49,000
무슨 일이 메모리에 같이 않기 때문에 그러나 여기에 큰 좋지 않아?

716
00:39:49,000 --> 00:39:54,000
그건 아니에요. 우리는 그렇게하지 ​​않도록해야합니다.

717
00:39:54,000 --> 00:40:00,000
내가 1, 2, 3 가까이 서로를 그려 했는데도 메모리에 같이 표시하고,

718
00:40:00,000 --> 00:40:03,000
우리가 시뮬레이션하는 경우에도 같은 사람들을 가리키는 동안은 사람들이 - 수

719
00:40:03,000 --> 00:40:07,000
당신의 일부가 임의의 단계를 다시 앞으로 여러분 중 일부는 임의의 단계를 취할 수 있겠어요?

720
00:40:07,000 --> 00:40:10,000
>> 이 혼란은 여전히​​ 연결된 목록입니다

721
00:40:10,000 --> 00:40:13,000
하지만이 사람들은 어디서든 메모리에있을 수

722
00:40:13,000 --> 00:40:15,000
그래서 아니타는 + + 왜 안 먹힌다?

723
00:40:15,000 --> 00:40:19,000
위치 아니타에 무엇 + +?

724
00:40:19,000 --> 00:40:21,000
누가 알 겠어.

725
00:40:21,000 --> 00:40:24,000
그건 아주 interposed 할 일이 몇 가지 다른 값입니다

726
00:40:24,000 --> 00:40:28,000
혹시 이러한 노드의 사이에 있기 때문에 우리는 배열을 사용하지 않는 것입니다.

727
00:40:28,000 --> 00:40:30,000
우리는 개별적으로 이러한 노드 각각 할당.

728
00:40:30,000 --> 00:40:32,000
그래, 당신들은 몸을 다시 청소 할 수 있습니다.

729
00:40:32,000 --> 00:40:37,000
나를 대신 아니타 + +, 우리가 대신 할 아니타의 것을 제안하자 도착 -

730
00:40:37,000 --> 00:40:42,000
그래, 우리가 할 후 아니타가에서 가리키는대로로 이동되지 않는 이유. 다음?

731
00:40:42,000 --> 00:40:45,000
즉, 우리는 22 번을 들고 라몬로 이동

732
00:40:45,000 --> 00:40:51,000
아니타가 왼쪽 포인터를 복사 될 것처럼하고. 다음입니다.

733
00:40:51,000 --> 00:40:54,000
우리가 22 버렸기 때문에 그녀는 라몬보다 더 안 것입니다.

734
00:40:54,000 --> 00:40:56,000
하지만 그건 생각합니다. 자,이는 지독한 엉망입니다.

735
00:40:56,000 --> 00:40:59,000
솔직히, 아무도, 그래서 고맙게도이 구문을 기억하지, 그리고 것입니다

736
00:40:59,000 --> 00:41:04,000
실제로 약간의 고의적 - 오, 실제로 제가 쓴 건 못 봤어요입니다.

737
00:41:04,000 --> 00:41:08,000
당신은 할수있을 경우 더 강력한 것입니다. 짜잔!

738
00:41:08,000 --> 00:41:10,000
>> 무대 뒤에서, 문제가 이런 식으로 해결했습니다.

739
00:41:10,000 --> 00:41:14,000
아니타, 왼쪽이 단계를 위해,

740
00:41:14,000 --> 00:41:18,000
첫째, 우리는 아니타가 가리키고되는 주소로가는거야

741
00:41:18,000 --> 00:41:23,000
, 어디 그녀는뿐만 아니라 우리가 비교를 위해서 검사 n을, 찾을 수

742
00:41:23,000 --> 00:41:25,000
뿐만 아니라 옆에 찾을 수 있습니다 -이 경우,

743
00:41:25,000 --> 00:41:28,000
라몬의 왼쪽 손이 목록에있는 다음 노드를 가리키는.

744
00:41:28,000 --> 00:41:32,000
하지만 지금은, 내가 전에 언급하는 지독한 엉망이야

745
00:41:32,000 --> 00:41:34,000
C 우리가이 일을 단순화 할 수 밖에하지만집니다.

746
00:41:34,000 --> 00:41:40,000
대신 작문 (* 아니타), 우리는 대신, 아니타 -> N을 작성할 수 있습니다

747
00:41:40,000 --> 00:41:45,000
그리고, 그것은 기능적으로 동일한 일이야,하지만 더 많은 직관적

748
00:41:45,000 --> 00:41:48,000
그리고 우리가 그리는 된 것으로 사진이 더 많은 일치

749
00:41:48,000 --> 00:41:50,000
이 시간은 화살표를 사용합니다.

750
00:41:50,000 --> 00:41:57,000
>> 마지막으로, 우리는이 프로그램의 끝 부분에 어떻게해야하나요?

751
00:41:57,000 --> 00:42:00,000
남은 코드 한 줄이 있어요.

752
00:42:00,000 --> 00:42:02,000
무엇을 반환?

753
00:42:02,000 --> 00:42:05,000
거짓 때문에 우리는 전체를한다면 동안 루프

754
00:42:05,000 --> 00:42:10,000
그리고 아니타 사실은 널 (null)는, 그녀가 목록의 끝까지 갔어요 의미입니다

755
00:42:10,000 --> 00:42:12,000
그녀가 가리키고있는 곳에서 - 이름이 뭐였지?

756
00:42:12,000 --> 00:42:15,000
null입니다 아리. >> 아리의 왼쪽.

757
00:42:15,000 --> 00:42:18,000
아니타는 이제 null입니다, 그리고 당신이 지금 지옥의 변방에 어색 여기 서 실현

758
00:42:18,000 --> 00:42:21,000
여기 독백이 떨어져 갈거야 때문에,

759
00:42:21,000 --> 00:42:23,000
하지만 우리는 곧 다시 포함됩니다.

760
00:42:23,000 --> 00:42:27,000
아니타는 이야기 그 시점에서 null입니다, 동안 루프가 종료 때문에

761
00:42:27,000 --> 00:42:30,000
우리는 False를 반환하는 이유로 그녀는 아리의 NULL 포인터에 대한 모든 방법을 강구하는 경우

762
00:42:30,000 --> 00:42:34,000
그리고 그녀가 목록에 추구한다는 수는 없었습니다.

763
00:42:34,000 --> 00:42:39,000
우리는 너무 치울 수 있지만,이는 아주 좋은 구현 한 것입니다

764
00:42:39,000 --> 00:42:43,000
탐색 기능,이 연결 목록 기능을 찾으십시오.

765
00:42:43,000 --> 00:42:48,000
아직 선형 검색이야,하지만 + + 포인터처럼 간단하지

766
00:42:48,000 --> 00:42:52,000
또는 + + 전 변수 이제 우리가 추측 할 수 없기 때문에

767
00:42:52,000 --> 00:42:54,000
이러한 노드의 각 메모리에 위치합니다.

768
00:42:54,000 --> 00:42:57,000
좀 더 구체적으로, 문자 그대로 빵 부스러기의 흔적을 따라해야하거나

769
00:42:57,000 --> 00:43:00,000
한 노드에서 다른에 도착 포인터.

770
00:43:00,000 --> 00:43:02,000
>> 지금의이 다른 하나를 시도해 보자. 아니타, 당신은 여기 다시 올 하시겠습니까?

771
00:43:02,000 --> 00:43:06,000
왜 우리가 가서 관객의 다른 사람을 할당해야합니까?

772
00:43:06,000 --> 00:43:08,000
Malloc - 당신의 이름은? >> 레베카.

773
00:43:08,000 --> 00:43:10,000
레베카. 레베카는 관객의 malloced되었습니다

774
00:43:10,000 --> 00:43:13,000
그녀는 이제 55 번을 저장합니다.

775
00:43:13,000 --> 00:43:17,000
아니타 삽입 및 손의 목표는 지금

776
00:43:17,000 --> 00:43:22,000
그 적절한 장소에 여기 링크 된 목록에 레베카.

777
00:43:22,000 --> 00:43:24,000
잠시 이리와.

778
00:43:24,000 --> 00:43:28,000
이런 식으로 무슨 짓을했습니다.

779
00:43:28,000 --> 00:43:32,000
나는 노드 *을 다하고 있습니다. 그리고 자네 이름이 뭐였더라?

780
00:43:32,000 --> 00:43:34,000
레베카. >> 레베카, 좋아.

781
00:43:34,000 --> 00:43:41,000
레베카는 malloc (sizeof (노드))됩니다.

782
00:43:41,000 --> 00:43:44,000
것처럼 우리는 과거에 학생들과 이것 저것 등을 할당 한

783
00:43:44,000 --> 00:43:46,000
우리는 노드의 크기를해야합니다, 이제 레베카는

784
00:43:46,000 --> 00:43:49,000
무엇을 가리키고 무엇입니까?

785
00:43:49,000 --> 00:43:52,000
레베카 55입니다 중 하나 그녀의 내부에 두 개의 필드를 가지고 있습니다.

786
00:43:52,000 --> 00:43:55,000
하자의 일, 레베카 -> = 55.

787
00:43:55,000 --> 00:44:00,000
하지만 레베카 -> 옆에있는 지금 - 좋아한다, 그녀의 손을 누가 알 일 일까?

788
00:44:00,000 --> 00:44:03,000
정말 이유를 잘 측정하지, 일부 쓰레기 값에서 눈치입니다

789
00:44:03,000 --> 00:44:07,000
왼쪽 이제 그녀의 옆에이되도록 우리는 적어도이 작업을 수행합니다.

790
00:44:07,000 --> 00:44:09,000
지금 아니타는 여기에서보십시오.

791
00:44:09,000 --> 00:44:11,000
당신은 레베카가 할당 된 것으로되어 있습니다.

792
00:44:11,000 --> 00:44:20,000
가서 우리가 레베카를 넣어 위치를 찾습니다.

793
00:44:20,000 --> 00:44:25,000
아주 좋아, 좋아.

794
00:44:25,000 --> 00:44:28,000
, 좋아, 좋아, 이제 우리는 당신이 방향의 비트를 제공해야

795
00:44:28,000 --> 00:44:30,000
그래서 당신은 아리에 도달했습니다.

796
00:44:30,000 --> 00:44:33,000
, 그의 왼손은 널 (null)이지만, 레베카는 분명히 오른쪽에 속한

797
00:44:33,000 --> 00:44:36,000
그럼 우리는이 연결 목록을 변경해야합니까

798
00:44:36,000 --> 00:44:38,000
적절한 장소에 레베카를 삽입하는 순서로?

799
00:44:38,000 --> 00:44:42,000
당신은 말 그대로 필요에 따라 주변 사람들의 왼쪽 손을 움직일 수있는 경우는,

800
00:44:42,000 --> 00:44:48,000
우리는 그런 식으로 문제를 해결합니다.

801
00:44:48,000 --> 00:44:52,000
그래, 좋아, 그리고 한편, 레베카의 왼쪽 손은 그녀의 옆에 지금 있습니다.

802
00:44:52,000 --> 00:44:54,000
>> 너무 쉬웠다.

803
00:44:54,000 --> 00:44:57,000
하자, 거의 다 할당 - 우린 20 해보십시오.

804
00:44:57,000 --> 00:44:59,000
자, 어서 올라 와요.

805
00:44:59,000 --> 00:45:04,000
20 할당 된, 그럼 내가 가서 여기에 다시 말하죠

806
00:45:04,000 --> 00:45:07,000
우리는 노드 *의 사드 했어.

807
00:45:07,000 --> 00:45:11,000
우리는 (sizeof (노드)) malloc 있습니다.

808
00:45:11,000 --> 00:45:16,000
우리는, 우리가 20 전에했던 것과 같은 정확한 구문을 수행

809
00:45:16,000 --> 00:45:20,000
그리고 난 다음에 = NULL을 다하겠습니다, 지금은 아니타에게 달려 있습니다

810
00:45:20,000 --> 00:45:23,000
당신이 동일한 역할을 할 수 있다면 당신은 연결리스트에 삽입합니다.

811
00:45:23,000 --> 00:45:30,000
실행.

812
00:45:30,000 --> 00:45:32,000
그래, 좋아.

813
00:45:32,000 --> 00:45:38,000
당신이 근처에 왼쪽 손을 움직이기 시작하기 전에 지금 신중하게 생각합니다.

814
00:45:38,000 --> 00:45:46,000
귀하는 오늘 현재까지 가장 어색한 역할을 가지고.

815
00:45:46,000 --> 00:45:59,000
누구의 손 첫째 이동해야 하는가?

816
00:45:59,000 --> 00:46:02,000
좋아요, 좀 더의를 듣고 있어요, 잠깐만 요.

817
00:46:02,000 --> 00:46:07,000
일부 사람들은 정중하게 여기 어색한 상황을 해결하는 데 도움이하고 싶은 경우.

818
00:46:07,000 --> 00:46:11,000
누구의 왼쪽 먼저 아마도 업데이트해야합니다? 그래.

819
00:46:11,000 --> 00:46:13,000
[학생] 사드의.

820
00:46:13,000 --> 00:46:15,000
좋아요, 사드의, 왜,하지만?

821
00:46:15,000 --> 00:46:17,000
[안 들리게 학생 응답]

822
00:46:17,000 --> 00:46:19,000
좋아, 때문에 우리가 이동 - 만약 당신 이름은? >> 마샬.

823
00:46:19,000 --> 00:46:22,000
마샬, 우리는 null로 첫번째 다운 손을 이동하면,

824
00:46:22,000 --> 00:46:25,000
이제 우리는 말 그대로이 목록에 4 명을 고아했습니다

825
00:46:25,000 --> 00:46:29,000
그는 라몬과 왼쪽 모두에서 가리키는 유일한 때문

826
00:46:29,000 --> 00:46:31,000
그래서 먼저 포인터를 업데이트하는 것은 좋지 않습니다.

827
00:46:31,000 --> 00:46:33,000
씨가 실행 취소 보자.

828
00:46:33,000 --> 00:46:37,000
좋아, 지금 가서 라몬에서 가리키는 적절한 왼쪽 손을 이동합니다.

829
00:46:37,000 --> 00:46:39,000
이 약간 중복을 느낀다.

830
00:46:39,000 --> 00:46:41,000
자, 그럼 이제 라몬에서 가리키는 두 사람이지만, 그 좋아요

831
00:46:41,000 --> 00:46:43,000
때문에 지금은 어떻게 다른 우리는 목록을 업데이트하려면 어떻게해야합니까?

832
00:46:43,000 --> 00:46:48,000
다른 어떤 손이 이동나요?

833
00:46:48,000 --> 00:46:53,000
훌륭해, 지금 우리는 모든 기억을 잃은 있나요?

834
00:46:53,000 --> 00:46:57,000
아니, 잘, 우리가이 한번 더 부러 할 수없는 경우 보자.

835
00:46:57,000 --> 00:47:00,000
>> , 숫자 5를 마지막으로 Mallocing.

836
00:47:00,000 --> 00:47:04,000
다시의 모든 방법은 아래에 있습니다.

837
00:47:04,000 --> 00:47:08,000
매우 흥분 돼.

838
00:47:08,000 --> 00:47:15,000
[박수]

839
00:47:15,000 --> 00:47:17,000
이름이 무엇입니까? >> 론.

840
00:47:17,000 --> 00:47:19,000
론은, 좋아, 당신은 5 번으로 malloced 수 있습니다.

841
00:47:19,000 --> 00:47:23,000
우리는이 거의 똑같아요 해당 코드를 실행 한

842
00:47:23,000 --> 00:47:26,000
그냥 다른 이름으로.

843
00:47:26,000 --> 00:47:28,000
좋아요.

844
00:47:28,000 --> 00:47:38,000
지금, 아니타, 행운을 빌어 요 이제 목록에 5 번을 삽입.

845
00:47:38,000 --> 00:47:43,000
좋은, 그리고?

846
00:47:43,000 --> 00:47:47,000
우수,이 정말 총 세 명의 가지 경우 세 번째입니다.

847
00:47:47,000 --> 00:47:49,000
우리가 처음 레베카 끝에서 사람을했다.

848
00:47:49,000 --> 00:47:51,000
우리는 중간에 사람을했다.

849
00:47:51,000 --> 00:47:53,000
이제 우리는, 처음에,이 예제에서 사람이

850
00:47:53,000 --> 00:47:56,000
우리는 이제 처음으로 루카스를 업데이트했습니다

851
00:47:56,000 --> 00:48:00,000
목록의 첫 번째 요소는 이제 새 노드에 가리 있기 때문에하면,

852
00:48:00,000 --> 00:48:03,000
누가, 차례로, 노드 번호 9시 가리키고 있습니다.

853
00:48:03,000 --> 00:48:06,000
>> 이 상당히 어색 시연했습니다 확신 해요,

854
00:48:06,000 --> 00:48:08,000
그래서 애들에게 환호와 갈채가 잖아요.

855
00:48:08,000 --> 00:48:11,000
잘 했어.

856
00:48:11,000 --> 00:48:17,000
그게 전부 야. 당신은 약간의 메모리로 종이의 조각을 유지 할 수 있습니다.

857
00:48:17,000 --> 00:48:22,000
이 코드에서 이런 짓을 것이 밝혀

858
00:48:22,000 --> 00:48:26,000
단지 주변에 손을 이동과 같은 매우 간단하지 않습니다

859
00:48:26,000 --> 00:48:28,000
그리고 다른 일에 포인터를 가리키고.

860
00:48:28,000 --> 00:48:31,000
하지만 이런 일을 수행 할 시간이되면 걸 깨닫게

861
00:48:31,000 --> 00:48:34,000
당신이 정말로에 초점을 경우 연결된 목록 또는 그 변종

862
00:48:34,000 --> 00:48:38,000
이러한 기본적인 기초, 내가 찾아 내야 할 한입 크기의 문제,

863
00:48:38,000 --> 00:48:43,000
이렇게 손이나 손, 어떤 달리 상당히 복잡한 프로그램 걸 깨닫게

864
00:48:43,000 --> 00:48:47,000
사실,이 같은 매우 간단한 빌딩 블록을 줄일 수 있습니다.

865
00:48:47,000 --> 00:48:51,000
>> 아직도 더 정교한 방향으로 일을 살펴 보자.

866
00:48:51,000 --> 00:48:53,000
이제 우리는 연결리스트의 개념을 가지고있어.

867
00:48:53,000 --> 00:48:57,000
다시 제안이 있는데 이중 연결리스트에 우리는 또한이 - 감사합니다,

868
00:48:57,000 --> 00:49:01,000
이는 거의 같은 소리를 들으며, 지금 우리는 구조체에 두 개의 포인터를 가지고

869
00:49:01,000 --> 00:49:05,000
대신에 하나, 우리는 아마도 그 포인터가 이전 및 다음 호출 할 수

870
00:49:05,000 --> 00:49:08,000
왼쪽 또는 오른쪽으로하지만, 저희는 사실, 그 중 두 필요는 없어.

871
00:49:08,000 --> 00:49:10,000
코드는 좀 더 관여 할 것입니다.

872
00:49:10,000 --> 00:49:12,000
아니타는 무대에 여기에서 더 많은 작업을해야 할 일을했을 것이다.

873
00:49:12,000 --> 00:49:15,000
그러나 우리는 확실히 구조의 종류를 구현할 수 있습니다.

874
00:49:15,000 --> 00:49:19,000
시간을 실행의 측면에서하지만, 어떻게 실행 시간 것

875
00:49:19,000 --> 00:49:24,000
지금 연결 목록에서 숫자 n을 찾는 아니타은?

876
00:49:24,000 --> 00:49:27,000
n의 아직도 큰 O는, 그래서 선형 검색보다 더 좋은 없어요.

877
00:49:27,000 --> 00:49:29,000
우리는 다시하지만 이진 검색을 수행 할 수 없습니다.

878
00:49:29,000 --> 00:49:34,000
경우 그건 이유는 무엇입니까? 당신은 주변에 점프 할 수 없습니다.

879
00:49:34,000 --> 00:49:36,000
우리는 분명 무대에있는 모든 인간을 참조하더라도

880
00:49:36,000 --> 00:49:39,000
와 아니타는 "다음은 그 목록의 중간는"을 eyeballed하고, 말 수

881
00:49:39,000 --> 00:49:42,000
그녀는 컴퓨터 프로그램에 있다면 그녀는 모를 걸

882
00:49:42,000 --> 00:49:47,000
그녀가 가진 유일한 것은 시나리오의 시작에 래치하기 때문이다

883
00:49:47,000 --> 00:49:50,000
첫 번째 포인터이었다 루카스,이었다.

884
00:49:50,000 --> 00:49:53,000
그녀는 반드시 해당 링크를 따라해야

885
00:49:53,000 --> 00:49:56,000
그녀는 대략 중간을 발견 할 때까지 그녀의 방법을 계산하면,

886
00:49:56,000 --> 00:49:58,000
심지어 다음, 그녀는 중간에 도달하면 금방 알 수 없을거야

887
00:49:58,000 --> 00:50:01,000
그녀는 얼마나 많이 알아 끝으로 모든 길을 가겠하지 않는

888
00:50:01,000 --> 00:50:05,000
당신이 가지고하지 않는 한 다음 backtracks, 그건 너무 어려운 일이 될 거에요

889
00:50:05,000 --> 00:50:07,000
일종의 이중 연결 목록입니다.

890
00:50:07,000 --> 00:50:10,000
>> 오늘 몇 가지 문제를 해결하지만, 다른 사람을 소개합니다.

891
00:50:10,000 --> 00:50:12,000
다른 데이터 구조 모두에 대해 무엇입니까?

892
00:50:12,000 --> 00:50:15,000
이것은 메이 하우스에서 트레이의 사진입니다

893
00:50:15,000 --> 00:50:19,000
이 경우에, 우리는 또한 종류의 이미 얘기 한 데이터 구조를 갖추고 있습니다.

894
00:50:19,000 --> 00:50:22,000
우리는 메모리의 맥락에서 스택에 대해 얘기

895
00:50:22,000 --> 00:50:26,000
그는 종류의 의도적으로 물건을 때문에 메모리의 측면에서 스택

896
00:50:26,000 --> 00:50:31,000
효과적으로 상단에 층을 더 많은 물건을 가진 데이터 구조입니다.

897
00:50:31,000 --> 00:50:35,000
그러나 스택에 대한 흥미로운 점은 같은, 실제로는 경우가 있습니다

898
00:50:35,000 --> 00:50:38,000
이 데이터 구조의 특별한 친절 있다는 것입니다.

899
00:50:38,000 --> 00:50:42,000
이 데이터 구조입니다 상기의 첫 번째 요소

900
00:50:42,000 --> 00:50:46,000
마지막 요소가 부족합니다.

901
00:50:46,000 --> 00:50:50,000
당신은 스택에 넣어 할 첫 번째 줄의 경우

902
00:50:50,000 --> 00:50:53,000
당신은 불행히도 스택 해제 할 마지막 줄이 될거야

903
00:50:53,000 --> 00:50:55,000
그건 좋은 일에 쓰일 것 없어.

904
00:50:55,000 --> 00:50:58,000
반대로, 당신은 다른 방법으로 주위에 생각 할 수 있습니다

905
00:50:58,000 --> 00:51:02,000
의 마지막은 첫 번째가 부족합니다.

906
00:51:02,000 --> 00:51:05,000
>> 이제 모든 시나리오는 스택을 갖는 곳 신경 오는거야

907
00:51:05,000 --> 00:51:08,000
해당 속성이 데이터 구조

908
00:51:08,000 --> 00:51:13,000
먼저 알아,의 마지막으로, 실제로 뛰어난입니까?

909
00:51:13,000 --> 00:51:16,000
그건 좋은 일이야? 하는 건 나쁜 짓이야?

910
00:51:16,000 --> 00:51:19,000
트레이는 모든 동일하지 않는다면 분명히 나쁜 일이야

911
00:51:19,000 --> 00:51:21,000
그리고 그들은 모두 특별한 다른 색상이나 이것 저것있었습니다

912
00:51:21,000 --> 00:51:24,000
당신이 원하는 색상은 아래의 모든 방법입니다.

913
00:51:24,000 --> 00:51:26,000
물론, 큰 노력 없이는 얻을 수 없습니다.

914
00:51:26,000 --> 00:51:28,000
당신은 상단에서 시작하여 내려 오면서해야합니다.

915
00:51:28,000 --> 00:51:31,000
마찬가지로,이 팬 선수 중 한 일인가

916
00:51:31,000 --> 00:51:34,000
누구가 아이폰과 선을 얻으려고 밤을 기다립니다

917
00:51:34,000 --> 00:51:36,000
이런 곳에서?

918
00:51:36,000 --> 00:51:40,000
는 것도 좋지 않을까 경우 애플 스토어

919
00:51:40,000 --> 00:51:42,000
스택 데이터 구조였다?

920
00:51:42,000 --> 00:51:44,000
야호? 정말?

921
00:51:44,000 --> 00:51:47,000
그것은 마지막 순간에 표시하는 사람들 만 좋아

922
00:51:47,000 --> 00:51:50,000
다음 대기열을 뜯어 낸하게.

923
00:51:50,000 --> 00:51:52,000
그리고 사실, 너무 경사되었다는 사실은 큐를 말을하고

924
00:51:52,000 --> 00:51:56,000
우리는 이러한 종류의 데이터 구조의 부를 것이다 것과 실제로 일치

925
00:51:56,000 --> 00:51:59,000
순서 상관있어 현실에,

926
00:51:59,000 --> 00:52:02,000
당신은 최초의 하나가 먼저 아웃되고 싶어

927
00:52:02,000 --> 00:52:04,000
인간의 공정성을 위해서 만합니다.

928
00:52:04,000 --> 00:52:07,000
우리는 일반적으로 큐 데이터 구조는 전화드립니다.

929
00:52:07,000 --> 00:52:11,000
>> 이 연결리스트 외에, 우리가이 같은 기본적인 아이디어를 사용할 수 있습니다 밝혀

930
00:52:11,000 --> 00:52:15,000
및 문제에 대한 해결책의 새로운 및 다른 유형을 만들기 시작합니다.

931
00:52:15,000 --> 00:52:19,000
예를 들어, 스택의 경우, 우리는 스택을 나타냅니다

932
00:52:19,000 --> 00:52:22,000
이와 같은 데이터 구조를 사용하여, 나는 제안합니다.

933
00:52:22,000 --> 00:52:26,000
이 경우, 내가 구조체를 선언 한 결과,이 구조의 내부에 말했듯이

934
00:52:26,000 --> 00:52:30,000
숫자의 배열 후라는 변수 크기입니다

935
00:52:30,000 --> 00:52:33,000
나는이 일을 스택에게 전화 하겠어.

936
00:52:33,000 --> 00:52:35,000
자,이 사실은 작동 왜?

937
00:52:35,000 --> 00:52:43,000
스택의 경우, 나는 배열로 화면에이 효과적으로 그려 수 있습니다.

938
00:52:43,000 --> 00:52:47,000
여기 내 스택입니다. 저건 내 번호입니다.

939
00:52:47,000 --> 00:52:50,000
그리고 우리는,이,이,이로이 일을 그려 줄께요.

940
00:52:50,000 --> 00:52:53,000
그리고 내가 여기 다른 데이터 멤버가

941
00:52:53,000 --> 00:52:58,000
크기라고하는, 그래서이 크기이며,이 숫자로

942
00:52:58,000 --> 00:53:02,000
그리고 집합 적으로, 여기 온 아이 패드 하나의 스택 구조를 나타냅니다.

943
00:53:02,000 --> 00:53:07,000
이제 기본적으로 크기는 아마 0으로 초기화되어야한다는 거죠

944
00:53:07,000 --> 00:53:11,000
그리고 처음 숫자의 배열의 내부이야

945
00:53:11,000 --> 00:53:14,000
처음 배열을 할당 할 때?

946
00:53:14,000 --> 00:53:16,000
쓰레기. 누가 알 겠어? 그리고 실제로 중요하지 않습니다.

947
00:53:16,000 --> 00:53:20,000
그것은 완전히 무작위로,이 1, 2, 3, 4, 5 인 경우 중요하지 않습니다

948
00:53:20,000 --> 00:53:25,000
내 구조에 저장 운이 너무 오래 알고 있기 때문에 그 스택의 크기

949
00:53:25,000 --> 00:53:29,000
0, 그럼 프로그래밍다시피, 배열의 요소의 보지 않습니다.

950
00:53:29,000 --> 00:53:31,000
거기 뭐가 중요하지 않습니다.

951
00:53:31,000 --> 00:53:34,000
0 크기의 의미가 될 것 같은 사람들 보지 마.

952
00:53:34,000 --> 00:53:38,000
>> 하지만 가서 스택에 무언가를 삽입하고 싶.

953
00:53:38,000 --> 00:53:42,000
, 전 5 번을 삽입 할, 그래서 제가 여기 5 번을 넣어

954
00:53:42,000 --> 00:53:45,000
그럼 내가 여기서 무슨 일을 내려 놓고 어떻게해야합니까?

955
00:53:45,000 --> 00:53:48,000
지금은 실제로 크기에 1을 내려 놓고 것이다

956
00:53:48,000 --> 00:53:50,000
지금 스택의 크기는 1입니다.

957
00:53:50,000 --> 00:53:53,000
제가 가서 번호를 삽입하면, 무슨합시다 7 옆에 말을?

958
00:53:53,000 --> 00:53:57,000
이것은 다음 2로 업데이트됩니다, 그리고 우리는 9 할거야

959
00:53:57,000 --> 00:54:02,000
그리고 다음이 3으로 업데이트됩니다.

960
00:54:02,000 --> 00:54:05,000
그러나 스택의 현재 흥미로운 기능입니다

961
00:54:05,000 --> 00:54:09,000
난 내가 나타하려면 어떤 요소를 제거해야 해요

962
00:54:09,000 --> 00:54:12,000
스택의 일에서, 그래서 얘기하는 거요?

963
00:54:12,000 --> 00:54:14,000
9가는 제일 먼저 것입니다.

964
00:54:14,000 --> 00:54:18,000
나는 스택에서 요소를 나타하려면 어떻게 사진 변경해야합니다

965
00:54:18,000 --> 00:54:20,000
많은 메이의 트레이를 좋아하세요?

966
00:54:20,000 --> 00:54:22,000
그래. 2 >> [학생] 세트 크기입니다.

967
00:54:22,000 --> 00:54:27,000
맞아요, 제가 모두 2로 크기를 설정하고 있으며, 그 배열을 어떻게해야 하죠?

968
00:54:27,000 --> 00:54:29,000
전 아무것도 할 필요가 없습니다.

969
00:54:29,000 --> 00:54:32,000
내 말은, 그저 항문을 위해이 0 또는 -1 또는 의미 뭔가를 넣어 수

970
00:54:32,000 --> 00:54:34,000
이 합법적 값이지만, 그건 문제가되지 않습니다 때문에

971
00:54:34,000 --> 00:54:37,000
나는 얼마나 오래 배열 자체의 외부에 기록 할 수 있습니다

972
00:54:37,000 --> 00:54:41,000
그래서 알고 만이 배열의 첫 번째 두 요소보세요.

973
00:54:41,000 --> 00:54:47,000
자, 내가 가서이 배열에 숫자 8을 추가하면 어떻게 그림 다음 변경합니까?

974
00:54:47,000 --> 00:54:50,000
이 8되고,이 3이됩니다.

975
00:54:50,000 --> 00:54:52,000
여기 몇 모서리를 절단거야.

976
00:54:52,000 --> 00:54:56,000
이제 우리는 5, 7, 8을 가지고 우리는 다시 3의 크기로하고 있습니다.

977
00:54:56,000 --> 00:54:58,000
이것은 구현하기 아주 간단합니다

978
00:54:58,000 --> 00:55:06,000
하지만 때 우리는이 디자인 결정을 후회하는거야?

979
00:55:06,000 --> 00:55:09,000
언제 일이 매우 잘못 시작합니까? 그래.

980
00:55:09,000 --> 00:55:11,000
[안 들리게 학생 응답]

981
00:55:11,000 --> 00:55:13,000
다시 가서 집어 넣는 첫 번째 요소를 할 때

982
00:55:13,000 --> 00:55:18,000
>> 스택은 후드 아래에 배열하더라도 그것은 여기 변

983
00:55:18,000 --> 00:55:21,000
우리가 얘기를 시작했습니다 이러한 데이터 구조는 일반적으로 알려져 있습니다

984
00:55:21,000 --> 00:55:25,000
추상 데이터 구조된다들이 구현하는 방법을

985
00:55:25,000 --> 00:55:27,000
완전히 중요한 게 있습니다.

986
00:55:27,000 --> 00:55:31,000
스택 같은 데이터 구조를 지원을 추가하도록되어

987
00:55:31,000 --> 00:55:35,000
스택에 트레이를 밀어 푸시 같은 운영,

988
00:55:35,000 --> 00:55:39,000
그리고 스택에서 요소를 제거하고, 그거야 팝업.

989
00:55:39,000 --> 00:55:43,000
당신은 이미 구현 다른 사람의 코드를 다운로드 할 경우

990
00:55:43,000 --> 00:55:46,000
이 일이 스택을 호출, 그 사람이 쓴 것

991
00:55:46,000 --> 00:55:49,000
당신을위한 두 기능은 푸시와 그의 목적 삶의 팝업,

992
00:55:49,000 --> 00:55:51,000
정확히 그런 짓을하는 것이다.

993
00:55:51,000 --> 00:55:54,000
귀하 또는 그 사람 자신이 그 프로그램을 구현 자

994
00:55:54,000 --> 00:55:58,000
구현하는 방법을 결정하는 완전히 하나였습니다 것이다

995
00:55:58,000 --> 00:56:00,000
후드 아래에 밀어과 터지는의 의미

996
00:56:00,000 --> 00:56:03,000
또는 밀 터지는의 기능.

997
00:56:03,000 --> 00:56:07,000
그리고 여기에 약간 멍청한 결정을 한

998
00:56:07,000 --> 00:56:10,000
이 간단한 데이터 구조 이유를 내 스택을 구현하여?

999
00:56:10,000 --> 00:56:12,000
때이 데이터 구조 휴식을합니까?

1000
00:56:12,000 --> 00:56:18,000
어는 시점에서 사용자가 푸시 호출하면 예를 들어, 오류를 반환해야합니까?

1001
00:56:18,000 --> 00:56:20,000
[학생] 더 이상 공간이없는 경우.

1002
00:56:20,000 --> 00:56:23,000
맞아요, 더 이상 공간, 제가 용량을 초과 한 경우, 만약이

1003
00:56:23,000 --> 00:56:27,000
하지만 그 위험이 글로벌 상수 어떤 종류의 것을 제안 때문에 이는 모두 대문자입니다.

1004
00:56:27,000 --> 00:56:30,000
음, 그럼 난 그냥 미안 해요, 다른 가치를 강요 할 수 "라고해야 겠어요

1005
00:56:30,000 --> 00:56:32,000
스택에 "더 메이처럼.

1006
00:56:32,000 --> 00:56:36,000
>> 어떤 시점에서, 사람들은 그 작은 캐비닛의 상단 부분을 공격 할거야.

1007
00:56:36,000 --> 00:56:39,000
스택에 더 이상의 공간이나 용량이 오류가 어떤 종류가있는 시점에서 없습니다.

1008
00:56:39,000 --> 00:56:42,000
그들은 트레이 다른 곳, 다른 곳에서 요소를 넣어해야

1009
00:56:42,000 --> 00:56:44,000
또는 아무데도 전혀 요.

1010
00:56:44,000 --> 00:56:47,000
이제 큐와 함께, 우리는 그것을 다르게 약간을 구현 수 있습니다.

1011
00:56:47,000 --> 00:56:50,000
대기열이 후드 아래에, 그것은 구현 될 수 있다는 점에서 약간 다릅니다

1012
00:56:50,000 --> 00:56:54,000
배열로, 왜,이 케이스는, 내가 제안 무엇입니까

1013
00:56:54,000 --> 00:56:59,000
또한 목록의 머리를 대표하는 헤드 요소를 가지고하는 것은,

1014
00:56:59,000 --> 00:57:06,000
크기뿐만 아니라 목록의 앞에 애플 스토어에서 줄의 처음?

1015
00:57:06,000 --> 00:57:14,000
내가 왜 여기 데이터의 추가 조각을해야합니까?

1016
00:57:14,000 --> 00:57:16,000
무엇 숫자로 생각

1017
00:57:16,000 --> 00:57:18,000
제가 그려 한 경우는 다음과 같습니다.

1018
00:57:18,000 --> 00:57:21,000
이 지금 대신 스택의 큐입니다 가정

1019
00:57:21,000 --> 00:57:24,000
되는 - 그냥 애플 스토어 - 큐 같은 차이는 공정입니다.

1020
00:57:24,000 --> 00:57:27,000
목록의 시작 부분에 라인의 첫 번째 사람,이 경우 5 번,

1021
00:57:27,000 --> 00:57:30,000
그 또는 그녀가 먼저 가게에 알려 할 것이다.

1022
00:57:30,000 --> 00:57:32,000
가 그런 짓을 보자.

1023
00:57:32,000 --> 00:57:35,000
이 애플 스토어 지금이 순간에 내 큐의 상태이며, 있다고 가정합시다

1024
00:57:35,000 --> 00:57:39,000
열리고 처음, 숫자 5, 가게에 주도되어 있습니다.

1025
00:57:39,000 --> 00:57:43,000
어떻게 내가 처음으로 사람을 해제 대기 한 지금 그림을 변경하려면 어떻게해야합니까

1026
00:57:43,000 --> 00:57:47,000
줄의 앞에?

1027
00:57:47,000 --> 00:57:50,000
그게 뭐지? >> [학생] 대기열을 변경합니다.

1028
00:57:50,000 --> 00:57:52,000
머리를 변경, 그래서 5 사라집니다.

1029
00:57:52,000 --> 00:57:56,000
현실에서는이 작업을 수행하는 것처럼 - 최선의 방법이야?

1030
00:57:56,000 --> 00:58:00,000
이 사람이 사라 것처럼 현실에서, 그건.

1031
00:58:00,000 --> 00:58:03,000
숫자 7은 실제 매장에 어떤 거죠?

1032
00:58:03,000 --> 00:58:05,000
그들은 앞으로 큰 단계를 걸립니다.

1033
00:58:05,000 --> 00:58:08,000
>> 이 배열 할 때,하지만 우리는 감사 온거야

1034
00:58:08,000 --> 00:58:10,000
주위에 물건을 이동?

1035
00:58:10,000 --> 00:58:12,000
그게 당신의 시간 낭비의 일종 이죠?

1036
00:58:12,000 --> 00:58:16,000
첫 번째 사람을 가지고 같이 왜 이렇게 항문해야하지

1037
00:58:16,000 --> 00:58:21,000
메모리의 청크의 물리적 시작시 줄의 시작 부분에?

1038
00:58:21,000 --> 00:58:23,000
그래서 완전히 불필요한입니다. 이유는 무엇입니까?

1039
00:58:23,000 --> 00:58:26,000
난 그냥 대신 무엇을 기억하세요? >> [안 들리게 학생 응답]

1040
00:58:26,000 --> 00:58:30,000
맞아, 난 그냥이 추가 데이터 구성원 머리 기억

1041
00:58:30,000 --> 00:58:34,000
이제 목록의 머리는 잠시 전이었고 이는 더 이상 0하지 않을 수 있습니다.

1042
00:58:34,000 --> 00:58:39,000
이제 실제로 숫자 1입니다. 이런 식으로, 내가 약간의 최적화를.

1043
00:58:39,000 --> 00:58:44,000
나는 애플 스토어에서 줄의 시작 줄에서 사람을 해제 대기 한해서

1044
00:58:44,000 --> 00:58:47,000
모두가 선형 동작입니다 리콜, 이동하는 것은 아닙니다.

1045
00:58:47,000 --> 00:58:50,000
내가 대신 일정한 시간 만 투자 할 수

1046
00:58:50,000 --> 00:58:53,000
그리고 훨씬 빠른 응답을 얻을 수 있습니다.

1047
00:58:53,000 --> 00:58:56,000
하지만 돈을 지불 가격은 추가 성능을 얻기 위해 무엇

1048
00:58:56,000 --> 00:58:58,000
모두를 변화 할 필요가 안돼?

1049
00:58:58,000 --> 00:59:01,000
네. >> [안 들리게 학생 응답]

1050
00:59:01,000 --> 00:59:04,000
더 많은 사람들을 추가 할 수 있습니다, 그게 문제가 직교입니다

1051
00:59:04,000 --> 00:59:07,000
우리가 주변 사람들을 변화가 아니라는 사실합니다.

1052
00:59:07,000 --> 00:59:11,000
우리가 모든 사람을 이동 싫든 여부 그래, 아직도 배열

1053
00:59:11,000 --> 00:59:13,000
오, 난 괜찮아, 자네 말이 무슨 뜻인지를 참조하십시오.

1054
00:59:13,000 --> 00:59:16,000
사실, 난 당신이 거의하지만 그건에 말에 동의 해

1055
00:59:16,000 --> 00:59:19,000
우리는 이제 더 이상이 배열의 시작을 사용 할 수 없어

1056
00:59:19,000 --> 00:59:22,000
I 5를 제거하는 경우 때문에, 그럼 7을 제거합니다.

1057
00:59:22,000 --> 00:59:24,000
하지만은 오른쪽에있는 사람을 넣어.

1058
00:59:24,000 --> 00:59:28,000
>> 전 공간을 낭비하는 거 느낌, 결국 제 큐 전혀 아무것도로 분해

1059
00:59:28,000 --> 00:59:31,000
그래서 우리는 그냥 사람들이 빙 둘러을 가질 수

1060
00:59:31,000 --> 00:59:35,000
우리는, 원형 구조의 일종의 정말이 배열을 생각할 수

1061
00:59:35,000 --> 00:59:38,000
우리는 빙 둘러의 정렬을 수행하는 C에서 뭘 연산자를 사용할 수 있습니까?

1062
00:59:38,000 --> 00:59:40,000
[안 들리게 학생 응답] >> 모듈로 연산자.

1063
00:59:40,000 --> 00:59:43,000
그것은 당신이 빙 둘러 어떻게해야합니까을 통해 생각 좀 성가신 것

1064
00:59:43,000 --> 00:59:46,000
하지만, 우리가 할 수있는, 우리는 그 줄의 앞으로 사용하는 일에 사람들을 묻어 버릴 수 있겠구나 싶었는데 ...

1065
00:59:46,000 --> 00:59:52,000
하지만 우리는 그 줄의 실제 머리는 실제로이 머리 변수와 함께 기억 해요.

1066
00:59:52,000 --> 00:59:57,000
뭐,하지만 우리의 목표 궁극적으로 대신하는 경우

1067
00:59:57,000 --> 01:00:00,000
우리는 아니타와 무대에서 여기처럼, 숫자를 찾아하는 것이 었습니다

1068
01:00:00,000 --> 01:00:02,000
그런데 우리는 모든 세계의 가장까요?

1069
01:00:02,000 --> 01:00:05,000
우리는 배열에서 허용하는 것보다 더 정교을 원

1070
01:00:05,000 --> 01:00:09,000
우리가 동적으로 데이터 구조를 확장 할 수있는 기능을 원하기 때문에.

1071
01:00:09,000 --> 01:00:12,000
하지만 우리는 우리가 지적하는 것을에 의존해야하고 싶지 않아

1072
01:00:12,000 --> 01:00:15,000
첫 번째 강의에서, 최적의 알고리즘 아니었다

1073
01:00:15,000 --> 01:00:17,000
선형 검색의.

1074
01:00:17,000 --> 01:00:21,000
그것은 당신이 실제로 달성 할 수 있다는 판명

1075
01:00:21,000 --> 01:00:24,000
적어도 일정한 시간 가까이된다 아니타 같은 사람,

1076
01:00:24,000 --> 01:00:27,000
그녀가 데이터 구조를 구성하는 경우 연결 목록이되어서는 안된다,

1077
01:00:27,000 --> 01:00:30,000
스택이되지, 대기열이되지 않게, 수 사실,

1078
01:00:30,000 --> 01:00:33,000
그녀는 일을 찾아 할 수있는 데이터 구조 마련

1079
01:00:33,000 --> 01:00:37,000
하는 단어뿐 아니라 숫자, 왜에서 우리는 일정한 시간을 전화 할게.

1080
01:00:37,000 --> 01:00:40,000
>> 그리고 사실, 앞서 찾고,이 클래스의 psets 중 하나는 거의 항상

1081
01:00:40,000 --> 01:00:43,000
맞춤법 검사기의 구현으로서,

1082
01:00:43,000 --> 01:00:46,000
우리는 다시 몇 가지 150000 영어 단어 당신을주고 목표에 있습니다

1083
01:00:46,000 --> 01:00:51,000
메모리에 사람들을로드하고 빠르게 양식의 질문에 답변 할 수

1084
01:00:51,000 --> 01:00:54,000
이 단어가 올바르게 입력 했습니까?

1085
01:00:54,000 --> 01:00:58,000
그 대답을 모두 150,000 단어를 반복한다면 그리고 정말 싫어.

1086
01:00:58,000 --> 01:01:02,000
그러나, 사실, 우리는 매우 빠른 시간에 할 수있는 볼 수 있습니다.

1087
01:01:02,000 --> 01:01:06,000
그리고 해시 테이블이라는 구현 무언가를, 참여거야

1088
01:01:06,000 --> 01:01:09,000
그리고 한눈에 해시 테이블이라는 것은가는 경우에도

1089
01:01:09,000 --> 01:01:12,000
이 슈퍼 빠른 응답 시간 우리가 달성 해,

1090
01:01:12,000 --> 01:01:18,000
그 문제가 실​​제로 있다는 것을 밝혀졌다.

1091
01:01:18,000 --> 01:01:23,000
가 - 다시 전화이 일을 구현하는 시간을 때, 나는 다시하고 있어요.

1092
01:01:23,000 --> 01:01:25,000
내가 여기있는 유일한 사람입니다.

1093
01:01:25,000 --> 01:01:28,000
그 때이 일을 구현하는 때, 해시 테이블이라고

1094
01:01:28,000 --> 01:01:30,000
우리는 결정을 내려야 할거야.

1095
01:01:30,000 --> 01:01:32,000
이런 일이 실제로 얼마나 큰해야하나요?

1096
01:01:32,000 --> 01:01:36,000
그리고 우리는이 해시 테이블에 삽입 번호를 시작할 때,

1097
01:01:36,000 --> 01:01:38,000
어떻게 이런 식으로 그들을 저장하는거야

1098
01:01:38,000 --> 01:01:42,000
우리가 그들을 다 떨어질 때 우리는 빨리 다시 꺼내 수?

1099
01:01:42,000 --> 01:01:45,000
하지만 우리는 머지 않아 볼 수 있습니다 그 질문에

1100
01:01:45,000 --> 01:01:48,000
모든 사람들의 생일 클래스에있을 때 매우 밀접한 관계가있는 것입니다.

1101
01:01:48,000 --> 01:01:51,000
그것은이 방에서, 우리는 몇 십 명을 가진 걸 밝혀

1102
01:01:51,000 --> 01:01:56,000
우리 둘은 같은 생일은 아마 매우 높은 가지고있는 확률은 너무.

1103
01:01:56,000 --> 01:01:58,000
만 40 우리이 방에가 일인가?

1104
01:01:58,000 --> 01:02:02,000
같은 생일을 가진 두 사람의 확률은 무엇입니까?

1105
01:02:02,000 --> 01:02:04,000
[학생] 50 % 이상.

1106
01:02:04,000 --> 01:02:06,000
네, 50 % 이상. 사실, 나는 차트를 가져 왔어.

1107
01:02:06,000 --> 01:02:08,000
밖 및집니다이 정말 빠져 있습니다 미리보기-

1108
01:02:08,000 --> 01:02:12,000
이 방에있는 우리의 유일한 58, 우리의 2의 확률이있을 경우

1109
01:02:12,000 --> 01:02:16,000
같은 생일을 갖는 것은, 거의 100 % 상당히 높은

1110
01:02:16,000 --> 01:02:20,000
그리고 수요일에 우리의 상처를 많이 일으킬거야.

1111
01:02:20,000 --> 01:02:24,000
>> 그 말과 함께, 여기서 휴정 보자. 우리는 수요일에 표시됩니다.

1112
01:02:24,000 --> 01:02:28,000
[박수]

1113
01:02:28,000 --> 01:02:30,000
[CS50.TV]