1
00:00:00,000 --> 00:00:11,860

2
00:00:11,860 --> 00:00:13,120
>> 스피커 1 : 모든 오른쪽, 그래서 우리는 다시 수 있습니다.

3
00:00:13,120 --> 00:00:14,480
CS50에 오신 것을 환영합니다.

4
00:00:14,480 --> 00:00:16,510
이것은 일주일 내내의 끝입니다.

5
00:00:16,510 --> 00:00:20,200
그래서 지난 시간을 기억, 우리는 시작
조금 더 정교한보고

6
00:00:20,200 --> 00:00:21,100
데이터 구조.

7
00:00:21,100 --> 00:00:25,110
지금까지 있기 때문에, 모두 우리가 정말 있었다
우리의 처분이, 배열했다.

8
00:00:25,110 --> 00:00:29,340
>> 그러나 우리는 배열을 무시하지 않기 전에
모든 흥미있는 참으로

9
00:00:29,340 --> 00:00:33,570
사실 중 일부는 무엇입니까합니다
이 간단한 데이터 플러스

10
00:00:33,570 --> 00:00:34,560
구조 지금까지?

11
00:00:34,560 --> 00:00:36,110
그것은 잘은 무엇입니까?

12
00:00:36,110 --> 00:00:39,450
지금까지 우리가 본 것처럼?

13
00:00:39,450 --> 00:00:42,540
당신은 무엇을 가지고 있습니까?

14
00:00:42,540 --> 00:00:44,028
아무것도.

15
00:00:44,028 --> 00:00:45,020
>> 학생 : [들림].

16
00:00:45,020 --> 00:00:45,395
>> 스피커 1 : 저게 뭐죠?

17
00:00:45,395 --> 00:00:46,410
>> 학생 : [들림].

18
00:00:46,410 --> 00:00:47,000
>> 스피커 1 : 고정 크기입니다.

19
00:00:47,000 --> 00:00:51,260
자, 그럼 왜 크기가 고정 그래도 좋은가?

20
00:00:51,260 --> 00:00:53,180
>> 학생 : [들림].

21
00:00:53,180 --> 00:00:56,240
>> 스피커 1 : OK, 그래서에 효율적
당신을 할당 할 수 있다는 의미

22
00:00:56,240 --> 00:01:00,070
공간의 고정 된 양, 희망
정확하게으로 많이

23
00:01:00,070 --> 00:01:01,180
공간을 당신이 원하는대로.

24
00:01:01,180 --> 00:01:02,720
그래서 절대적으로 플러스가 될 수 있습니다.

25
00:01:02,720 --> 00:01:06,530
>> 또 다른 배열해서 측면은 무엇입니까?

26
00:01:06,530 --> 00:01:07,610
그래?

27
00:01:07,610 --> 00:01:08,750
>> 학생 : [들림].

28
00:01:08,750 --> 00:01:09,550
>> 스피커 1 : 모든 - 네?

29
00:01:09,550 --> 00:01:11,270
>> 학생 : [들림].

30
00:01:11,270 --> 00:01:13,620
>> 스피커 1 : 메모리에있는 모든 상자
또는 서로 옆에.

31
00:01:13,620 --> 00:01:15,220
그리고 그 도움이된다 - 왜?

32
00:01:15,220 --> 00:01:15,970
그것은 매우 사실입니다.

33
00:01:15,970 --> 00:01:18,611
하지만 어떻게 우리가 진실을 악용 할 수 있습니까?

34
00:01:18,611 --> 00:01:21,500
>> 학생 : [들림].

35
00:01:21,500 --> 00:01:24,490
>> 스피커 1 : 맞아요, 우리가 추적 할 수의
모든 것이 알아서 곳

36
00:01:24,490 --> 00:01:28,560
하나, 즉 주소의 주소
메모리의 청크의 첫 번째 바이트.

37
00:01:28,560 --> 00:01:30,420
또는 문자열의 경우,
첫 번째의 주소

38
00:01:30,420 --> 00:01:31,460
해당 문자열에있는 문자.

39
00:01:31,460 --> 00:01:33,330
거기에서, 우리는 찾을 수 있습니다
문자열의 끝.

40
00:01:33,330 --> 00:01:35,710
우리는 두 번째 요소를 찾을 수 있습니다
세 번째 요소, 등등.

41
00:01:35,710 --> 00:01:38,740
>> 그리고 그 설명이 너무 멋진 방법
기능은 배열이 우리에게주는 것입니다

42
00:01:38,740 --> 00:01:40,020
무작위 액세스 할 수 있습니다.

43
00:01:40,020 --> 00:01:44,330
그냥 대괄호를 사용하여
표기법과 숫자, 당신은로 이동할 수 있습니다

44
00:01:44,330 --> 00:01:48,070
배열의 특정 요소
일정 시간, 큰 O에

45
00:01:48,070 --> 00:01:49,810
하나 말하자면.

46
00:01:49,810 --> 00:01:51,080
>> 하지만 몇 가지 단점이있었습니다.

47
00:01:51,080 --> 00:01:53,110
배열은 매우 쉽게 무엇을하지?

48
00:01:53,110 --> 00:01:55,810

49
00:01:55,810 --> 00:01:57,170
그것은 잘 게 아니에요?

50
00:01:57,170 --> 00:01:58,810
>> 학생 : [들림].

51
00:01:58,810 --> 00:01:59,860
>> 스피커 1 : 저게 뭐죠?

52
00:01:59,860 --> 00:02:00,530
>> 학생 : [들림].

53
00:02:00,530 --> 00:02:01,460
>> 스피커 1 : 크기에 확장.

54
00:02:01,460 --> 00:02:04,800
배열의 단점이 될 수 있도록
무엇의 정확히 반대

55
00:02:04,800 --> 00:02:05,540
그나입니다.

56
00:02:05,540 --> 00:02:07,610
그래서 단점 중 하나는
그것은 고정 된 크기의합니다.

57
00:02:07,610 --> 00:02:09,400
그래서 당신은 정말 성장을 할 수 없습니다.

58
00:02:09,400 --> 00:02:13,510
당신의 큰 덩어리를 재 할당 할 수
기억하고 이전 요소를 이동

59
00:02:13,510 --> 00:02:14,460
새 배열.

60
00:02:14,460 --> 00:02:18,060
에 대해 다음 무료 이전 배열,
예, malloc을 또는 유사한을 사용하여

61
00:02:18,060 --> 00:02:21,180
realloc을 호출 기능을하는
재 할당 메모리.

62
00:02:21,180 --> 00:02:25,490
>> realloc과는 옆으로, 당신을 제공하기 위해 시도
배열에 다음의 메모리

63
00:02:25,490 --> 00:02:26,610
당신은 이미이 있는지 확인하십시오.

64
00:02:26,610 --> 00:02:28,740
그러나 물건을 움직일 수 있습니다
모두 주위에.

65
00:02:28,740 --> 00:02:30,710
그러나 짧은, 맞아, 비싸?

66
00:02:30,710 --> 00:02:33,440
때문에 당신의 메모리 청크가있는 경우
이 크기는하지만, 당신은 정말 하나를 원하는

67
00:02:33,440 --> 00:02:36,710
이 크기의, 당신은 유지하려는
원래의 요소는, 당신이

68
00:02:36,710 --> 00:02:40,510
대략 선형 시간 복사 프로세스
그에서 일어날 필요

69
00:02:40,510 --> 00:02:41,900
새로운 구 배열입니다.

70
00:02:41,900 --> 00:02:44,630
그리고 현실은 운영 체제를 요구하고있다
또 다시 시스템

71
00:02:44,630 --> 00:02:48,340
다시 메모리의 큰 덩어리를 시작할 수 있습니다에 대한
뿐만 아니라 당신에게 약간의 시간을 요할 수 있습니다.

72
00:02:48,340 --> 00:02:52,250
그래서 축복과 저주의
, 사실을 위장하는 이러한 배열

73
00:02:52,250 --> 00:02:53,860
고정 된 크기입니다.

74
00:02:53,860 --> 00:02:56,790
그러나 우리는 대신에 무언가를 소개하는 경우
이런 식으로, 어떤 우리가 링크라는

75
00:02:56,790 --> 00:03:00,580
목록, 우리는 몇 가지 그나를 얻을
몇 여기서 단점뿐만 아니라.

76
00:03:00,580 --> 00:03:05,780
>> 연결리스트는 단순히 데이터 그래서
구조는 다음에 C 구조체의 구성

77
00:03:05,780 --> 00:03:09,850
구조체, 리콜, 단지 경우,
하나 이상의 특정의 컨테이너

78
00:03:09,850 --> 00:03:11,100
변수의 종류.

79
00:03:11,100 --> 00:03:16,110
이 경우, 어떻게 데이터 유형을
구조체의 내부로 나타나는

80
00:03:16,110 --> 00:03:17,600
마지막으로 우리는 노드라고?

81
00:03:17,600 --> 00:03:19,380
이 사각형의 각 노드입니다.

82
00:03:19,380 --> 00:03:22,660
그리고 작은 사각형의 각
그것의 내부 데이터 형식입니다.

83
00:03:22,660 --> 00:03:25,300
우리는 어떤 종류의 말 했는가
그들은 월요일에 있었다?

84
00:03:25,300 --> 00:03:26,478
그래?

85
00:03:26,478 --> 00:03:27,870
>> 학생 : [들림].

86
00:03:27,870 --> 00:03:30,721
>> 스피커 1 : 변수의 포인터, 또는
더 구체적으로, 중간, n에,

87
00:03:30,721 --> 00:03:32,180
그리고 하단의 포인터.

88
00:03:32,180 --> 00:03:35,360
이들의 모두에서 32 비트 될 일이
이 CS50 같은 컴퓨터에서 최소

89
00:03:35,360 --> 00:03:37,980
기구, 그리고 그들이있어 너무
크기가 똑같이 그려.

90
00:03:37,980 --> 00:03:42,260
>> 그래서 포인터를 사용하는
분명히에 대한 생각?

91
00:03:42,260 --> 00:03:47,690
배열이있을 때 왜 지금이 화살표를 추가
너무 친절하고 깨끗하고 간단하게?

92
00:03:47,690 --> 00:03:50,460
포인터가 무엇을하고있다
우리 다음 각 노드에서?

93
00:03:50,460 --> 00:03:52,160
>> 학생 : [들림].

94
00:03:52,160 --> 00:03:52,465
>> SPEAKER 1 : 맞아요.

95
00:03:52,465 --> 00:03:54,120
여기서 당신을 말하고
다음 중 하나입니다.

96
00:03:54,120 --> 00:03:57,350
그래서 일종의의 비유를 사용
일종의 스레드를 사용하여

97
00:03:57,350 --> 00:03:59,180
함께 이러한 노드에 실을 꿰다.

98
00:03:59,180 --> 00:04:01,760
그리고 그것은 우리가하고있는 정확하게 무엇을
포인터 때문에 이러한 각

99
00:04:01,760 --> 00:04:06,360
메모리 덩어리가 될 수도 있고 그렇지 않을 수도 있습니다 또는
연속 다시 다시 다시하기

100
00:04:06,360 --> 00:04:09,500
RAM의 내부에 있기 때문에 때마다
malloc에​​ 말을 전화 나에게 충분히 제공

101
00:04:09,500 --> 00:04:12,510
새 노드에 대한 바이트, 그것은 수도
여기 아니면 여기에있을 수도 있습니다.

102
00:04:12,510 --> 00:04:13,120
그것은 여기에있을 수 있습니다.

103
00:04:13,120 --> 00:04:13,730
그것은 여기에있을 수 있습니다.

104
00:04:13,730 --> 00:04:14,640
당신은 모르겠어요.

105
00:04:14,640 --> 00:04:17,880
>> 하지만의 주소에 포인터를 사용
이러한 노드, 당신은 스티치 그 수

106
00:04:17,880 --> 00:04:22,370
함께 시각적으로 보이는 방법
이러한 일들이 경우에도 목록처럼

107
00:04:22,370 --> 00:04:26,770
모든 하나를 통해 확산
당신의 두 RAM 당신의 사기가바이트

108
00:04:26,770 --> 00:04:28,760
자신의 컴퓨터의 내부입니다.

109
00:04:28,760 --> 00:04:33,230
>> , 그 후에, 단점은 너무
연결리스트는 무엇입니까?

110
00:04:33,230 --> 00:04:34,670
우리가있어 가격은 무엇입니까
분명히 지불?

111
00:04:34,670 --> 00:04:36,010
>> 학생 : [들림].

112
00:04:36,010 --> 00:04:36,920
>> 스피커 1 : 더 많은 공간, 오른쪽?

113
00:04:36,920 --> 00:04:39,340
우리는이 경우에, 양을 두 배로 한
공간을 우리는 사라했기 때문에

114
00:04:39,340 --> 00:04:43,500
각 각 노드에 대한 32 비트에서
INT, 이제 우리는 64 비트를 가지고 있기 때문에

115
00:04:43,500 --> 00:04:45,050
뿐만 아니라 포인터 주변을 유지합니다.

116
00:04:45,050 --> 00:04:48,860
당신은 더 많은 효율성을 얻을 귀하의 구조체 경우
이 간단한 것보다 크다.

117
00:04:48,860 --> 00:04:52,020
당신은 실제로 내부에 학생이있는 경우
어느 문자열의 부부입니다

118
00:04:52,020 --> 00:04:55,430
이름과 집, 어쩌면 ID 번호,
모두 어쩌면 다른 분야.

119
00:04:55,430 --> 00:04:59,000
>> 당신은 충분히 큰 구조체 나있는 경우에는,
그리고 아마 포인터의 비용​​은

120
00:04:59,000 --> 00:05:00,010
아니 그렇게 큰 거래.

121
00:05:00,010 --> 00:05:03,570
이것은에서 코너 케이스의 비트
우리는 간단한 원시를 저장하는

122
00:05:03,570 --> 00:05:04,760
연결리스트의 내부입니다.

123
00:05:04,760 --> 00:05:05,790
그러나 중요한 점은 동일합니다.

124
00:05:05,790 --> 00:05:08,230
당신은 확실히 더 지출하고
메모리,하지만 당신은 있어요

125
00:05:08,230 --> 00:05:08,990
유연성을 제공합니다.

126
00:05:08,990 --> 00:05:12,280
지금은 요소를 추가하려는 경우 때문에,
이 목록의 시작 부분에,

127
00:05:12,280 --> 00:05:14,340
나는 새로운 노드를 할당해야합니다.

128
00:05:14,340 --> 00:05:17,180
난 그냥 사람들을 업데이트해야합니다
바로 이동하여 어떻게 든 화살

129
00:05:17,180 --> 00:05:17,980
주변에 몇몇 포인터.

130
00:05:17,980 --> 00:05:20,580
>> 나는에 무언가를 삽입하려면
목록의 중간에, 나는 필요 없어

131
00:05:20,580 --> 00:05:24,410
우리가 그랬던 것처럼 옆 사람을 밀어
자원 봉사자와 함께 주 '지난 사람

132
00:05:24,410 --> 00:05:25,700
배열을 나타낸다.

133
00:05:25,700 --> 00:05:29,470
난 그냥 새로운 노드를 할당 할 수 있습니다
다음 그냥 화살표를 가리

134
00:05:29,470 --> 00:05:32,290
다른 방향은하지 않기 때문에
실제에 남아있다

135
00:05:32,290 --> 00:05:35,670
내가 그린 것 같은 기억은 진정한 선
여기에 화면에.

136
00:05:35,670 --> 00:05:38,400
>> 그리고 마지막으로, 당신은 삽입 할 경우
목록의 끝에 뭔가가, 그것의

137
00:05:38,400 --> 00:05:39,210
더 쉽게.

138
00:05:39,210 --> 00:05:43,320
이것은 임의의 표기법의 일종이다
하지만 34의 포인터는 추측을.

139
00:05:43,320 --> 00:05:46,710
대부분의 포인터의 값은 무엇인가
옛날처럼의 가능성이 그려진 종류

140
00:05:46,710 --> 00:05:47,700
이 학교 안테나?

141
00:05:47,700 --> 00:05:48,920
>> 학생 : [들림].

142
00:05:48,920 --> 00:05:49,900
>> 스피커 1 : 그것은 아마 널 (null)입니다.

143
00:05:49,900 --> 00:05:52,710
그리고 실제로 그 하나 저자의
널의 표현입니다.

144
00:05:52,710 --> 00:05:56,310
당신 때문에 절대적으로 그리고 널의
알 필요가 어디에 링크의 끝

145
00:05:56,310 --> 00:06:00,050
목록은 다음 보관하지 않도록하고
이 화살표를 수행하고 다음과 같은

146
00:06:00,050 --> 00:06:01,170
어떤 쓰레기 값.

147
00:06:01,170 --> 00:06:06,230
그래서 널 (null)이 더 있다는 걸 의미하지 않습니다
숫자 34의 오른쪽에 더 많은 노드,

148
00:06:06,230 --> 00:06:07,200
이 경우합니다.

149
00:06:07,200 --> 00:06:10,270
>> 그래서 우리는 우리가 구현할 수있는 제안
코드에서이 노드입니다.

150
00:06:10,270 --> 00:06:12,130
그리고 우리는 이런 종류 봤어요
구문 전.

151
00:06:12,130 --> 00:06:15,090
typedef는 단지의 새로운 유형을 정의
우리는 같은 우리 동의어를 제공합니다

152
00:06:15,090 --> 00:06:17,100
문자열은 char *로를 위해이다.

153
00:06:17,100 --> 00:06:21,030
이 경우, 우리에게주는 것
속기 표기법 있도록 구조체 노드

154
00:06:21,030 --> 00:06:24,010
대신 같이 쓸 수있다
많은 청소기 노드.

155
00:06:24,010 --> 00:06:25,360
그것은 덜 자세한 많아요.

156
00:06:25,360 --> 00:06:30,080
>> 노드의 내부에 분명히 int이며
라는 N, 다음 구조체 노드 *

157
00:06:30,080 --> 00:06:34,670
이는 우리가 원하는 정확히 무엇을 의미
화살표는 다른, 포인터를 의미하는

158
00:06:34,670 --> 00:06:36,940
동일한 데이터 형식의 노드입니다.

159
00:06:36,940 --> 00:06:40,300
그리고 나는 우리가 구현할 수있는 제안
이 같은 검색 기능에서

160
00:06:40,300 --> 00:06:41,890
언뜻 보일 수 있습니다
조금 복잡.

161
00:06:41,890 --> 00:06:43,330
그러나 맥락에서 살펴 보자.

162
00:06:43,330 --> 00:06:45,480
>> 내가 여기서 기기에 갈 수 있습니다.

163
00:06:45,480 --> 00:06:48,460
저라는 파일을 열어 보자
목록 제로 점 H.

164
00:06:48,460 --> 00:06:53,950
그리고는 정의를 우리를 포함
그냥이 데이터에 순간 전보고

165
00:06:53,950 --> 00:06:55,390
형식은 노드를했다.

166
00:06:55,390 --> 00:06:57,350
그래서 우리는 그 점 h 파일에 넣었습니다.

167
00:06:57,350 --> 00:07:01,430
>> 그리고 옆으로도이 생각으로
당신은 볼 것입니다이 프로그램은

168
00:07:01,430 --> 00:07:05,410
모든 것을 복잡, 그것은 참으로입니다
로 프로그램을 작성 규칙

169
00:07:05,410 --> 00:07:10,270
당겨, 데이터 유형 같은 것들을 넣어
때로는 안에서의 상수

170
00:07:10,270 --> 00:07:13,210
헤더 파일과 반드시​​있는
귀하의 C 파일 확실 할 때

171
00:07:13,210 --> 00:07:17,370
프로그램은 크고 큰 얻을 수 있도록
모두에 보이도록 위치를 알고

172
00:07:17,370 --> 00:07:20,840
어떤 경우에는 문서 또는
다음과 같은 기본 사항에 대한

173
00:07:20,840 --> 00:07:22,360
어떤 종류의 정의.

174
00:07:22,360 --> 00:07:25,680
>> 지금은 목록 제로 점을 열면
C는 몇 가지를 알 수 있습니다.

175
00:07:25,680 --> 00:07:29,090
그것은 대부분의 몇 가지 헤더 파일을 포함
그 중 우리가 전에 본 적이.

176
00:07:29,090 --> 00:07:31,980
그것은 자신의 헤더 파일이 포함되어 있습니다.

177
00:07:31,980 --> 00:07:35,200
>> 그리고 옆으로, 그 이유는 두 배의
여기에 따옴표로 각도에 반대

178
00:07:35,200 --> 00:07:38,340
라인에 괄호가
거기 강조했다?

179
00:07:38,340 --> 00:07:39,180
>> 학생 : [들림].

180
00:07:39,180 --> 00:07:40,460
>> 스피커 1 : 네, 그래서 로컬 파일입니다.

181
00:07:40,460 --> 00:07:44,300
그것은 여기에 자신의 로컬 파일 그래서 경우
15 행에서, 예를 들어, 사용

182
00:07:44,300 --> 00:07:46,570
큰 따옴표 대신
꺾쇠 괄호의.

183
00:07:46,570 --> 00:07:48,270
>> 지금이 흥미로운 종류입니다.

184
00:07:48,270 --> 00:07:51,830
내가 지구를 선언 한 것을 알 수
라인 18이 프로그램에서 변수

185
00:07:51,830 --> 00:07:55,910
먼저 호출이되는 아이디어는
첫 번째에 대한 포인터가 될 것

186
00:07:55,910 --> 00:07:59,190
내 연결된 목록에서 노드, 난했습니다
내가했습니다 있기 때문에 null로 초기화

187
00:07:59,190 --> 00:08:02,310
어떤 실제를 할당되지
그러나 단지 노드.

188
00:08:02,310 --> 00:08:07,570
>> 그래서 이것은 우리가 그림으로 나타냅니다
그림으로의 순간 전보고

189
00:08:07,570 --> 00:08:10,090
지금까지의 해당 포인터
손으로면을 떠났다.

190
00:08:10,090 --> 00:08:12,260
그래서 지금 그 포인터
화살표를 가지고 있지 않습니다.

191
00:08:12,260 --> 00:08:14,590
그 대신 null입니다.

192
00:08:14,590 --> 00:08:17,880
그러나 그것은 있다는 것을 나타냅니다
첫 번째 실제의 주소

193
00:08:17,880 --> 00:08:19,480
이 목록의 노드입니다.

194
00:08:19,480 --> 00:08:22,120
그래서 나는 그것이 글로벌 구현했습니다
이 모든, 당신이 볼 수로 인해

195
00:08:22,120 --> 00:08:25,310
이 프로그램은 생활에서 구현합니다 않습니다
나를 위해 연결리스트.

196
00:08:25,310 --> 00:08:27,050
>> 지금은 여기에 몇 가지 프로토 타입을 가지고있다.

197
00:08:27,050 --> 00:08:31,190
나는 같은 기능을 구현하기로 결정
삭제, 삽입, 검색 및

198
00:08:31,190 --> 00:08:31,740
통과 -

199
00:08:31,740 --> 00:08:35,210
를 통해 마지막 단지 인 거리
목록 요소를 인쇄.

200
00:08:35,210 --> 00:08:36,750
그리고 지금 여기 내 메인 루틴이다.

201
00:08:36,750 --> 00:08:39,890
그리고 우리는에 너무 많은 시간을 할애하지 않습니다
이 이후 이러한 희망, 정렬입니다

202
00:08:39,890 --> 00:08:41,780
지금 쯤은 오래된 모자입니다.

203
00:08:41,780 --> 00:08:45,370
>> 나는 다음과 같은 작업을 수행 할거야
사용자가 협력하면서.

204
00:08:45,370 --> 00:08:47,300
하나 그래서, 인쇄 할거야
이 메뉴 중.

205
00:08:47,300 --> 00:08:49,420
그리고 난 같은 포맷 한
완전히 내가 할 수있는 것처럼.

206
00:08:49,420 --> 00:08:52,240
의미 하나 사용자 유형이있는 경우
그들은 뭔가를 삭제합니다.

207
00:08:52,240 --> 00:08:54,560
의미 두 가지의 사용자 유형에 해당하는 경우
그들은 무언가를 삽입하려고합니다.

208
00:08:54,560 --> 00:08:55,930
등등.

209
00:08:55,930 --> 00:08:58,270
그런 다음 메시지를 표시 할거야
다음 명령.

210
00:08:58,270 --> 00:08:59,300
그리고 나서 getInt를 사용하려고 해요.

211
00:08:59,300 --> 00:09:02,790
>> 그래서 이것은 정말 간단한 menuing입니다
당신이 입력 할 필요가 어디 인터페이스

212
00:09:02,790 --> 00:09:05,270
하나 번호 매핑
이러한 명령.

213
00:09:05,270 --> 00:09:08,730
지금은 좋은 깨끗한 스위치가
에 전환하는거야 문

214
00:09:08,730 --> 00:09:10,090
사용자가 들어 입력 한 어떤

215
00:09:10,090 --> 00:09:12,180
그들은 하나를 입력 한 경우, 나는거야
삭제 전화 및 휴식.

216
00:09:12,180 --> 00:09:14,380
그들은 두 입력 한 경우에, 나는거야
삽입 호출 휴식.

217
00:09:14,380 --> 00:09:16,490
>> 지금은 각각 넣었습니다 인식 한
같은 줄에 이러한.

218
00:09:16,490 --> 00:09:18,360
이것은 단지 문체의 결정이다.

219
00:09:18,360 --> 00:09:20,210
일반적으로 우리는 무언가를 보았다
이런.

220
00:09:20,210 --> 00:09:23,260
하지만 난 그냥 솔직히, 내 프로그램 결정
더 읽기 보였기 때문에

221
00:09:23,260 --> 00:09:25,980
그것은 만 사가지 경우였다
다만 다음과 같이 기재.

222
00:09:25,980 --> 00:09:28,360
스타일을 완전히 합법적 인 사용.

223
00:09:28,360 --> 00:09:31,480
그리고 등이 너무 오래 할거야
사용자가 0 입력하지 않은, 어느 I

224
00:09:31,480 --> 00:09:33,910
결정은 종료 할 의미합니다.

225
00:09:33,910 --> 00:09:36,630
>> 그래서 지금 난 무엇을 알
여기서 뭘.

226
00:09:36,630 --> 00:09:38,650
나는 분명히 목록을 확보 할거야.

227
00:09:38,650 --> 00:09:40,230
잠시 후에 그것에 대한하지만 더.

228
00:09:40,230 --> 00:09:41,640
의에 앞서이 프로그램을 실행하자.

229
00:09:41,640 --> 00:09:45,250
그래서 나는 더 큰 터미널을 만들어 보자
창, 도트 슬래시 목록 0.

230
00:09:45,250 --> 00:09:49,510
나는로 가서 삽입 할거야
입력 두, 지금 50와 같은 수,

231
00:09:49,510 --> 00:09:51,590
당신은 목록이 이제 50입니다 볼 수 있습니다.

232
00:09:51,590 --> 00:09:53,380
그리고 내 텍스트 다만 조금 위로 스크롤.

233
00:09:53,380 --> 00:09:55,940
이제 목록에 포함 된 알
번호 50.

234
00:09:55,940 --> 00:09:58,220
>> 두 가지를 복용하여 다른 삽입을하자.

235
00:09:58,220 --> 00:10:01,630
의이 같은 숫자를 입력 할 수 있습니다.

236
00:10:01,630 --> 00:10:03,940
목록은 현재 50 다음 하나입니다.

237
00:10:03,940 --> 00:10:06,020
이것은 단지 텍스트 표현입니다 그래서
목록.

238
00:10:06,020 --> 00:10:10,550
과의 같은 하나 이상의 숫자를 삽입하자
희망 번호 인 42,

239
00:10:10,550 --> 00:10:14,620
때문에 중간에 종료 예정
특정 종류의이 프로그램은 그

240
00:10:14,620 --> 00:10:16,320
그것은 삽입을 같은 요소.

241
00:10:16,320 --> 00:10:17,220
그래서 거기에 우리가 있습니다.

242
00:10:17,220 --> 00:10:20,730
수 초 간단한 프로그램
절대적으로 내가 배열을 사용했지만

243
00:10:20,730 --> 00:10:23,280
연결리스트를 사용하는 일이
그냥 내가 동적으로 수

244
00:10:23,280 --> 00:10:24,610
성장과 수축.

245
00:10:24,610 --> 00:10:28,470
>> 그래서, 만약의 검색에 대해 살펴 보겠습니다 I
명령 세 가지를 실행, 내가 검색 할

246
00:10:28,470 --> 00:10:31,040
번호 43, 말합니다.

247
00:10:31,040 --> 00:10:34,190
아무것도 분명히 찾을 수 없습니다,
나는 어떤 응답을 가지고하지 않기 때문에.

248
00:10:34,190 --> 00:10:35,010
그래서 다시이 작업을 수행하자.

249
00:10:35,010 --> 00:10:35,690
검색 할 수 있습니다.

250
00:10:35,690 --> 00:10:39,520
50, 또는 오히려 검색하자 검색
42, 이는 좋은가

251
00:10:39,520 --> 00:10:40,850
약간 미묘한 의미.

252
00:10:40,850 --> 00:10:42,610
그리고 거기에 삶의 의미를 발견했다.

253
00:10:42,610 --> 00:10:44,990
당신이 모르는 경우, 번호 42,
참조, 구글 그것.

254
00:10:44,990 --> 00:10:45,350
좋아.

255
00:10:45,350 --> 00:10:47,130
그래서 나를 위해이 프로그램을 수행하고있다?

256
00:10:47,130 --> 00:10:50,660
그것은 다만 저를 따라서 삽입 할 수있어
요소까지 및 검색 할 수 있습니다.

257
00:10:50,660 --> 00:10:53,650
>> 에, 그럼, 빨리 감기하자
우리는 흘끗 그 함수

258
00:10:53,650 --> 00:10:55,360
월요일에 맛보기로.

259
00:10:55,360 --> 00:10:59,620
이 기능 그래서, 난에 대해 검색을 주장
처음으로 목록의 요소

260
00:10:59,620 --> 00:11:03,830
한, 사용자에게 메시지를 표시 한 후 호출
실제 INT를 얻을 수 getInt를

261
00:11:03,830 --> 00:11:05,060
당신이 검색하고자하는.

262
00:11:05,060 --> 00:11:06,460
>> 그런 다음이를 확인할 수 있습니다.

263
00:11:06,460 --> 00:11:10,690
나는 임시 변수를 만들거야
라인 188에 포인터라고 -

264
00:11:10,690 --> 00:11:11,270
PTR -

265
00:11:11,270 --> 00:11:12,440
그것을 무엇이라고 수 있었다.

266
00:11:12,440 --> 00:11:16,140
그리고 노드에 대한 포인터이다
나는 거기에 노드 * 말했기 때문에.

267
00:11:16,140 --> 00:11:19,900
그리고 나는 그것이 동일하게 초기화 해요
처음 그래서 효과적으로 것을 내

268
00:11:19,900 --> 00:11:22,860
손가락, 그래서 매우에 이야기하기
목록의 첫 번째 요소입니다.

269
00:11:22,860 --> 00:11:27,460
여기 내 오른손 PTR 난 그래서 경우
같은 것을 가리키는 첫

270
00:11:27,460 --> 00:11:28,670
가리키는입니다.

271
00:11:28,670 --> 00:11:31,430
>> 그래서 지금 다시 코드,
무엇이 다음에 일어날 일 -

272
00:11:31,430 --> 00:11:35,070
반복 할 때이 일반적인 패러다임
같은 구조에

273
00:11:35,070 --> 00:11:35,970
연결리스트.

274
00:11:35,970 --> 00:11:40,410
나는 동안 다음을 수행 할거야
포인터 그래서 null로 같지 않은 동안

275
00:11:40,410 --> 00:11:47,530
내 손가락은 널 문자를 가리키는되지 않습니다
값, 포인터 화살표 n은 N과 동일합니다.

276
00:11:47,530 --> 00:11:52,290
우리는 여기서 n은 것을 처음으로 알 수 있습니다 무엇
당 GetInts에 입력 한 사용자는 여기를 호출합니다.

277
00:11:52,290 --> 00:11:54,280
>> 그리고 포인터 화살표 없음은 무엇을 의미?

278
00:11:54,280 --> 00:11:59,020
우리는 여기 사진에 돌아가 잘 경우,
나는에서 가리키는 손가락이있는 경우

279
00:11:59,020 --> 00:12:02,960
아홉을 포함하는 첫 번째 노드
화살표는 본질적으로 이동을 의미합니다

280
00:12:02,960 --> 00:12:08,860
노드, 위치 N의 값을 잡아
이 경우, 데이터 필드에 N을했다.

281
00:12:08,860 --> 00:12:14,120
>> 옆으로 - 우리는이 부부를 보았다
주 전 누군가가 물었을 때 -

282
00:12:14,120 --> 00:12:18,840
이 구문은 새로운이지만, 그것은하지 않습니다
우리에게 능력을 제공하는 우리

283
00:12:18,840 --> 00:12:20,040
이미하지 않았다.

284
00:12:20,040 --> 00:12:25,325
사용하는 것과이 구절은 무엇인가
점 표기법과 스타 커플

285
00:12:25,325 --> 00:12:29,490
주 전 우리는 다시 벗겨 때
이 비트 중간 계층?

286
00:12:29,490 --> 00:12:31,780
>> 학생 : [들림].

287
00:12:31,780 --> 00:12:38,880
>> 스피커 1 : 맞아요, 그것은 스타이고,
그런 다음에, 스타 점 N 있었다

288
00:12:38,880 --> 00:12:41,930
여기서 괄호, 이는 보인다
솔직히, 나는 많게 생각

289
00:12:41,930 --> 00:12:43,320
읽기 더 이상한.

290
00:12:43,320 --> 00:12:46,270
그러나 별 포인터, 언제나,
수단이 이동합니다.

291
00:12:46,270 --> 00:12:49,090
그리고 일단 당신이 어떤 데이터가 왔어
필드가 액세스 할 수 있습니까?

292
00:12:49,090 --> 00:12:52,730
그럼 당신은에 액세스 할 점 표기법을 사용
구조체 데이터 필드, 그리고

293
00:12:52,730 --> 00:12:54,140
특히 n을합니다.

294
00:12:54,140 --> 00:12:56,240
>> 솔직히, 나는이 주장
읽는 것만으로 어렵습니다.

295
00:12:56,240 --> 00:12:58,080
어디 기억하기 힘들어
괄호, 가야합니까

296
00:12:58,080 --> 00:12:59,030
스타와 그 모든.

297
00:12:59,030 --> 00:13:02,150
그래서 세계는 몇 가지 문법을 채택
설탕, 말하자면.

298
00:13:02,150 --> 00:13:04,740
말의 단지 섹시한 방법
이 동일하며

299
00:13:04,740 --> 00:13:05,970
아마도 더 직관적.

300
00:13:05,970 --> 00:13:09,600
포인터가 실제로 포인터라면,
화살표 표기 수단이 가서 찾아

301
00:13:09,600 --> 00:13:11,890
이 경우 필드에 N을했다.

302
00:13:11,890 --> 00:13:13,660
>> 나는 그것을 발견 그래서 만약, 내가 뭘 알 수 있습니다.

303
00:13:13,660 --> 00:13:17,430
나는 단순히 인쇄, 나는 퍼센트 나는 발견
그 INT의 값에 연결.

304
00:13:17,430 --> 00:13:20,730
나는 종류의 단지 1 초 동안 잠을 호출
로 화면에 일시 정지 관광

305
00:13:20,730 --> 00:13:22,900
사용자에게 흡수 할 두 번째 줄
방금 무슨 일이.

306
00:13:22,900 --> 00:13:24,290
그리고 나서 휴식.

307
00:13:24,290 --> 00:13:26,330
그렇지 않으면, 나는 무엇을해야합니까?

308
00:13:26,330 --> 00:13:30,960
나는 동일한 포인터를 업데이트
다음 포인터 화살표.

309
00:13:30,960 --> 00:13:35,840
>> 그래서 그냥 명확하게,이 이동 수단
내 구식 표기법도 사용.

310
00:13:35,840 --> 00:13:39,580
이것은 단지 어떤 이동하는 것을 의미하므로
당신은 매우에서하는 가리키고

311
00:13:39,580 --> 00:13:43,660
첫 번째 경우는 내가 가리키는있어입니다
그것에서 9와 구조체.

312
00:13:43,660 --> 00:13:44,510
그래서 거기에 갔어요.

313
00:13:44,510 --> 00:13:47,880
그리고 점 표기법의 의미,
다음에서 값을 가져옵니다.

314
00:13:47,880 --> 00:13:50,470
>> 그러나이 값은, 그것은 그려에도 불구하고
좁은으로, 단지 숫자입니다.

315
00:13:50,470 --> 00:13:51,720
그것은 숫자 주소입니다.

316
00:13:51,720 --> 00:13:55,670
여부,이 코드 한 줄은 이렇게
이 같은 기록보다 비밀

317
00:13:55,670 --> 00:14:00,190
방법, 또는 다음과 같이, 조금 더
직관적 인 방법은, 그냥 내 손을 이동 의미

318
00:14:00,190 --> 00:14:03,460
다음 단계로 첫 번째 노드에서
그 후, 다음 하나는

319
00:14:03,460 --> 00:14:05,320
한 다음, 등등.

320
00:14:05,320 --> 00:14:09,920
>> 그래서 우리는 다른에 연연하지 않습니다
삽입 및 삭제의 구현

321
00:14:09,920 --> 00:14:14,030
및 탐색의 처음 두
이는 매우 관여하고 있습니다.

322
00:14:14,030 --> 00:14:17,010
그리고 나는 그것을 얻기 위해 아주 쉽게 생각
구두를 수행 할 때 잃었다.

323
00:14:17,010 --> 00:14:19,890
그러나 우리가 할 수있는 것은
결정하기 위해 시도하는 방법

324
00:14:19,890 --> 00:14:21,640
가장 시각적으로이 작업을 수행 할 수 있습니다.

325
00:14:21,640 --> 00:14:24,800
내가 제안 것이기 때문에 그 경우 우리
이에 요소를 삽입 할

326
00:14:24,800 --> 00:14:26,680
기존 목록, 어떤
다섯 가지 요소를 가지고 -

327
00:14:26,680 --> 00:14:29,530
9, 17, 22, 26, 33 -

328
00:14:29,530 --> 00:14:33,300
나는이 구현하려고 한 경우
코드는, 내가 이동하는 방법을 고려할 필요가

329
00:14:33,300 --> 00:14:34,160
이 일에 대해.

330
00:14:34,160 --> 00:14:37,720
>> 그리고 아기 단계를 수행 제안 할
이 경우 내 말은 그것에, 무엇입니까

331
00:14:37,720 --> 00:14:41,090
가능한 시나리오가 우리
일반적으로 발생할 수있는?

332
00:14:41,090 --> 00:14:44,120
링크에 대해 삽입을 구현할 때
목록이 그냥 일어나는

333
00:14:44,120 --> 00:14:46,090
크기 다섯 구체적인 예.

334
00:14:46,090 --> 00:14:50,420
당신은 번호를 삽입 할 경우에 잘
번호를 하나의 말을 좋아하고,

335
00:14:50,420 --> 00:14:53,380
여기서, 정렬 된 순서를 유지
분명히 하나의 필요 개수는 않습니다

336
00:14:53,380 --> 00:14:55,686
이 특정 예제에서 이동?

337
00:14:55,686 --> 00:14:56,840
처음에 좋아한다.

338
00:14:56,840 --> 00:15:00,030
>> 그러나 흥미로운 무슨이있다
당신은이에 하나를 삽입 할 경우

339
00:15:00,030 --> 00:15:04,100
목록, 어떤 특별한 포인터가 필요
분명히 업데이트 할?

340
00:15:04,100 --> 00:15:04,610
첫번째로 올려주세요.

341
00:15:04,610 --> 00:15:07,830
그래서 난이 첫 번째 경우입니다 주장
우리는, 고려할 수있는

342
00:15:07,830 --> 00:15:11,140
에서 삽입을 포함하는 시나리오
목록의 시작입니다.

343
00:15:11,140 --> 00:15:15,400
>> 의도 쉽게 또는 어쩌면 오프 뽑아 보자
쉽게 경우, 상대적으로 말하기.

344
00:15:15,400 --> 00:15:18,110
내가 삽입한다고 가정
정렬 된 순서에서 번호 35.

345
00:15:18,110 --> 00:15:20,600
그것은 분명 거기에 속한다.

346
00:15:20,600 --> 00:15:25,320
그래서 포인터가 분명히가는
이 시나리오에서 업데이트 할 수 있습니까?

347
00:15:25,320 --> 00:15:30,060
34의 포인터가 널 (NULL)이되고
그러나 구조체의 주소

348
00:15:30,060 --> 00:15:31,800
숫자 35을 포함.

349
00:15:31,800 --> 00:15:32,750
그래서이 경우는 두 가지이다.

350
00:15:32,750 --> 00:15:36,190
아직, 나는 양자화의 종류 해요
내가 여기서 할 필요가 얼마나 작동합니다.

351
00:15:36,190 --> 00:15:39,880
>> 그리고 마지막으로, 명백한 중간 케이스입니다
참, 중간에 있으면 내가 원하는

352
00:15:39,880 --> 00:15:45,870
가는 말 23과 같이 삽입
23 26 사이지만,

353
00:15:45,870 --> 00:15:48,680
지금은 상황이 조금 더 얻을
참여하기 때문에 어떤

354
00:15:48,680 --> 00:15:52,800
포인터를 변경해야합니까?

355
00:15:52,800 --> 00:15:56,680
22 분명히 변경해야하므로
그는 더 이상 26 가리킬 수 있기 때문이다.

356
00:15:56,680 --> 00:16:00,320
그는 새 노드를 가리 키도록해야하는
나는 호출하여 할당해야합니다

357
00:16:00,320 --> 00:16:01,770
malloc에​​ 또는 어떤 해당합니다.

358
00:16:01,770 --> 00:16:05,990
>> 하지만 나는 또한 새로운 노드 23이 필요합니다
이 경우, 그 포인터를 가지고

359
00:16:05,990 --> 00:16:07,870
누구를 가리키는?

360
00:16:07,870 --> 00:16:08,560
26.

361
00:16:08,560 --> 00:16:10,380
하고있을거야
여기에 작업 순서입니다.

362
00:16:10,380 --> 00:16:13,410
때문에 미련이 작업을 수행, 그리고 경우
의 시작 부분에 인스턴스 시작을위한

363
00:16:13,410 --> 00:16:16,040
목록 내 목표는 23를 삽입하는 것입니다.

364
00:16:16,040 --> 00:16:18,610
그리고 나는 속합니까 확인
여기에, 구에 가까운?

365
00:16:18,610 --> 00:16:18,950
아니오.

366
00:16:18,950 --> 00:16:20,670
그것은 17 다음 여기에 속한다합니까?

367
00:16:20,670 --> 00:16:20,940
아니오.

368
00:16:20,940 --> 00:16:22,530
그것은 22 다음 여기에 속한다합니까?

369
00:16:22,530 --> 00:16:23,300
예.

370
00:16:23,300 --> 00:16:26,400
>> 지금 여기 바보 야하는 경우, 그리고
이를 통해 생각 나는 수도

371
00:16:26,400 --> 00:16:28,320
23 나의 새로운 노드를 할당합니다.

372
00:16:28,320 --> 00:16:32,080
나는의 포인터를 업데이트 할 수 있습니다
노드를 가리키는 22라는

373
00:16:32,080 --> 00:16:33,080
그것은 새로운 노드.

374
00:16:33,080 --> 00:16:36,140
그리고 나서 업데이트 무엇을해야합니까
새 노드의 포인터이어야 하는가?

375
00:16:36,140 --> 00:16:38,120
>> 학생 : [들림].

376
00:16:38,120 --> 00:16:38,385
>> 스피커 1 : 맞아요.

377
00:16:38,385 --> 00:16:39,710
26에 가리키는.

378
00:16:39,710 --> 00:16:45,590
난 이미 업데이트되지 않은 경우에 젠장
22의 포인터가이 사람에서 가리킨하기

379
00:16:45,590 --> 00:16:48,260
지금은 고아, 나머지를 가지고
목록으로 말하자면.

380
00:16:48,260 --> 00:16:52,140
여기에 작업 때문에 순서
중요 할 것입니다.

381
00:16:52,140 --> 00:16:55,100
>> 이렇게하려면 내가 훔칠 수
여섯 자원 봉사자를 말한다.

382
00:16:55,100 --> 00:16:57,650
그리고 우리는이 작업을 수행 할 수없는 경우 보자
시각 대신 코드 현명한.

383
00:16:57,650 --> 00:16:59,330
그리고 우리는 몇 가지 아름다운 스트레스를가
오늘 당신을 위해 공.

384
00:16:59,330 --> 00:17:02,510
확인하는 방법에 대한 하나, 둘,에
다시 -가 끝.

385
00:17:02,510 --> 00:17:04,530
너희 둘 셋, 넷,
끝에 사람.

386
00:17:04,530 --> 00:17:05,579
다섯, 여섯.

387
00:17:05,579 --> 00:17:05,839
있는지 확인하십시오.

388
00:17:05,839 --> 00:17:06,450
다섯 여섯.

389
00:17:06,450 --> 00:17:08,390
모든 권리와 갈 게요
너희들 옆에있는 시간입니다.

390
00:17:08,390 --> 00:17:09,640
좋아, 어서.

391
00:17:09,640 --> 00:17:12,010

392
00:17:12,010 --> 00:17:14,819
>> 좋아, 여기에 먼저있어 이후
당신은 어색 하나 싶습니다

393
00:17:14,819 --> 00:17:16,119
여기에 구글 유리에?

394
00:17:16,119 --> 00:17:19,075
좋아, 그래서 OK, 유리,
영상을 기록합니다.

395
00:17:19,075 --> 00:17:22,720

396
00:17:22,720 --> 00:17:24,589
OK, 당신은 갈 수 있어요.

397
00:17:24,589 --> 00:17:27,950
>> 좋아요, 당신들이 와서 할 수있는 경우
여기, 내가 사전에 준비했습니다

398
00:17:27,950 --> 00:17:30,110
몇 가지 숫자.

399
00:17:30,110 --> 00:17:31,240
그래, 어서와.

400
00:17:31,240 --> 00:17:33,440
그리고 왜 당신이 조금 가지 않는다
추가하는 방법입니다.

401
00:17:33,440 --> 00:17:35,520
그리고 보자, 당신의 이름은 무엇입니까,
구글 유리가 있나요?

402
00:17:35,520 --> 00:17:35,910
>> 학생 : 벤.

403
00:17:35,910 --> 00:17:36,230
>> 스피커 1 : 벤?

404
00:17:36,230 --> 00:17:38,380
OK, 벤, 당신은 말 그대로 먼저 될 것입니다.

405
00:17:38,380 --> 00:17:40,580
그래서 우리는 당신을 보낼거야
무대의 끝.

406
00:17:40,580 --> 00:17:41,670
좋아, 당신의 이름은?

407
00:17:41,670 --> 00:17:41,990
>> 학생 : 제이슨.

408
00:17:41,990 --> 00:17:44,530
>> 스피커 1 : 제이슨, OK 당신은거야
아홉합니다.

409
00:17:44,530 --> 00:17:46,700
당신은 벤이 길을 따라 싶은 경우에.

410
00:17:46,700 --> 00:17:47,010
>> 학생 : 질.

411
00:17:47,010 --> 00:17:49,630
>> 스피커 1 : 질, 당신이 될 것입니다
17 이는 내가이 더 많은 일을하려는 경우

412
00:17:49,630 --> 00:17:51,260
지능적으로 나는 것
다른 쪽 끝에서 시작했다.

413
00:17:51,260 --> 00:17:52,370
당신은 그 길을 이동합니다.

414
00:17:52,370 --> 00:17:53,030
22.

415
00:17:53,030 --> 00:17:53,670
그리고 당신은?

416
00:17:53,670 --> 00:17:53,980
>> 학생 : 메리.

417
00:17:53,980 --> 00:17:56,130
>> 스피커 1 : 메리, 당신은 22있을 것이다.

418
00:17:56,130 --> 00:17:58,420
그리고 당신의 이름은?

419
00:17:58,420 --> 00:17:58,810
>> 학생 : 크리스.

420
00:17:58,810 --> 00:18:00,100
>> 스피커 1 : 크리스, 당신은 26있을 것이다.

421
00:18:00,100 --> 00:18:00,740
그리고 마지막으로.

422
00:18:00,740 --> 00:18:01,400
>> 학생 : 다이아나.

423
00:18:01,400 --> 00:18:02,670
>> 스피커 1 : 다이아나, 당신은 34있을 것이다.

424
00:18:02,670 --> 00:18:03,920
그래서 당신은 어서와.

425
00:18:03,920 --> 00:18:06,360
>> 좋아, 이렇게 분류 완벽
이미 주문한다.

426
00:18:06,360 --> 00:18:09,600
과의이 가서 이렇게하자
그래서 우리가 정말 할 수 있습니다 -

427
00:18:09,600 --> 00:18:11,720
벤 당신이 찾고있는 단지 종류입니다
난데없이 거기에.

428
00:18:11,720 --> 00:18:15,670
자, 그럼 가서이를 묘사하자
I이었다 많은처럼 팔을 사용하여, 정확하게,

429
00:18:15,670 --> 00:18:16,250
무슨 일이야.

430
00:18:16,250 --> 00:18:19,540
그래서 가서 자신에게 줄
발 또는 자신 사이에는 두 가지.

431
00:18:19,540 --> 00:18:22,900
한 손으로 가서 포인트
당신은에서 누구를 가리키는해야한다

432
00:18:22,900 --> 00:18:23,470
이에 따라.

433
00:18:23,470 --> 00:18:25,890
당신이 null이라면 그냥 포인트
똑바로 바닥에.

434
00:18:25,890 --> 00:18:27,690
OK, 너무 좋아.

435
00:18:27,690 --> 00:18:32,290
>> 그래서 지금 우리는 연결리스트를 가지고 있고, 나를 보자
나는의 역할을합니다 것을 제안

436
00:18:32,290 --> 00:18:35,110
PTR, 그래서 나는 걱정하지 않습니다
주변이 들고입니다.

437
00:18:35,110 --> 00:18:37,830
그리고 - 사람 바보 대회 -
당신이 당신이 원하는 무엇이든을 호출 할 수 있습니다 -

438
00:18:37,830 --> 00:18:39,800
이전 포인터, PRED 포인터 -

439
00:18:39,800 --> 00:18:43,930
그냥 우리가 준 별명이다
내 왼쪽 손에 우리의 샘플 코드입니다.

440
00:18:43,930 --> 00:18:47,240
유지 될 것하는 반면
누구에 누구의 추적

441
00:18:47,240 --> 00:18:48,400
시나리오에 따라.

442
00:18:48,400 --> 00:18:52,390
>> 그래서 첫째, 오프 뽑아하려는 가정
삽입의 첫 번째 예는 말

443
00:18:52,390 --> 00:18:54,330
20,리스트에.

444
00:18:54,330 --> 00:18:57,160
그래서 누군가가 필요 해요
우리를 위해 숫자 20을 구현.

445
00:18:57,160 --> 00:18:58,950
그래서 malloc에​​ 누군가 필요
관객.

446
00:18:58,950 --> 00:18:59,380
올라 와요.

447
00:18:59,380 --> 00:19:00,340
당신의 이름은 무엇입니까?

448
00:19:00,340 --> 00:19:01,300
>> 학생 : 브라이언.

449
00:19:01,300 --> 00:19:05,270
>> 스피커 1 : 브라이언, 모든 권리, 그래서 당신
20를 포함하는 노드가되어야한다.

450
00:19:05,270 --> 00:19:06,810
그래, 어서와.

451
00:19:06,810 --> 00:19:10,025
그리고 확실히, 여기서
브라이언 속합니까?

452
00:19:10,025 --> 00:19:12,190
그래서 중간에 - 사실,
분을 기다립니다.

453
00:19:12,190 --> 00:19:13,420
우리는 주문의를하고 있어요.

454
00:19:13,420 --> 00:19:17,170
우리는 더 어렵게이 만들고있어
처음에는 필요 이상으로.

455
00:19:17,170 --> 00:19:21,210
OK, 우리는 자유 브라이언에 갈거야
그리고 다섯 realloc을 브라이언.

456
00:19:21,210 --> 00:19:23,680
>> OK, 이제 우리는 삽입 할
다섯 브라이언.

457
00:19:23,680 --> 00:19:25,960
그래서 옆 어서와
단지 순간을 위해 벤.

458
00:19:25,960 --> 00:19:28,250
그리고 당신은 아마 알 수 있습니다
이 이야기는 것입니다.

459
00:19:28,250 --> 00:19:30,500
그러나하자에 대해 신중하게 생각
작업의 순서입니다.

460
00:19:30,500 --> 00:19:32,880
그리고 그것은 정확하게이 영상의
줄 것이

461
00:19:32,880 --> 00:19:34,080
이 샘플 코드.

462
00:19:34,080 --> 00:19:40,120
그래서 나는 여기있는 PTR 처음에 가리키는있다
아니 본질적으로 벤,에, 그러나 어떤에

463
00:19:40,120 --> 00:19:43,245
그는이 포함되어 가치있는이 경우
이다 - 당신의 이름을 다시 무엇인가?

464
00:19:43,245 --> 00:19:43,670
>> 학생 : 제이슨.

465
00:19:43,670 --> 00:19:47,350
>> 스피커 1 : 제이슨 벤과 나는 둘은 그렇게
이 순간 제이슨 가리키는.

466
00:19:47,350 --> 00:19:49,700
그래서 지금 결정해야합니다,
브라이언은 어디에 속합니까?

467
00:19:49,700 --> 00:19:53,500
유일한 그래서 난에 액세스 할 수 있습니다
지금 자신의 n 개의 데이터 항목입니다.

468
00:19:53,500 --> 00:19:58,280
그래서, 확인하는 것입니다거야
제이슨보다 브라이언 적은?

469
00:19:58,280 --> 00:19:59,770
대답은 사실이다.

470
00:19:59,770 --> 00:20:03,680
>> 그래서 지금 어떻게해야
올바른 순서로?

471
00:20:03,680 --> 00:20:07,120
나는 얼마나 많은 포인터를 업데이트 할 필요가
이 이야기에 맞추어?

472
00:20:07,120 --> 00:20:10,720
내 손은 여전히​​ 가리키는 위치
제이슨, 당신의 손 - 만약 당신이 원한다면

473
00:20:10,720 --> 00:20:12,930
일종의처럼 손을 넣어 I
, 물음표 모르겠어요.

474
00:20:12,930 --> 00:20:14,070
OK, 좋아.

475
00:20:14,070 --> 00:20:15,670
>> 좋아, 당신이 너무
몇 가지 후보.

476
00:20:15,670 --> 00:20:20,500
벤 또는 I 또는 브라이언이나 제이슨 하나
아니면 다른 사람, 그

477
00:20:20,500 --> 00:20:21,370
포인터를 변경해야합니까?

478
00:20:21,370 --> 00:20:23,260
어떻게 전체의 많은?

479
00:20:23,260 --> 00:20:24,080
>> 좋아, 그럼 두.

480
00:20:24,080 --> 00:20:27,090
내 포인터가 정말 더 이상 문제가되지 않습니다
난 그냥 임시 해요 때문이다.

481
00:20:27,090 --> 00:20:31,370
그래서, 아마도이 두 사람의
벤과 브라이언 모두.

482
00:20:31,370 --> 00:20:34,410
그래서 우리는 업데이트하는 날 제안하자
벤은, 이후 그가 처음이다.

483
00:20:34,410 --> 00:20:36,350
이 목록의 첫 번째 요소
지금 브라이언 될 것입니다.

484
00:20:36,350 --> 00:20:38,070
브라이언에 따라서 벤 점.

485
00:20:38,070 --> 00:20:39,320
자, 이제 어떻게?

486
00:20:39,320 --> 00:20:41,950

487
00:20:41,950 --> 00:20:43,460
>> 누가 누구에서 지적되는?

488
00:20:43,460 --> 00:20:44,710
>> 학생 : [들림].

489
00:20:44,710 --> 00:20:46,180
>> 스피커 1 : OK 그래서 브라이언이
제이슨 가리킬 수 있습니다.

490
00:20:46,180 --> 00:20:48,360
하지만 난 그 포인터 추적을 잃었습니까?

491
00:20:48,360 --> 00:20:49,980
제이슨이 어디 있는지 아세요?

492
00:20:49,980 --> 00:20:50,790
>> 학생 : [들림].

493
00:20:50,790 --> 00:20:52,620
>> 스피커 1 : 난 이후로 내가 할
임시 포인터.

494
00:20:52,620 --> 00:20:55,110
그리고 아마도, 내가 변경되지 않은
새 노드를 가리키게한다.

495
00:20:55,110 --> 00:20:58,300
그래서 우리는 단순히 브라이언 포인트를 가질 수 있습니다
누구에 나는 가리키는거야.

496
00:20:58,300 --> 00:20:59,000
그리고 우리는 끝났어.

497
00:20:59,000 --> 00:21:01,890
그래서 케이스 하나에 삽입
목록의 시작.

498
00:21:01,890 --> 00:21:02,950
두 가지 주요 단계가 있었다.

499
00:21:02,950 --> 00:21:06,750
하나, 우리는 벤를 업데이트해야하고
우리는 또한 브라이언를 업데이트해야합니다.

500
00:21:06,750 --> 00:21:09,230
그리고 나서 걱정 할 필요가 없습니다
의 나머지 부분을 통해 터벅 터벅

501
00:21:09,230 --> 00:21:12,680
우리는 이미 발견 목록, 때문에 그의
그는에 속한 위치하기 때문에

502
00:21:12,680 --> 00:21:14,080
첫 번째 요소의 왼쪽.

503
00:21:14,080 --> 00:21:15,400
>> 좋아, 그래서 매우 간단합니다.

504
00:21:15,400 --> 00:21:18,110
우리는 거의 것처럼 사실, 느낌
이 너무 복잡하고.

505
00:21:18,110 --> 00:21:20,240
그럼 이제 끝을 뽑아 보자
목록, 그리고 위치를 확인

506
00:21:20,240 --> 00:21:21,380
복잡성이 시작됩니다.

507
00:21:21,380 --> 00:21:24,560
청중 그래서 지금, 나 할당.

508
00:21:24,560 --> 00:21:25,540
사람은 55를 재생하려면?

509
00:21:25,540 --> 00:21:26,700
좋아, 내가 먼저 손을 보았다.

510
00:21:26,700 --> 00:21:29,620
올라 와요.

511
00:21:29,620 --> 00:21:30,030
그래.

512
00:21:30,030 --> 00:21:31,177
당신의 이름은 무엇입니까?

513
00:21:31,177 --> 00:21:32,310
>> 학생 : [들림].

514
00:21:32,310 --> 00:21:33,240
>> 스피커 1 : Habata.

515
00:21:33,240 --> 00:21:33,890
OK, 올라옵니다.

516
00:21:33,890 --> 00:21:35,730
당신은 55 번있을 것이다.

517
00:21:35,730 --> 00:21:37,820
그래서 당신은 물론, 속
목록의 끝에.

518
00:21:37,820 --> 00:21:41,850
그럼 저와 시뮬레이션을 재생하자
단지 순간을 위해 PTR되고있다.

519
00:21:41,850 --> 00:21:44,050
그래서 나는 처음에 가리 키도록거야
벤에서 가리키는 뭐든간에.

520
00:21:44,050 --> 00:21:45,900
우리는 지금 브라이언을 가리키는거야 모두.

521
00:21:45,900 --> 00:21:48,420
그래서 55 개 미만이 아닙니다.

522
00:21:48,420 --> 00:21:52,510
그래서 난으로 자신을 업데이트 할거야
브라이언의 다음 포인터로 가리키는 사람

523
00:21:52,510 --> 00:21:54,450
지금은 물론 제이슨입니다.

524
00:21:54,450 --> 00:21:57,310
55 그래서보다 아홉 없습니다
나는 PTR를 업데이트하는거야.

525
00:21:57,310 --> 00:21:58,890
나는 PTR를 업데이트하는거야.

526
00:21:58,890 --> 00:22:02,290
나는 PTR를 업데이트하는거야
나는 PTR을 업데이트 할 것.

527
00:22:02,290 --> 00:22:05,060
그리고 나는 갈거야 - 음, 무엇을
당신의 이름을 다시?

528
00:22:05,060 --> 00:22:05,560
>> 학생 : 다이아나.

529
00:22:05,560 --> 00:22:09,190
>> 스피커 1 : 다이아나 가리키는 물론,
그녀의 왼쪽 손으로 널에서.

530
00:22:09,190 --> 00:22:13,030
어디 Habata 실제로 수행
분명히 속해?

531
00:22:13,030 --> 00:22:15,050
왼쪽으로, 여기.

532
00:22:15,050 --> 00:22:19,460
어떻게 내가 여기에 그녀를 넣어 알고
내가 망쳐 버린 것 같아요.

533
00:22:19,460 --> 00:22:22,420
무엇 PTR 예술이기 때문에
시간이 순간?

534
00:22:22,420 --> 00:22:23,240
NULL입니다.

535
00:22:23,240 --> 00:22:25,580
그래서 비록 시각적으로, 우리는 할 수있다
분명이 모든 참조

536
00:22:25,580 --> 00:22:26,610
여기에 무대에 사람.

537
00:22:26,610 --> 00:22:29,680
나는 이전의 트랙을 유지 적이 없다
목록에있는 사람.

538
00:22:29,680 --> 00:22:33,210
나는 밖으로 가리키는 손가락을 가지고 있지 않습니다
이 경우, 노드 번호 34.

539
00:22:33,210 --> 00:22:34,760
>> 그럼 실제로이 이상을 시작할 수 있습니다.

540
00:22:34,760 --> 00:22:37,560
그래서 지금은 사실 필요
두 번째 지역 변수입니다.

541
00:22:37,560 --> 00:22:40,980
그리고 이것은 당신이 볼 수 것입니다
실제 예제 C 코드로 내가가는 곳,

542
00:22:40,980 --> 00:22:45,860
나는 가리 내 오른손을 업데이트 할 때
제이슨, 따라서 I, 뒤에 브라이언를 떠나

543
00:22:45,860 --> 00:22:51,440
더 나은 내 왼쪽 손을 사용하여 시작
내가 어디에 있었는지 내가 가서되도록 업데이트

544
00:22:51,440 --> 00:22:52,700
이 목록을 통해 -

545
00:22:52,700 --> 00:22:55,040
더 어색 나는 예정보다
지금 여기 시각 -

546
00:22:55,040 --> 00:22:56,740
내가 얻을거야
목록의 끝.

547
00:22:56,740 --> 00:23:00,020
>> 이 손은 사랑이다 아직도 널
표시하는 것보다 다른 쓸모없는

548
00:23:00,020 --> 00:23:02,980
나는 목록의 끝에 분명 해요
하지만 지금은 적어도이있다

549
00:23:02,980 --> 00:23:08,270
이전 포인터 그래서, 여기를 가리키는
지금 무엇을 건네고 어떤 포인터가 필요

550
00:23:08,270 --> 00:23:10,150
업데이트 할?

551
00:23:10,150 --> 00:23:13,214
그의 손 당신이 원하는
첫 번째 재구성?

552
00:23:13,214 --> 00:23:15,190
>> 학생 : [들림].

553
00:23:15,190 --> 00:23:16,220
>> 스피커 1 : OK, 다이애나의 때문에.

554
00:23:16,220 --> 00:23:21,110
어디 가리 싶어
에서 다이애나의 왼쪽 포인터?

555
00:23:21,110 --> 00:23:23,620
55, 아마도 그 때문에
우리가 삽입 한.

556
00:23:23,620 --> 00:23:25,560
어디 55 포인터가 가야하나요?

557
00:23:25,560 --> 00:23:27,000
아래는, null를 나타내는.

558
00:23:27,000 --> 00:23:28,890
그리고 내 손이 시점에서,하지
그들은 단지했기 때문에 문제가

559
00:23:28,890 --> 00:23:30,070
임시 변수.

560
00:23:30,070 --> 00:23:31,030
이제 우리는 끝났어.

561
00:23:31,030 --> 00:23:34,650
>> 그래서 추가가 복잡 -와
그것은 구현하기가 어렵지 않다

562
00:23:34,650 --> 00:23:38,660
그러나 우리는 만들 수있는 보조 변수를 필요로
확인이 내 권리를 이동하기 전에

563
00:23:38,660 --> 00:23:42,140
손, 내 왼쪽의 값을 업데이트
한편, PRED이 경우 포인터 때문에,

564
00:23:42,140 --> 00:23:45,860
나는 뒤에 포인터를 가지고
내가 어디에 있었는지를 추적한다.

565
00:23:45,860 --> 00:23:49,360
지금은 옆으로, 당신이 생각하는 경우
이처럼 통해,이 느낌

566
00:23:49,360 --> 00:23:51,490
유지해야하는 약간 성가신
이 왼손의 추적 할 수 있습니다.

567
00:23:51,490 --> 00:23:54,015
>> 어떤 다른 해결책은 것
이 문제에 다녀 오 셨나요?

568
00:23:54,015 --> 00:23:56,500
당신은 데이터를 재 설계 할 수있어 경우
우리가 얘기 구조

569
00:23:56,500 --> 00:23:59,630
지금까지?

570
00:23:59,630 --> 00:24:02,690
이 단지 종류의 조금을 느끼는 경우
좋아, 두 개의 포인터를 가지고 고민

571
00:24:02,690 --> 00:24:08,430
누가이 목록을 수 것
, 이상적인 세계에서, 유지하고있다

572
00:24:08,430 --> 00:24:10,160
우리가 필요로하는 정보를?

573
00:24:10,160 --> 00:24:11,360
그래?

574
00:24:11,360 --> 00:24:12,610
>> 학생 : [들림].

575
00:24:12,610 --> 00:24:15,160

576
00:24:15,160 --> 00:24:16,150
>> 스피커 1 : 맞아요.

577
00:24:16,150 --> 00:24:19,130
오른쪽 너무 흥미로운 사실​​은있다
아이디어의 세균.

578
00:24:19,130 --> 00:24:22,470
그리고 이전 포인터의 생각,
이전 요소를 가리키는.

579
00:24:22,470 --> 00:24:25,580
내가 그냥 구현하는 경우 그
목록 자체의 내부?

580
00:24:25,580 --> 00:24:27,810
그리고 시각화하기 어려울 것
이 모든 종이없는

581
00:24:27,810 --> 00:24:28,830
바닥에 떨어지는.

582
00:24:28,830 --> 00:24:31,860
그러나이 사람들을 모두 사용한다고 가정
그들의 손의 이전을 가지고

583
00:24:31,860 --> 00:24:35,950
따라서 포인터, 그리고 다음 포인터
우리는 이중 전화 할게 무엇을 구현

584
00:24:35,950 --> 00:24:36,830
연결리스트.

585
00:24:36,830 --> 00:24:41,090
즉, 나 되감기 정렬 할 수 있습니다 것입니다
훨씬 더 쉽게 나없이,

586
00:24:41,090 --> 00:24:43,800
프로그래머, 유지하기 위해 필요
수동 추적 -

587
00:24:43,800 --> 00:24:44,980
진정한 수동 -

588
00:24:44,980 --> 00:24:47,280
나는 이전에 있었던 곳의
리스트합니다.

589
00:24:47,280 --> 00:24:48,110
그래서 우리는 그렇게 할 수 없습니다.

590
00:24:48,110 --> 00:24:50,950
그 때문에 우리는 간단하게합니다
두 배, 가격에 올 것

591
00:24:50,950 --> 00:24:53,450
포인터 공간,
두 번째 개를 원하는 경우.

592
00:24:53,450 --> 00:24:55,760
그러나 실제로 일반적이다
데이터 구조로 알려져

593
00:24:55,760 --> 00:24:57,410
이중 연결리스트.

594
00:24:57,410 --> 00:25:01,310
>> 여기에 마지막 예제를 수행하고 넣어 보자
자신의 불행 중이 녀석.

595
00:25:01,310 --> 00:25:03,270
malloc에​​ 20 그래서.

596
00:25:03,270 --> 00:25:05,320
이 통로에서 올라와.

597
00:25:05,320 --> 00:25:06,280
좋아, 당신의 이름은 무엇입니까?

598
00:25:06,280 --> 00:25:07,440
>> 학생 : [들림].

599
00:25:07,440 --> 00:25:07,855
>> 스피커 1 : 미안 해요?

600
00:25:07,855 --> 00:25:08,480
>> 학생 : [들림].

601
00:25:08,480 --> 00:25:09,410
>> 스피커 1 : Demeron?

602
00:25:09,410 --> 00:25:10,230
OK 올라옵니다.

603
00:25:10,230 --> 00:25:11,910
당신은 20이어야한다.

604
00:25:11,910 --> 00:25:14,720
당신은 분명 가고있다
17 22 사이에 속한다.

605
00:25:14,720 --> 00:25:16,150
그래서 내 교훈을 배울 수 있습니다.

606
00:25:16,150 --> 00:25:18,150
내가 포인터를 시작하는거야
브라이언 가리키는.

607
00:25:18,150 --> 00:25:21,190
그리고 내 왼쪽 손을 가지고거야
내가 이동에만 브라이언로 업데이트

608
00:25:21,190 --> 00:25:23,600
제이슨 검사는 아홉 20 이하합니까?

609
00:25:23,600 --> 00:25:24,060
아니오.

610
00:25:24,060 --> 00:25:25,430
17 이상 20 미만입니까?

611
00:25:25,430 --> 00:25:25,880
아니오.

612
00:25:25,880 --> 00:25:27,450
22 이상 20 미만입니까?

613
00:25:27,450 --> 00:25:28,440
예.

614
00:25:28,440 --> 00:25:34,070
그래서 포인터 또는 손 변경해야
여기서 그들은 지금 가리키는거야?

615
00:25:34,070 --> 00:25:37,070
>> 그래서 우리는 20를 가리키는 17을 수행 할 수 있습니다.

616
00:25:37,070 --> 00:25:37,860
그래서 괜찮아요.

617
00:25:37,860 --> 00:25:40,080
우리는 어디 가리 싶어
포인터 지금?

618
00:25:40,080 --> 00:25:41,330
22시.

619
00:25:41,330 --> 00:25:45,410
22 여기서 우리는 다시 한번 감사를 알고
내 임시 포인터.

620
00:25:45,410 --> 00:25:46,760
그래서 우리는 OK있어.

621
00:25:46,760 --> 00:25:49,440
그래서 때문에이 임시 저장
나는 모두가 어디에 추적을 유지했다.

622
00:25:49,440 --> 00:25:55,055
그리고 지금 당신은 시각적 곳으로 갈 수 있습니다
당신이 속하고 지금 우리는 1, 2, 3이 필요

623
00:25:55,055 --> 00:25:58,410
4, 5, 6, 7, 8, 9, 긴장 공,
와 갈채를

624
00:25:58,410 --> 00:25:59,770
이 녀석, 우리가 할 수있는 경우.

625
00:25:59,770 --> 00:26:00,410
잘 했어.

626
00:26:00,410 --> 00:26:05,320
>> [박수]

627
00:26:05,320 --> 00:26:06,330
>> 스피커 1 : 좋아요.

628
00:26:06,330 --> 00:26:09,860
그리고 당신은 조각을 유지할 수 있습니다
기념품으로 종이.

629
00:26:09,860 --> 00:26:15,930
>> 좋아, 그래서, 많은의 날 믿어
더 쉽게하는을 걷는

630
00:26:15,930 --> 00:26:17,680
그것은 실제 코드보다 인간.

631
00:26:17,680 --> 00:26:22,690
하지만 당신은 단지 순간에 찾을 수 있습니다
지금 같은 것입니다 - 아, 감사합니다.

632
00:26:22,690 --> 00:26:23,630
감사합니다 -

633
00:26:23,630 --> 00:26:29,360
당신이 동일한 데이터를 찾을 것입니다
구조, 연결리스트, 사실 수 있습니다

634
00:26:29,360 --> 00:26:33,200
더에 빌딩 블록으로 사용될 수
복잡한 데이터 구조.

635
00:26:33,200 --> 00:26:37,620
>> 그리고 여기 너무 테마를 실현은 그
우리는 절대적으로 더 소개했다

636
00:26:37,620 --> 00:26:40,060
구현에 복잡성
이 알고리즘.

637
00:26:40,060 --> 00:26:43,940
삽입, 우리는 그것을 통해 간 경우,
삭제 및 검색은 조금

638
00:26:43,940 --> 00:26:46,660
그것보다 더 복잡
배열했다.

639
00:26:46,660 --> 00:26:48,040
그러나 우리는 어떤 활력을 얻을 수 있습니다.

640
00:26:48,040 --> 00:26:50,180
우리는 적응 데이터 구조를 얻을.

641
00:26:50,180 --> 00:26:54,010
>> 그러나 다시, 우리는 몇 가지를 갖는 가격을 지불
추가적인 복잡성의 두

642
00:26:54,010 --> 00:26:54,910
그것을 구현.

643
00:26:54,910 --> 00:26:56,750
그리고 우리는 무작위 액세스를 제공하고 있습니다.

644
00:26:56,750 --> 00:27:00,450
그리고 솔직히, 멋진이 아니다
슬라이드를 청소 난 당신을 줄 수있는

645
00:27:00,450 --> 00:27:03,120
여기에서 말하는 이유는 연결 목록입니다
배열보다 낫다.

646
00:27:03,120 --> 00:27:04,100
그리고에 그것을 두십시오.

647
00:27:04,100 --> 00:27:07,520
테마도, 지금은 재발하기 때문에
더 그렇게 앞으로 몇 주 안에있다

648
00:27:07,520 --> 00:27:10,200
반드시이 아니라고
정답.

649
00:27:10,200 --> 00:27:13,830
>> 우리는 별도의 축이 이유입니다
문제 세트 디자인.

650
00:27:13,830 --> 00:27:17,700
그것은 매우 문맥에 맞는 것입니다
이 데이터를 사용할지 여부

651
00:27:17,700 --> 00:27:21,750
구조 나 하나, 그것은 것입니다
측면에서 당신에게 중요한 무엇에 따라 달라집니다

652
00:27:21,750 --> 00:27:24,620
자원과 복잡성.

653
00:27:24,620 --> 00:27:28,830
>> 하지만 내가 제안하자 그 이상 데이터
구조 성배는 것

654
00:27:28,830 --> 00:27:32,200
시간 상수 뭔가,
에 관계없이 많은 재료가되는 방법

655
00:27:32,200 --> 00:27:36,940
그 안에, 그것은 놀라운되지 않을 것 경우
데이터 구조는 답을 반환

656
00:27:36,940 --> 00:27:37,920
일정 시간입니다.

657
00:27:37,920 --> 00:27:38,330
예.

658
00:27:38,330 --> 00:27:40,110
이 단어는 큰 사전입니다.

659
00:27:40,110 --> 00:27:41,550
또는 아니,이 단어는 없습니다.

660
00:27:41,550 --> 00:27:43,270
아니면 그러한 문제.

661
00:27:43,270 --> 00:27:46,360
잘 보자 우리가 적어도 수 있다면
그 방향으로 조치를 취할.

662
00:27:46,360 --> 00:27:50,190
>> 내가 새 데이터 구조를 제안하게하는
다른 것들을 사용할 수 있습니다,

663
00:27:50,190 --> 00:27:52,260
이 경우 해시 테이블이라고.

664
00:27:52,260 --> 00:27:55,590
그래서 우리는이기는 다시 사실입니다
이 경우 배열과의

665
00:27:55,590 --> 00:28:00,550
임으로,이 그려진 것
의 종류와 배열로 해시 테이블

666
00:28:00,550 --> 00:28:02,810
2 차원 배열 -

667
00:28:02,810 --> 00:28:05,410
또는 오히려이 두 여기에 묘사 된 것
차원 배열 - 그러나 이것은 단지

668
00:28:05,410 --> 00:28:10,770
같은 크기 26의 배열, 그 경우 우리
배열 테이블, 테​​이블 받침대를 호출

669
00:28:10,770 --> 00:28:12,440
제로 상단에 사각형입니다.

670
00:28:12,440 --> 00:28:15,090
테이블 브라켓 25 사각형이다
아래에.

671
00:28:15,090 --> 00:28:18,620
그리고 내가 데이터를 그릴 수있는 방법입니다
내가 저장할 구조

672
00:28:18,620 --> 00:28:19,790
사람의 이름.

673
00:28:19,790 --> 00:28:24,370
>> 그래서 예를 들어, 난을 그릴 수 없습니다
여기에 오버 헤드에 모든 것을, 만약 내가

674
00:28:24,370 --> 00:28:29,160
내가 지금 갈거야이 배열을했다
해시 테이블을 호출하고,이 또 다시

675
00:28:29,160 --> 00:28:31,360
위치 제로.

676
00:28:31,360 --> 00:28:34,840
이것은 여기에 위치입니다
하나 등등.

677
00:28:34,840 --> 00:28:37,880
나는이 데이터를 사용하려는 주장
구조, 토론을 위해,

678
00:28:37,880 --> 00:28:42,600
사람의 이름을 저장하기 위해, Alice와 Bob
찰리와 같은 다른 이름.

679
00:28:42,600 --> 00:28:46,110
그래서 시작으로 지금의 생각
사전, 말의

680
00:28:46,110 --> 00:28:47,520
단어의 제비를 가진.

681
00:28:47,520 --> 00:28:49,435
그들은 이름이 될 일이
여기에 우리의 예제합니다.

682
00:28:49,435 --> 00:28:52,560
그리고 이것은에, 아마도 너무나 밀접한입니다
우리와 같이 맞춤법 검사기를 구현

683
00:28:52,560 --> 00:28:54,400
문제에 대한 여섯 설정할 수 있습니다.

684
00:28:54,400 --> 00:28:59,300
>> 우리는 전체 크기 26의 배열이있는 경우에는
이 25 일 위치되도록

685
00:28:59,300 --> 00:29:03,390
하단에, 나는 앨리스이라고 주장
사전의 첫 번째 단어

686
00:29:03,390 --> 00:29:07,260
내가 RAM에 삽입 할 이름,
이 데이터 구조로, 어디

687
00:29:07,260 --> 00:29:12,480
말하고 본능이 앨리스의
이름이 배열에 가야하나요?

688
00:29:12,480 --> 00:29:13,510
>> 우리는 26 옵션이 있습니다.

689
00:29:13,510 --> 00:29:14,990
우리는 그녀를두고 싶은?

690
00:29:14,990 --> 00:29:16,200
우리는 브라켓 제로에서 그녀를 원하는 맞죠?

691
00:29:16,200 --> 00:29:18,280
앨리스에 대한이의 그 제로를 호출 할 수 있습니다.

692
00:29:18,280 --> 00:29:20,110
그리고 B는 하나가 될 것입니다, 그리고 C는 두 가지가됩니다.

693
00:29:20,110 --> 00:29:22,600
그래서 우리는 쓸거야
여기에 앨리스의 이름을 백업합니다.

694
00:29:22,600 --> 00:29:24,890
우리는 밥, 자신을 삽입 할 경우
이름이 여기에 갈 것이다.

695
00:29:24,890 --> 00:29:27,280
찰리는 여기에 갈 것이다.

696
00:29:27,280 --> 00:29:30,500
등등 다운을 통해
이 데이터 구조입니다.

697
00:29:30,500 --> 00:29:32,090
>> 이 멋진 데이터 구조입니다.

698
00:29:32,090 --> 00:29:32,730
왜?

699
00:29:32,730 --> 00:29:37,460
잘 실행 시간은 무엇인가
이것으로 사람의 이름을 삽입

700
00:29:37,460 --> 00:29:39,850
지금은 데이터 구조를?

701
00:29:39,850 --> 00:29:43,702
이 테이블이 구현되는 것을 감안할 때,
진정, 배열.

702
00:29:43,702 --> 00:29:44,940
잘 일정한 시간이다.

703
00:29:44,940 --> 00:29:45,800
그것은 하나의 명령이다.

704
00:29:45,800 --> 00:29:46,360
왜?

705
00:29:46,360 --> 00:29:48,630
>> 그럼 당신은 어떻게 결정합니까
앨리스는 어디에 속해?

706
00:29:48,630 --> 00:29:51,000
당신은 그녀의 이름의 한 편지를 보여?

707
00:29:51,000 --> 00:29:51,490
첫번째로 올려주세요.

708
00:29:51,490 --> 00:29:54,350
이 문자열 인 경우 그리고 당신은 거기에 얻을 수 있습니다
단지 문자열을 확인하여

709
00:29:54,350 --> 00:29:55,200
브라켓 제로.

710
00:29:55,200 --> 00:29:57,110
문자열의 0 번째 문자 때문에.

711
00:29:57,110 --> 00:29:57,610
그것은 간단합니다.

712
00:29:57,610 --> 00:30:00,350
우리는 암호에 해당했다
할당 주 전.

713
00:30:00,350 --> 00:30:05,310
그리고 일단 당신이 앨리스의 알
편지를 수도, 우리는 뺄 수 있습니다

714
00:30:05,310 --> 00:30:08,160
65 자본 자체 할인
그것은 우리에게 영을 준다.

715
00:30:08,160 --> 00:30:10,940
그래서 우리는 이제 앨리스가 속한 것을 알고
위치 제로.

716
00:30:10,940 --> 00:30:14,240
>> 그리고이 데이터에 대한 포인터를 제공
구조는 일종의, 얼마나합니까

717
00:30:14,240 --> 00:30:18,840
그것은 위치를 찾으려면 데려가
배열의 제로?

718
00:30:18,840 --> 00:30:22,080
한 단계는, 바로 그것은 일정한 시간
랜덤 액세스 때문에 우리

719
00:30:22,080 --> 00:30:23,780
제안은 배열의 특징이었다.

720
00:30:23,780 --> 00:30:28,570
그래서 짧은, 알아내는 무슨 색인
앨리스의 이름에,이다,이다

721
00:30:28,570 --> 00:30:32,610
이 경우는, 또는하자 그냥 해결
제로 여기서, B는 하나이며, C는 그

722
00:30:32,610 --> 00:30:34,900
두 그렇게 파악
일정 시간입니다.

723
00:30:34,900 --> 00:30:38,510
난 그냥 그녀의 첫 글자를보고해야
제로 곳 알아 냈어

724
00:30:38,510 --> 00:30:40,460
배열은 일정 시간입니다.

725
00:30:40,460 --> 00:30:42,140
그래서 기술적으로 그건
지금은 두 단계처럼.

726
00:30:42,140 --> 00:30:43,330
그러나 여전히 상수이다.

727
00:30:43,330 --> 00:30:46,880
그래서 우리는 하나의 큰 O를 호출, 그래서 우리는했습니다
이 테이블에 앨리스를 삽입

728
00:30:46,880 --> 00:30:48,440
일정 시간입니다.

729
00:30:48,440 --> 00:30:50,960
>> 물론, 내가되고있어
여기에 순진, 맞죠?

730
00:30:50,960 --> 00:30:53,240
어떤 클래스의 아론이 있다면?

731
00:30:53,240 --> 00:30:53,990
또는 알리시아?

732
00:30:53,990 --> 00:30:57,230
또는 다른 이름으로 시작
A. 우리가 어디 넣어 가고있다

733
00:30:57,230 --> 00:31:00,800
그 사람 맞죠?

734
00:31:00,800 --> 00:31:03,420
내 말은, 지금은 세 개만있다
테이블에 사람들이, 어쩌면 우리

735
00:31:03,420 --> 00:31:07,490
위치 아론을 넣어야한다
제로 하나 둘 셋.

736
00:31:07,490 --> 00:31:09,480
>> 오른쪽, 여기를 넣을 수 있습니다.

737
00:31:09,480 --> 00:31:13,350
하지만, 우리는에 다윗을 삽입하려고하면
이 목록은 다윗이 어디로 가야합니까?

738
00:31:13,350 --> 00:31:15,170
지금 우리의 시스템은 침입 시작
아래 오른쪽?

739
00:31:15,170 --> 00:31:19,210
이제 다윗은 여기서 끝납니다
아론은 실제로 여기됩니다.

740
00:31:19,210 --> 00:31:23,060
를 갖는 그리고 지금은이 모든 아이디어
우리를주는 깨끗한 데이터 구조

741
00:31:23,060 --> 00:31:28,010
일정 시간 삽입이 더 이상
내가해야하기 때문에 시간 상수,

742
00:31:28,010 --> 00:31:31,240
확인, 오, 제기랄, 누군가가 벌써
앨리스의 위치.

743
00:31:31,240 --> 00:31:35,320
>> 날이 데이터의 나머지 부분을 조사하자
구조 넣는 장소를 찾고

744
00:31:35,320 --> 00:31:37,130
아론의 이름이 같은 사람.

745
00:31:37,130 --> 00:31:39,390
그리고도 시작됩니다
선형 시간이 걸릴 수 있습니다.

746
00:31:39,390 --> 00:31:42,710
또한, 당신은 지금을 찾으려면
이 데이터 구조 아론, 그리고

747
00:31:42,710 --> 00:31:45,430
확인하고, 아론의 이름은 여기에 없습니다.

748
00:31:45,430 --> 00:31:47,960
이상적으로, 당신은 아론의 말 것
없는 데이터 구조합니다.

749
00:31:47,960 --> 00:31:51,530
그러나 당신이 경우에 공간을 만들기 시작
아론은 여기서 D가 있었어야

750
00:31:51,530 --> 00:31:55,600
또는 E, 당신은, 최악의 경우, 확인해야합니다
에서 전체 데이터 구조,

751
00:31:55,600 --> 00:31:59,480
무언가에 양도한다이 경우
테이블의 크기에 선형.

752
00:31:59,480 --> 00:32:00,920
>> 모든 권리 그래서,이 문제를 해결할 수 있습니다.

753
00:32:00,920 --> 00:32:04,200
여기서 문제는 내가했다는 것입니다
이 배열의 26 요소입니다.

754
00:32:04,200 --> 00:32:05,000
내가 그것을 변경할 수 있습니다.

755
00:32:05,000 --> 00:32:06,010
으악.

756
00:32:06,010 --> 00:32:10,600
대신의 존재하므로 내가 그것을 변경할 수
총 크기 26, 바닥을 알 수

757
00:32:10,600 --> 00:32:12,720
인덱스 n은 마이너스 1로 바꿀 것입니다.

758
00:32:12,720 --> 00:32:16,610
26 인간 '에 대해 명확하게 너무 작은 경우
이름 때문에 수천있다

759
00:32:16,610 --> 00:32:20,830
세계의 이름은은 그냥 만들어 보자
100 1,000 1만인치

760
00:32:20,830 --> 00:32:22,960
의 단지 더 많은 공간을 할당 할 수 있습니다.

761
00:32:22,960 --> 00:32:27,230
>> 잘 반드시 감소하지 않는
우리는 두 가지 문제가 발생하지 않습니다 가능성

762
00:32:27,230 --> 00:32:31,510
이름으로 사람들로 시작하고,
그래서, 당신은 넣어 시도하려고했다

763
00:32:31,510 --> 00:32:33,120
아직 위치 제로에 이름.

764
00:32:33,120 --> 00:32:36,850
그들은 여전히​​ 충돌려고하는
우리는 아직도 넣어 솔루션을 필요 의미

765
00:32:36,850 --> 00:32:41,020
Alice와 아론과 알리시아 및 기타
다른로 시작하는 이름.

766
00:32:41,020 --> 00:32:43,460
하지만이 얼마나 문제인가?

767
00:32:43,460 --> 00:32:46,870
확률은 그게 당신
데이터 충돌이

768
00:32:46,870 --> 00:32:48,240
이런 구조?

769
00:32:48,240 --> 00:32:52,570
>> 음, 저를 보자 - 우리는 돌아올거야
여기 그 질문에.

770
00:32:52,570 --> 00:32:55,530
그리고 어떻게 우리가 수도보고
먼저 해결.

771
00:32:55,530 --> 00:32:58,480
내가 여기서이 제안을 당겨 보자.

772
00:32:58,480 --> 00:33:02,020
우리가 방금 설명한 것은 알고리즘
선형이라는 추론

773
00:33:02,020 --> 00:33:05,030
를 삽입하려고하면, 그것에 프로빙
이 데이터에 뭔가

774
00:33:05,030 --> 00:33:08,920
해시 테이블이라고 구조,
그리고 여지 당신은 거기에 없다

775
00:33:08,920 --> 00:33:12,000
진정한 데이터 구조를 조사
점검이 사용할 수 있습니까?

776
00:33:12,000 --> 00:33:13,430
이 가능한이 사용할 수 있습니다?

777
00:33:13,430 --> 00:33:13,980
이 사용할 수 있습니까?

778
00:33:13,980 --> 00:33:17,550
그리고 마침내 때, 당신은 삽입
당신이 원래 의도 한 이름

779
00:33:17,550 --> 00:33:19,370
다른 그 위치에서.

780
00:33:19,370 --> 00:33:23,360
그러나 최악의 경우, 만 자리
데이터의 맨 아래있을 수 있습니다

781
00:33:23,360 --> 00:33:25,090
구조, 배열의 끝.

782
00:33:25,090 --> 00:33:30,130
>> 그래서 선형 최악의 경우, 프로빙,
선형 알고리즘에 양도한다 여기서

783
00:33:30,130 --> 00:33:34,500
아론, 그가 마지막으로 삽입 할 수 일어나는 경우
이 데이터 구조에, 그는 수도

784
00:33:34,500 --> 00:33:39,540
이 첫 번째 위치에 충돌하지만,
다음 맨 마지막에 나쁜 행운으로 끝납니다.

785
00:33:39,540 --> 00:33:43,940
그래서이 일정하지 않다
저희를위한 시간 성배.

786
00:33:43,940 --> 00:33:47,650
삽입이 요소 접근 방식에
데이터 구조 해시라고

787
00:33:47,650 --> 00:33:52,050
테이블은 일정 시간이 될 것 같지 않습니다
적어도 일반적인 경우합니다.

788
00:33:52,050 --> 00:33:54,000
그것은 선형 무언가로 바뀔 수 있습니다.

789
00:33:54,000 --> 00:33:56,970
>> 우리는 충돌을 해결 그래서 경우
다소 다르게?

790
00:33:56,970 --> 00:34:00,740
그래서 여기가 더 정교의
아직도 무엇을 접근

791
00:34:00,740 --> 00:34:02,800
해시 테이블이라고.

792
00:34:02,800 --> 00:34:05,890
및 해시, 옆으로, 무엇으로
그 인덱스를 의미

793
00:34:05,890 --> 00:34:07,070
아까 언급.

794
00:34:07,070 --> 00:34:09,810
에 해시 뭔가 할 수 있습니다
동사로 생각했다.

795
00:34:09,810 --> 00:34:13,690
>> 당신 해시 앨리스는 이름의 경우에,
해시 함수 말하자면,

796
00:34:13,690 --> 00:34:14,710
숫자를 반환해야합니다.

797
00:34:14,710 --> 00:34:18,199
그녀는에 속하는 경우이 경우 제로
그녀는에 속하는 경우 위치 0 개

798
00:34:18,199 --> 00:34:20,000
위치 하나, 등등.

799
00:34:20,000 --> 00:34:24,360
그래서 내 해시 함수는 지금까지왔다
간단한 초 만보고

800
00:34:24,360 --> 00:34:26,159
사람의 이름 첫 글자.

801
00:34:26,159 --> 00:34:29,090
하지만 해시 함수로 간다
입력 데이터의 일부 조각

802
00:34:29,090 --> 00:34:30,210
문자열 중간, 뭐든간에.

803
00:34:30,210 --> 00:34:32,239
그리고 그것은 일반적으로 숫자를 뱉어.

804
00:34:32,239 --> 00:34:35,739
그리고 그 번호는 어디에 해당 데이터
요소는 데이터 구조에 속하는

805
00:34:35,739 --> 00:34:37,800
해시 테이블로 여기 알려져 있습니다.

806
00:34:37,800 --> 00:34:41,400
>> 그래서 그냥 직관적으로, 이것이다
약간 다른 상황.

807
00:34:41,400 --> 00:34:44,170
이것은 실제로 예제를 참조합니다
관련 생일, 여기서

808
00:34:44,170 --> 00:34:46,850
만큼이있을 수 있습니다
월 31 일.

809
00:34:46,850 --> 00:34:52,239
하지만이 사람에게 무엇을 결정 했
충돌의 경우에합니까?

810
00:34:52,239 --> 00:34:55,304
컨텍스트는 현재의 충돌되지 것
이름 만 생일의 충돌,

811
00:34:55,304 --> 00:35:00,760
두 사람의 같은 생일이있는 경우
예를 들어 10 월 2 일.

812
00:35:00,760 --> 00:35:02,120
>> 학생 : [들림].

813
00:35:02,120 --> 00:35:05,010
>> 스피커 1 : 그래, 그래서 여기에 우리가
연결리스트의 활용.

814
00:35:05,010 --> 00:35:07,830
그래서 조금 다르게 보인다
우리는 그것을 먼저 그려보다.

815
00:35:07,830 --> 00:35:10,790
그러나 우리는 배열을 가지고있는 것 같습니다
왼쪽에.

816
00:35:10,790 --> 00:35:13,230
즉 더를 위해, 하나의 인덱스 없다
특별한 이유.

817
00:35:13,230 --> 00:35:14,630
하지만 여전히 배열입니다.

818
00:35:14,630 --> 00:35:16,160
그것은 포인터의 배열입니다.

819
00:35:16,160 --> 00:35:20,670
각각의 이러한 요소 각각
이러한 원이나 슬래시 - 슬래시

820
00:35:20,670 --> 00:35:23,970
나타내는 널 (null) -이 각각의
포인터는 분명히 가리키고

821
00:35:23,970 --> 00:35:25,730
어떤 데이터 구조를?

822
00:35:25,730 --> 00:35:26,890
링크 된 목록입니다.

823
00:35:26,890 --> 00:35:30,530
>> 그래서 지금 우리가 할 수있는 능력을 가지고
우리의 프로그램에 하드 코드

824
00:35:30,530 --> 00:35:32,010
테이블의 크기입니다.

825
00:35:32,010 --> 00:35:35,360
이 경우, 우리가 결코 알
한달에 31 개 이상의 일.

826
00:35:35,360 --> 00:35:38,480
열심히 31과 같은 값입니다 코딩
그 상황에서 합리적.

827
00:35:38,480 --> 00:35:42,700
이름의 맥락에서, 하드 코딩
26 무리없는 그 사람들의

828
00:35:42,700 --> 00:35:46,340
이름은, 예를 들어,로 시작
Z까지를 포함하는 알파벳

829
00:35:46,340 --> 00:35:50,180
>> 우리는 데이터로 그들 모두를 벼락 공부를 할 수 있습니다
구조 그렇게 오랫동안 우리가 얻을 때, 등

830
00:35:50,180 --> 00:35:55,330
충돌, 우리는 여기에 이​​름을 넣지 않고,
우리는 대신에 이들 세포의 생각

831
00:35:55,330 --> 00:36:00,270
문자열이 아닌 자체 만만큼
예를 들어, 앨리스에 대한 포인터.

832
00:36:00,270 --> 00:36:03,660
그리고 앨리스는 또 다른 포인터를 가질 수 있습니다
로 시작하는 다른 이름

833
00:36:03,660 --> 00:36:06,150
A. 그리고 밥은 실제로 여기에 간다.

834
00:36:06,150 --> 00:36:10,850
>> 그리고 시작 다른 이름이 있다면
B로, 그는 여기에 끝납니다.

835
00:36:10,850 --> 00:36:15,070
그리고 이것의 각 요소
우리가 설계하는 경우 테이블 두 개,

836
00:36:15,070 --> 00:36:17,350
조금 더 영리 -

837
00:36:17,350 --> 00:36:18,125
어서 -

838
00:36:18,125 --> 00:36:22,950
우리는이 조금 더 디자인하는 경우
영리, 지금은 적응 데이터가됩니다

839
00:36:22,950 --> 00:36:27,720
아무 하드 제한은 없습니다 구조
당신은 삽입 할 수 있습니다 얼마나 많은 요소

840
00:36:27,720 --> 00:36:30,700
그것으로 당신이 할 경우가 있기 때문에
충돌, 그 괜찮습니다.

841
00:36:30,700 --> 00:36:34,690
그냥 가서 그것을에 추가
우리는이었다 조금 전 보았던

842
00:36:34,690 --> 00:36:38,290
연결리스트로 알려져 있습니다.

843
00:36:38,290 --> 00:36:39,690
>> 그럼 그냥 잠시 동안의 일시 정지를 할 수 있습니다.

844
00:36:39,690 --> 00:36:42,570
충돌 확률은 얼마인가
첫 번째 장소에서?

845
00:36:42,570 --> 00:36:45,480
그래, 어쩌면 내가 이상, 어쩌면 생각 해요
나는이 문제를 설계 할 이상 해요

846
00:36:45,480 --> 00:36:46,370
당신은 무엇을 알고 있기 때문에?

847
00:36:46,370 --> 00:36:49,070
네, 임의 가지고 올 수
처럼 내 머리의 맨 오프 예

848
00:36:49,070 --> 00:36:52,870
앨리슨와 아론하지만, 현실에서,
의 균일 한 분포 부여

849
00:36:52,870 --> 00:36:56,990
어떤 임의의 삽입이다 입력,
데이터 구조로 정말로 무엇인가

850
00:36:56,990 --> 00:36:58,580
충돌 확률은?

851
00:36:58,580 --> 00:37:01,670
잘 밝혀, 사실의
초고.

852
00:37:01,670 --> 00:37:03,850
이 날 일반화하자
문제는 이것과 같습니다.

853
00:37:03,850 --> 00:37:08,890
>> 따라서 N의 방에 CS50 학생, 무엇을
확률이 적어도

854
00:37:08,890 --> 00:37:11,010
방에 두 학생
같은 생일이?

855
00:37:11,010 --> 00:37:13,346
그래서이있다. 몇 훈트 -

856
00:37:13,346 --> 00:37:16,790
여기 몇 가지 200, 3백명
오늘 집에서 백명.

857
00:37:16,790 --> 00:37:20,670
당신은 무엇을 스스로에게 물어보고 싶은게 너무 경우
두 사람의 확률

858
00:37:20,670 --> 00:37:23,930
같은 생일을 가진이 방에,
우리는이 알아낼 수 있습니다.

859
00:37:23,930 --> 00:37:26,250
그리고 두 께가 실제로 주장
같은 생일을 가진 사람.

860
00:37:26,250 --> 00:37:29,560
>> 예를 들어, 사람이하지
오늘 생일이?

861
00:37:29,560 --> 00:37:31,340
어제?

862
00:37:31,340 --> 00:37:32,590
내일?

863
00:37:32,590 --> 00:37:35,980
내가 갈거야처럼 좋아, 그래서 느낌
더보기이 363 정도를해야합니다

864
00:37:35,980 --> 00:37:39,500
시간은 실제로 알아낼
우리가 할 경우에 충돌이 있습니다.

865
00:37:39,500 --> 00:37:42,350
아니면 우리가 수학적으로이 작업을 수행 할 수
오히려 지루하고 이상

866
00:37:42,350 --> 00:37:43,200
이 작업을 수행.

867
00:37:43,200 --> 00:37:44,500
다음을 제안한다.

868
00:37:44,500 --> 00:37:48,740
>> 그래서 우리가 모델링 할 수있는 제안
을 가진 두 사람의 확률

869
00:37:48,740 --> 00:37:55,320
1의 확률 같은 생일
필요없이 하나의 마이너스 확률

870
00:37:55,320 --> 00:37:56,290
같은 생일.

871
00:37:56,290 --> 00:37:59,960
그래서를 얻으려면,이 단지입니다
이를 작성하는 멋진 방법

872
00:37:59,960 --> 00:38:03,090
객실 내 첫 번째 사람이, 그 또는 그녀
수 중 하나를 가질 수 있습니다

873
00:38:03,090 --> 00:38:07,370
생일은 일년 365 일 가정
가진 사람에게 사과를

874
00:38:07,370 --> 00:38:08,760
2월 29일 생일.

875
00:38:08,760 --> 00:38:13,470
>> 그래서이 방에있는 첫 번째 사람은 무료입니다
생일의 수를 가지고

876
00:38:13,470 --> 00:38:18,280
밖으로 365의 가능성이 있으므로
우리는 365 365 나눈 할 것이다

877
00:38:18,280 --> 00:38:18,990
이는 하나입니다.

878
00:38:18,990 --> 00:38:22,700
방에있는 다음 사람, 만약 목표
충돌을 방지하는 것입니다, 수 만

879
00:38:22,700 --> 00:38:26,460
방법에 대한 자신의 생일을이
여러 가지 가능한 일?

880
00:38:26,460 --> 00:38:27,610
364.

881
00:38:27,610 --> 00:38:31,430
따라서이 식의 두 번째 항은
기본적으로 우리가 수학을하고

882
00:38:31,430 --> 00:38:33,460
한 가지 일을 뺀 있습니다.

883
00:38:33,460 --> 00:38:36,390
그리고 다음 날, 그 다음 날,
아래의 총 개수로 다음날

884
00:38:36,390 --> 00:38:38,100
방에있는 사람들의.

885
00:38:38,100 --> 00:38:41,290
>> 그리고 우리는 고려하면, 그 무엇
의 유무 사람의 확률

886
00:38:41,290 --> 00:38:45,265
독특한 생일, 그러나 다시 1을 뺀
즉, 우리가 얻을 것은 표현

887
00:38:45,265 --> 00:38:47,810
그것은 매우 기발 할 수 있습니다
다음과 같습니다.

888
00:38:47,810 --> 00:38:50,330
그러나 더 흥미로운
시각적으로 볼 수 있습니다.

889
00:38:50,330 --> 00:38:55,120
이 x 축에 차트입니다
방에있는 사람의 수,

890
00:38:55,120 --> 00:38:56,180
생일의 수.

891
00:38:56,180 --> 00:38:59,840
y 축에 대한 확률은
충돌의 두 사람

892
00:38:59,840 --> 00:39:01,230
같은 생일 데.

893
00:39:01,230 --> 00:39:05,020
>> 그리고이 곡선에서 테이크 아웃입니다
즉 당신이 40 좋아하는 받자 마자

894
00:39:05,020 --> 00:39:11,110
학생, 당신은 90 %의 확률로 최대있어
combinatorically 두

895
00:39:11,110 --> 00:39:13,550
명 이상 필요
같은 생일.

896
00:39:13,550 --> 00:39:18,600
그리고 일단 당신이 그것을의 58명을 좋아 얻을
기회 두의 거의 100 %

897
00:39:18,600 --> 00:39:21,310
방에있는 사람들을 위하여려고하고있다
같은 생일,있다하더라도

898
00:39:21,310 --> 00:39:26,650
365 또는 366 가능한 물통 및
방에있는 유일한 58명.

899
00:39:26,650 --> 00:39:29,900
다만 통계적으로 당신은 가능성이있어
, 충돌을하는 짧은

900
00:39:29,900 --> 00:39:31,810
이 토론을 동기를 부여.

901
00:39:31,810 --> 00:39:35,890
우리는 여기에서 멋진 얻고, 경우에도 그
이러한 체인을 가지고 시작, 우리는 아직도

902
00:39:35,890 --> 00:39:36,950
충돌을해야 할 것.

903
00:39:36,950 --> 00:39:42,710
>> 질문을 구걸 그래서, 무엇입니까
삽입과 삭제를 수행 비용

904
00:39:42,710 --> 00:39:44,850
이 같은 데이터 구조에?

905
00:39:44,850 --> 00:39:46,630
그럼 내가 제안하자 -

906
00:39:46,630 --> 00:39:51,570
그리고 나를 통해 화면으로 돌아 가자
여기에 - 우리의 요소를 n을 한 경우

907
00:39:51,570 --> 00:39:56,330
목록, 그래서 우리는 삽입하려는 경우
n 개의 요소, 그리고 우리는이

908
00:39:56,330 --> 00:39:58,050
얼마나 많은 총 버킷?

909
00:39:58,050 --> 00:40:03,450
하자 총 31 버킷 말
생일의 경우합니다.

910
00:40:03,450 --> 00:40:09,240
하나의 최대 길이는 무엇입니까
잠재적으로 이러한 체인?

911
00:40:09,240 --> 00:40:12,670
>> 다시 가능 31이 있다면
해당 월의 생일.

912
00:40:12,670 --> 00:40:14,580
그리고 우리가 모두 응집거야 -

913
00:40:14,580 --> 00:40:15,580
실제로는 바보 같은 예입니다.

914
00:40:15,580 --> 00:40:16,960
대신 26을 봅시다.

915
00:40:16,960 --> 00:40:20,890
실제로 이름이 사람이있는 경우에는
따라서 포기, A에서 Z까지로 시작

916
00:40:20,890 --> 00:40:22,780
우리는 26 가능성.

917
00:40:22,780 --> 00:40:25,920
그리고 우리는 같은 데이터 구조를 사용하는
우리가 그것에 우리가 보았던 하나,

918
00:40:25,920 --> 00:40:30,210
포인터의 배열 된 각
연결리스트를 가리키는

919
00:40:30,210 --> 00:40:32,360
첫 번째 목록은 모든 사람입니다
이름을 앨리스.

920
00:40:32,360 --> 00:40:35,770
두 번째 목록은 모든 첨부
시작,로 시작하는 이름을

921
00:40:35,770 --> 00:40:36,980
B와, 등등.

922
00:40:36,980 --> 00:40:41,020
>> 각각의 가능성 길이는 무엇입니까
해당 목록 우리는 좋은 깨끗한 가정하면

923
00:40:41,020 --> 00:40:45,410
Z까지 이름의 분포
전체 데이터 구조를 통해?

924
00:40:45,410 --> 00:40:50,210
데이터 구조의 N 사람들이있다
그들이 잘한다면, 26로 나눈

925
00:40:50,210 --> 00:40:52,110
전체에 퍼져
데이터 구조.

926
00:40:52,110 --> 00:40:54,970
따라서 이들 각각의 길이
체인은 26로 나눈 n입니다.

927
00:40:54,970 --> 00:40:57,380
그러나 큰 O 표기법, 즉 무엇인가?

928
00:40:57,380 --> 00:41:00,100

929
00:41:00,100 --> 00:41:02,440
정말 그렇게 무엇입니까?

930
00:41:02,440 --> 00:41:04,150
그래서 오른쪽, 정말 그냥 N입니까?

931
00:41:04,150 --> 00:41:06,620
우리는 과거에 말한 때문에,
우 당신은 26로 나누어합니다.

932
00:41:06,620 --> 00:41:08,710
예, 실제로는 더 빠르다.

933
00:41:08,710 --> 00:41:12,720
그러나 이론적으로, 그것은 근본적 아니다
모든 것을 빨리.

934
00:41:12,720 --> 00:41:16,040
>> 그래서 우리는 모두 그 정도되지 않는 것 같습니다
가까이이 성배.

935
00:41:16,040 --> 00:41:17,750
사실,이 단지 선형 시간입니다.

936
00:41:17,750 --> 00:41:20,790
도대체이 시점에서, 왜 우리는하지 않습니다
하나의 거대한 연결 목록을 사용합니까?

937
00:41:20,790 --> 00:41:23,510
왜 우리는 하나의 거대한을 사용하지 않는
의 이름을 저장하는 배열

938
00:41:23,510 --> 00:41:25,010
방에있는 사람?

939
00:41:25,010 --> 00:41:28,280
음, 뭔가가 남아 있습니다
해시 테이블에 대한 강력한?

940
00:41:28,280 --> 00:41:30,810
강력한 뭔가가 남아 있습니다
데이터 구조에 대한

941
00:41:30,810 --> 00:41:33,940
즉, 다음과 같습니다?

942
00:41:33,940 --> 00:41:35,182
이.

943
00:41:35,182 --> 00:41:37,050
>> 학생 : [들림].

944
00:41:37,050 --> 00:41:39,840
>> 스피커 1 : 그것은 단지 오른쪽, 다시 경우
선형 시간 알고리즘 및

945
00:41:39,840 --> 00:41:42,780
선형 시간 데이터 구조, 왜하지
단지 큰 모든 사람의 이름을 저장

946
00:41:42,780 --> 00:41:44,210
배열 또는 큰 연결리스트에서?

947
00:41:44,210 --> 00:41:47,010
그리고 훨씬 더 CS을 중단
그것은 필요 이상?

948
00:41:47,010 --> 00:41:49,600

949
00:41:49,600 --> 00:41:53,190
심지어 이것에 대해 강력한 무엇입니까
나는 그것을 긁어하지만?

950
00:41:53,190 --> 00:41:54,930
>> 학생 : [들림].

951
00:41:54,930 --> 00:41:57,040
>> 스피커 1 : 삽입의이되지 않습니다?

952
00:41:57,040 --> 00:41:58,140
더 이상 비싼.

953
00:41:58,140 --> 00:42:03,390
그래서 삽입은 잠재적 여전히 수
일정한 시간이 될 경우에도 데이터

954
00:42:03,390 --> 00:42:07,910
구조는 다음과 같이 배열을 보이는
포인터가 가리키는 각각의

955
00:42:07,910 --> 00:42:09,550
잠재적으로 연결된 목록입니다.

956
00:42:09,550 --> 00:42:15,220
당신은 어떻게 일정하게 달성 할 수
이름 시간 삽입?

957
00:42:15,220 --> 00:42:16,280
바로 앞에 붙여?

958
00:42:16,280 --> 00:42:19,290
>> 우리의 디자인 목표를 희생하는 경우
이전에, 우리는 계속 싶었던

959
00:42:19,290 --> 00:42:22,650
사람의 이름은, 예를 들어, 정렬
또는 무대에서 모든 숫자는 분류

960
00:42:22,650 --> 00:42:25,020
우리가이 있다고 가정
분류되지 않은 연결리스트.

961
00:42:25,020 --> 00:42:29,960
그것은 단지 우리에게 하나 또는 두 단계를 비용
벤과 브라이언의 경우처럼

962
00:42:29,960 --> 00:42:32,750
이전에 요소를 삽입하는 방법
목록의 시작입니다.

963
00:42:32,750 --> 00:42:36,090
우리 모두 정렬 걱정하지 않도록하는 경우
로 시작하는 이름의 일부 또는 전부

964
00:42:36,090 --> 00:42:39,660
B로 시작하는 이름을 우리는 아직 할 수
일정 시간 삽입을 얻을 수 있습니다.

965
00:42:39,660 --> 00:42:43,900
이제 앨리스 나 밥 또는 이름을 찾고
더 일반적으로 아직 무엇인가?

966
00:42:43,900 --> 00:42:48,100
그것은 26로 나눈 N의 큰 O,의
모두가 균일의 이상적인 경우

967
00:42:48,100 --> 00:42:51,190
분산, 많은의가 어디
Z의, 아마도 이는이 있기 때문에

968
00:42:51,190 --> 00:42:52,220
비현실적인.

969
00:42:52,220 --> 00:42:53,880
그러나 여전히 직선입니다.

970
00:42:53,880 --> 00:42:57,120
>> 그러나 여기에서, 우리는 점에 다시 올
인 점근 표기법

971
00:42:57,120 --> 00:42:58,600
이론적으로 사실.

972
00:42:58,600 --> 00:43:02,960
하지만 현실 세계에서, 경우 내가 주장하는
내 프로그램은 26 번 뭔가를 할 수

973
00:43:02,960 --> 00:43:06,210
그 프로그램이 당신보다 더 빠르게
당신이 사용하고 선호하는 건가요?

974
00:43:06,210 --> 00:43:09,660
당신이나 광산, 어떤
26 배 빠른?

975
00:43:09,660 --> 00:43:14,320
현실적으로, 그 사람은 26입니다
배 빠르게, 심지어 이론적 경우

976
00:43:14,320 --> 00:43:18,790
우리의 알고리즘은 동일한에서 실행
실행 시간 점근.

977
00:43:18,790 --> 00:43:20,940
>> 내가 다른을 제안하자
모두 솔루션입니다.

978
00:43:20,940 --> 00:43:24,380
이것은 당신의 마음을 날려하지 않는 경우,
우리는 데이터 구조 나간다.

979
00:43:24,380 --> 00:43:27,420
그래서 그것은 트라이입니다 -

980
00:43:27,420 --> 00:43:28,520
바보 같은 이름의 종류.

981
00:43:28,520 --> 00:43:32,880
그것은 단어에게 번의 검색에서 제공하고,
때문에 트라이, T-R-I-e를 철자

982
00:43:32,880 --> 00:43:34,450
물론 검색은 트라이 같은데.

983
00:43:34,450 --> 00:43:36,580
하지만 그 역사의
단어 트라이의.

984
00:43:36,580 --> 00:43:40,980
>> 그래서 트라이는 실제로 나무의 일종
그리고 그것은 또한 그 단어에 놀이이다.

985
00:43:40,980 --> 00:43:46,330
그리고 당신은 확실히 그것을 볼 수 없지만
이 시각화, 트라이은

986
00:43:46,330 --> 00:43:50,790
나무와 함께 가족 나무처럼, 구조
상단 및 평가 한 조상

987
00:43:50,790 --> 00:43:54,530
손자와 증손
으로는 바닥에 나뭇잎.

988
00:43:54,530 --> 00:43:58,100
그러나 트라이에있는 각 노드는 배열입니다.

989
00:43:58,100 --> 00:44:00,680
그리고 배열에 - 그리고하자
잠시 지나치게 단순화 - 그것은의이

990
00:44:00,680 --> 00:44:04,600
배열이 경우, 크기 26, 여기서
각 노드는 다시 크기의 배열

991
00:44:04,600 --> 00:44:09,000
26 곳의 0 번째 요소
배열을 나타내며, 마지막

992
00:44:09,000 --> 00:44:11,810
이러한 각의 요소
배열 Z.을 나타냅니다

993
00:44:11,810 --> 00:44:15,520
>> 그래서, 다음, 제안하는이 데이터
트라이로 알려진 구조 일 수있다

994
00:44:15,520 --> 00:44:17,600
단어를 저장하는 데에도 사용됩니다.

995
00:44:17,600 --> 00:44:21,740
우리는 우리가 저장할 수있는 방법 순간 전보고
단어, 또는이 경우 이름에, 우리

996
00:44:21,740 --> 00:44:25,440
우리는 번호를 저장할 수있는 방법을 보았던
그러나 우리는 이름이나 문자열에 초점을 맞출 경우

997
00:44:25,440 --> 00:44:27,460
여기에 흥미로운 것을 알 수 있습니다.

998
00:44:27,460 --> 00:44:32,210
그 이름 맥스웰이라고 주장
이 데이터 구조의 내부.

999
00:44:32,210 --> 00:44:33,730
당신은 어디에서 맥스웰을 볼 수 있습니까?

1000
00:44:33,730 --> 00:44:35,140
>> 학생 : [들림].

1001
00:44:35,140 --> 00:44:36,240
>> 스피커 1 : 왼쪽에.

1002
00:44:36,240 --> 00:44:39,910
따라서이 데이터 흥미로운 무엇
구조는 오히려 매장보다

1003
00:44:39,910 --> 00:44:46,200
문자열 M--X-W-E-L-L 백 슬래시 제로, 모든
인접, 대신 무엇을 할

1004
00:44:46,200 --> 00:44:46,890
따르고있다.

1005
00:44:46,890 --> 00:44:50,510
이 데이터 구조와 같은 트라이 경우,
그 각각의 노드는 다시 배열

1006
00:44:50,510 --> 00:44:54,650
그리고 당신은 맥스웰을 저장하려는 경우 먼저
인덱스 등등 때문에 루트의 노드,

1007
00:44:54,650 --> 00:44:57,810
, 최상위 노드를 이야기하기
오른쪽, 그래서 위치 M,에서

1008
00:44:57,810 --> 00:44:59,160
대략 중간에.

1009
00:44:59,160 --> 00:45:03,740
그리고 거기에서, 당신을 따라
자식 노드에 대한 포인터는, 말하자면.

1010
00:45:03,740 --> 00:45:06,150
따라서 가계도 의미에서,
당신은 아래로를 따르십시오.

1011
00:45:06,150 --> 00:45:09,030
그리고 그 다른 노드로 당신을 이끌
거기 왼쪽에

1012
00:45:09,030 --> 00:45:10,540
또 다른 배열입니다.

1013
00:45:10,540 --> 00:45:14,710
>> 그리고 당신은 맥스웰을 저장하려는 경우
당신이 나타내는 포인터를 찾을 수

1014
00:45:14,710 --> 00:45:16,430
A, 이는 여기입니다.

1015
00:45:16,430 --> 00:45:17,840
그런 다음 노드로 이동합니다.

1016
00:45:17,840 --> 00:45:20,100
그리고주의 - 이것은 왜 그림의
약간의 눈속임 -

1017
00:45:20,100 --> 00:45:21,990
이 노드는 작은 슈퍼보세요.

1018
00:45:21,990 --> 00:45:26,050
하지만이 오른쪽에 Y 및 Z를합니다
그것은 바로 저자가 절단되었습니다있어

1019
00:45:26,050 --> 00:45:27,630
사진 있도록 실제
일을 참조하십시오.

1020
00:45:27,630 --> 00:45:30,400
그렇지 않으면이 그림
상당히 넓은 것입니다.

1021
00:45:30,400 --> 00:45:36,180
다음 위치 X로 이제 당신은 색인,
그런 다음 그 W, 그리고 E, L, L. 무엇

1022
00:45:36,180 --> 00:45:37,380
이 호기심?

1023
00:45:37,380 --> 00:45:41,250
>> 음, 우리는 새로운 이런 종류의를 사용하는 경우
에 문자열을 저장하는 방법에 걸릴

1024
00:45:41,250 --> 00:45:44,500
데이터 구조, 당신은 여전히​​ 필요
기본적으로 데이터에 체크 표시

1025
00:45:44,500 --> 00:45:47,250
단어는 여기에 끝나는 구조.

1026
00:45:47,250 --> 00:45:50,830
즉,이 노드의 각
어떻게 든 기억을 가지고 우리

1027
00:45:50,830 --> 00:45:53,500
실제로 다음이 포인터의
그리고 약간의를 떠나

1028
00:45:53,500 --> 00:45:58,370
이것의 여기 하단에 빵 부스러기
M--X-W-E-L-L을 나타내는 구조입니다

1029
00:45:58,370 --> 00:46:00,230
실제로이 데이터 구조가있다.

1030
00:46:00,230 --> 00:46:02,040
>> 그래서 우리는 다음과 같이이 작업을 수행 할 수 있습니다.

1031
00:46:02,040 --> 00:46:06,810
우리가 그림에서 각 노드
톱 하나, 크기 27의 배열을 가지고 있습니다.

1032
00:46:06,810 --> 00:46:10,550
P에 여섯 설정 때문에 그것은 지금 27의
우리가 실제로 당신에게 아포스트로피를 줄 것이다

1033
00:46:10,550 --> 00:46:13,590
그래서 우리는 오라일리 같은 이름을 가질 수 있습니다
아포스트로피 및 다른 사람.

1034
00:46:13,590 --> 00:46:14,820
그러나 같은 생각.

1035
00:46:14,820 --> 00:46:17,710
에서 이러한 요소 각각의
구조체 배열을 포인트

1036
00:46:17,710 --> 00:46:19,320
노드, 그래서 그냥 노드입니다.

1037
00:46:19,320 --> 00:46:21,430
그래서 이것은 매우 연상
우리의 링크 목록.

1038
00:46:21,430 --> 00:46:24,550
>> 그리고, 나는 부울을 가지고있는 나는거야
단어를 호출하는 단지가 될 것입니다

1039
00:46:24,550 --> 00:46:29,120
단어이 종료 true의 경우
트리 노드입니다.

1040
00:46:29,120 --> 00:46:32,870
그것은 효과적으로 약간을 나타냅니다
삼각형 우리는 잠시 전에 보았다.

1041
00:46:32,870 --> 00:46:37,190
단어의 해당 노드에서 종료 그렇다면
나무, 그 단어 필드는 true가됩니다

1042
00:46:37,190 --> 00:46:41,990
이는 개념적으로 해제 확인되거나,
우리는 예가,이 삼각형을 그리는거야

1043
00:46:41,990 --> 00:46:44,080
여기에 단어입니다.

1044
00:46:44,080 --> 00:46:45,120
>> 그래서 이것은 트라이이다.

1045
00:46:45,120 --> 00:46:48,540
이제 질문은, 무엇
그 시간을 실행?

1046
00:46:48,540 --> 00:46:49,930
그것은 N의 큰 O인가?

1047
00:46:49,930 --> 00:46:51,410
다른 것입니까?

1048
00:46:51,410 --> 00:46:57,330
글쎄, 당신은이 데이터에 이름을 n을 한 경우
구조, 맥스웰의 하나 인

1049
00:46:57,330 --> 00:47:02,330
그들의 실행 시간 것입니다
삽입 또는 맥스웰를 찾는?

1050
00:47:02,330 --> 00:47:06,230

1051
00:47:06,230 --> 00:47:09,050
실행 시간은 무엇입니까
맥스웰 삽입?

1052
00:47:09,050 --> 00:47:11,740
N 다른 이름이있는 경우
이미 테이블에있는?

1053
00:47:11,740 --> 00:47:12,507
그래?

1054
00:47:12,507 --> 00:47:15,429
>> 학생 : [들림].

1055
00:47:15,429 --> 00:47:17,550
>> 스피커 1 : 그래, 길이의
이름, 오른쪽?

1056
00:47:17,550 --> 00:47:24,420
M--X-W-E-L-L 있도록이 같은 느낌 그래서
알고리즘은 일곱 큰 O입니다.

1057
00:47:24,420 --> 00:47:26,580
지금은 물론, 이름
길이가 달라집니다.

1058
00:47:26,580 --> 00:47:27,380
아마 짧은 이름입니다.

1059
00:47:27,380 --> 00:47:28,600
아마 긴 이름이다.

1060
00:47:28,600 --> 00:47:33,390
그러나 여기에서 중요한 것은이다
그것은 상수이다.

1061
00:47:33,390 --> 00:47:36,810
그리고 어쩌면 그것이 정말 일정하지의
하나님 현실적으로 경우에

1062
00:47:36,810 --> 00:47:41,570
사전에 몇 가지 제한이 거기에 아마
에있는 문자의 수

1063
00:47:41,570 --> 00:47:43,820
특정 국가에있는 사람의 이름을 입력합니다.

1064
00:47:43,820 --> 00:47:46,940
>> 그래서 우리는 가정 할 수
값은 상수입니다.

1065
00:47:46,940 --> 00:47:47,750
나는 그것이 무엇인지 모르겠어요.

1066
00:47:47,750 --> 00:47:50,440
그것은 아마보다 큰
우리는 생각합니다.

1067
00:47:50,440 --> 00:47:52,720
일부 코너는 항상 거기 때문에
미친 긴 이름을 가진 케이스.

1068
00:47:52,720 --> 00:47:56,360
그럼이 K 호출하게,하지만 여전히의
상수 아마도 모든 때문에

1069
00:47:56,360 --> 00:48:00,190
이상에서 세계에 이름을
특정 국가, 그 길이 또는이다

1070
00:48:00,190 --> 00:48:01,780
짧은, 그래서 상수이다.

1071
00:48:01,780 --> 00:48:04,490
그러나 우리는 말했다했을 때 뭔가 큰
상수 값의 O, 무엇을하는

1072
00:48:04,490 --> 00:48:07,760
에 정말 상응하는?

1073
00:48:07,760 --> 00:48:10,420
그건 정말 같은 것
일정한 시간을 말하는 등.

1074
00:48:10,420 --> 00:48:11,530
>> 지금 우리는 부정 행위의 종류 맞아요?

1075
00:48:11,530 --> 00:48:15,340
우리는 몇 가지 이론을 활용하는 종류입니다
여기에 잘, K의 순서가 있다고합니다

1076
00:48:15,340 --> 00:48:17,450
정말 그냥 하나의 주문
그리고 일정 시간입니다.

1077
00:48:17,450 --> 00:48:18,200
하지만 정말이다.

1078
00:48:18,200 --> 00:48:22,550
여기서 중요한 통찰력이기 때문
우리는이 이미 이름을 n을 한 경우

1079
00:48:22,550 --> 00:48:26,010
데이터 구조, 우리 삽입 맥스웰,
그것은 우리를 걸리는 시간의 양을

1080
00:48:26,010 --> 00:48:29,530
영향을받는 모든에서 맥스웰를 삽입
얼마나 많은 다른 사람들

1081
00:48:29,530 --> 00:48:31,100
데이터 구조에?

1082
00:48:31,100 --> 00:48:31,670
될 것 같지 않습니다.

1083
00:48:31,670 --> 00:48:36,280
나는 이것에 억 이상의 요소를 가지고 있다면
다음 트라이하고, 맥스웰되어 삽입

1084
00:48:36,280 --> 00:48:38,650
그는 전혀 영향?

1085
00:48:38,650 --> 00:48:39,050
아니오.

1086
00:48:39,050 --> 00:48:42,950
그리고 그 날 데이터의 달리의
우리는 여기서 지금까지 본 적이 구조

1087
00:48:42,950 --> 00:48:46,820
귀하의 알고리즘의 실행 시간은
얼마나 완전히 독립적으로

1088
00:48:46,820 --> 00:48:51,430
물건은 나 있지 않은
해당 데이터 구조에있다.

1089
00:48:51,430 --> 00:48:54,650
>> 이 가르치시로 그리고 당신은 지금이다
P 세트 여섯, 기회있는 것

1090
00:48:54,650 --> 00:48:58,310
다시 자신의 구현을 포함
15에 읽기 맞춤법 검사기,

1091
00:48:58,310 --> 00:49:01,050
즉, 최선의 방법이를 저장
반드시 명확하지 않다.

1092
00:49:01,050 --> 00:49:04,030
내가 찾을 열망했다지만
성배, 나는하지

1093
00:49:04,030 --> 00:49:05,330
트라이는 주장한다.

1094
00:49:05,330 --> 00:49:09,810
사실, 해시 테이블은 아주 잘 할 수있다
훨씬 더 효율적인 것으로 증명한다.

1095
00:49:09,810 --> 00:49:10,830
하지만 그 단지입니다 -

1096
00:49:10,830 --> 00:49:14,620
그것은 단지 디자인 결정 중 하나
당신은 확인해야합니다.

1097
00:49:14,620 --> 00:49:18,920
>> 그러나 닫는의가 보자 50 정도
초 무슨 일이 있을지에 들여다 봐도

1098
00:49:18,920 --> 00:49:22,190
앞서 다음 주 우리 전환 이후
이 명령 줄에서

1099
00:49:22,190 --> 00:49:26,220
것들을 웹에 세계의 C 프로그램 경우
기반 PHP 같은 언어와

1100
00:49:26,220 --> 00:49:30,350
자바 스크립트와 인터넷 자체
당신은했습니다 HTTP 같은 프로토콜,

1101
00:49:30,350 --> 00:49:32,870
년 동안 당연한
모든 지금 가장하고, 입력

1102
00:49:32,870 --> 00:49:34,440
하루는, 아마도, 또는 본.

1103
00:49:34,440 --> 00:49:37,420
그리고 우리는 다시 껍질을 시작합니다
어떤 레이어는 인터넷이다.

1104
00:49:37,420 --> 00:49:40,650
그리고 코드는 무엇입니다
기초는 오늘날의 도구를 제공합니다.

1105
00:49:40,650 --> 00:49:43,230
여기 맛보기 너무 50초.

1106
00:49:43,230 --> 00:49:46,570
나는 당신에게 그물의 전사를 제공합니다.

1107
00:49:46,570 --> 00:49:51,370
>> [동영상 재생]

1108
00:49:51,370 --> 00:49:56,764
>> - 그는 메시지와 함께.

1109
00:49:56,764 --> 00:50:00,687
프로토콜을 모두 자신과 함께.

1110
00:50:00,687 --> 00:50:13,370

1111
00:50:13,370 --> 00:50:19,780
그는 잔인한 방화벽의 세계에 온
무관 심한 라우터 및 위험까지

1112
00:50:19,780 --> 00:50:22,600
죽음보다 더.

1113
00:50:22,600 --> 00:50:23,590
그는 빠르다.

1114
00:50:23,590 --> 00:50:25,300
그는 강한.

1115
00:50:25,300 --> 00:50:27,700
그는 TCPIP입니다.

1116
00:50:27,700 --> 00:50:30,420
그는 당신의 주소를 가지고있다.

1117
00:50:30,420 --> 00:50:32,920

1118
00:50:32,920 --> 00:50:34,590
넷의 전사.

1119
00:50:34,590 --> 00:50:35,290
>> [END 동영상 재생]

1120
00:50:35,290 --> 00:50:38,070
>> 스피커 1 : 그것은 얼마나 인터넷
다음주로 작동된다.

1121
00:50:38,070 --> 00:50:40,406