1
00:00:00,000 --> 00:00:12,350
>> [음악 연주]

2
00:00:12,350 --> 00:00:13,050
>> ROB 보덴 : 안녕하세요.

3
00:00:13,050 --> 00:00:13,640
롭 해요.

4
00:00:13,640 --> 00:00:16,210
그리고의 이번 솔루션을 보자.

5
00:00:16,210 --> 00:00:20,070
그래서 여기에 우리가 구현하는거야
일반 테이블.

6
00:00:20,070 --> 00:00:24,090
우리는 볼이 우리의 구조체 노드
표는 다음과 같이 할 것입니다.

7
00:00:24,090 --> 00:00:28,710
따라서 문자의 단어를 가지고거야
크기 길이 + 1의 배열입니다.

8
00:00:28,710 --> 00:00:32,259
, + 1을 잊지 마세요 이후 최대
사전에있는 단어는 45입니다

9
00:00:32,259 --> 00:00:33,130
문자.

10
00:00:33,130 --> 00:00:37,070
그리고, 우리는 하나가 추가 필요 해요
백 슬래시 제로 캐릭터.

11
00:00:37,070 --> 00:00:40,870
>> 그리고 각 우리의 해시 테이블
버킷 저장하는 것입니다

12
00:00:40,870 --> 00:00:42,320
노드의 연결리스트.

13
00:00:42,320 --> 00:00:44,420
우리는 여기에서 프로빙 선형을하고 있지 않습니다.

14
00:00:44,420 --> 00:00:48,430
그리고 순서에 따라 다음에 링크를
버킷에있는 요소는, 우리는 필요

15
00:00:48,430 --> 00:00:50,390
구조체 노드 * 다음.

16
00:00:50,390 --> 00:00:51,110
OK.

17
00:00:51,110 --> 00:00:53,090
그래서 노드가 어떻게 생겼는지입니다.

18
00:00:53,090 --> 00:00:56,180
>> 지금 여기 선언은
우리의 해시 테이블.

19
00:00:56,180 --> 00:00:59,640
그것은 16,834 버킷을 가질 것입니다.

20
00:00:59,640 --> 00:01:01,910
그러나 그 수는 그리 중요하지 않습니다.

21
00:01:01,910 --> 00:01:05,450
그리고 마지막으로, 우리는해야 할 것입니다
글로벌 변수 해시 테이블의 크기, 어떤

22
00:01:05,450 --> 00:01:07,000
0으로 시작하는 것입니다.

23
00:01:07,000 --> 00:01:10,760
그리고 그것은 어떻게 추적 할거야
많은 단어는 우리 사전에 있습니다.

24
00:01:10,760 --> 00:01:13,710
>> 그럼 부하에 대해 살펴 보겠습니다.

25
00:01:13,710 --> 00:01:16,390
그 부하를 주목, 그것은 부울을 반환합니다.

26
00:01:16,390 --> 00:01:20,530
성공적이었다 경우 true를 반환
로드, 그렇지 않은 경우는 false.

27
00:01:20,530 --> 00:01:23,990
그리고, const를 char *로 사전 소요
사전입니다

28
00:01:23,990 --> 00:01:25,280
우리는 열려있다.

29
00:01:25,280 --> 00:01:27,170
그래서 첫 번째 일이
우리가 할 것입니다.

30
00:01:27,170 --> 00:01:29,500
>> 우리는은 fopen거야
독서를위한 사전.

31
00:01:29,500 --> 00:01:31,680
그리고 우리는해야 돼
그것이 성공했는지 확인하십시오.

32
00:01:31,680 --> 00:01:35,920
그것은 NULL을 반환 그렇다면, 우리는하지 않았다
성공적으로 사전을 엽니 다.

33
00:01:35,920 --> 00:01:37,440
그리고 우리는 false를 반환해야합니다.

34
00:01:37,440 --> 00:01:41,580
그러나 성공적으로 한 가정
열려있는, 우리가 읽고 싶은

35
00:01:41,580 --> 00:01:42,400
사전.

36
00:01:42,400 --> 00:01:46,450
우리는 몇 가지를 찾을 때까지 이렇게 반복 계속
이 루프의 탈옥 이유,

37
00:01:46,450 --> 00:01:47,570
우리는 볼 수있다.

38
00:01:47,570 --> 00:01:48,920
그래서 계속 루핑.

39
00:01:48,920 --> 00:01:51,780
>> 그리고 지금 우리에가는거야
단일 노드를 MALLOC.

40
00:01:51,780 --> 00:01:54,020
그리고 물론 우리는 필요
공기하려면 다시 확인.

41
00:01:54,020 --> 00:01:58,680
그래서 mallocing 성공하지 않은 경우, 다음
우리는 우리의 모든 노드를 언로드 할

42
00:01:58,680 --> 00:02:02,590
이전의 malloc에​​ 일어난 닫습니다
사전 및 false를 반환합니다.

43
00:02:02,590 --> 00:02:06,830
그러나 무시, 가정 우리
성공, 우리는 fscanf 사용하려면

44
00:02:06,830 --> 00:02:12,400
에서 하나의 단어를 읽을 수있는 우리의
우리의 노드에 사전.

45
00:02:12,400 --> 00:02:17,940
그래서 입력> 단어를 기억 문자입니다
+ 1 크기 LENGHTH의 단어 버퍼

46
00:02:17,940 --> 00:02:20,300
우리는 안으로 단어를 저장하는 거라고

47
00:02:20,300 --> 00:02:25,070
>> 그래서 fscanf는 한, 1을 반환 할 것입니다
그것은 수 성공적이었다로

48
00:02:25,070 --> 00:02:26,750
파일에서 단어를 읽을.

49
00:02:26,750 --> 00:02:30,460
오류 중 하나가 발생하면, 우리
파일의 끝에 도달, 그것을

50
00:02:30,460 --> 00:02:31,950
1을 반환하지 않습니다.

51
00:02:31,950 --> 00:02:35,180
그것은 1을 반환하지 않는 경우
우리는 마침내 탈옥거야

52
00:02:35,180 --> 00:02:37,280
이 while 루프.

53
00:02:37,280 --> 00:02:42,770
그래서 우리는 볼 우리는 성공적이되면
에 단어를 읽을

54
00:02:42,770 --> 00:02:48,270
항목> 단어, 우리는 갈거야
우리의 해시 함수를 사용하여 단어.

55
00:02:48,270 --> 00:02:49,580
>> 이제 살펴 보자
해시 함수.

56
00:02:49,580 --> 00:02:52,430

57
00:02:52,430 --> 00:02:55,610
그래서 당신이 정말로 필요로하지 않는다
이 문제를 이해하기.

58
00:02:55,610 --> 00:02:59,460
그리고 실제로 우리는 단지이 해시를 뽑아
인터넷에서 작동합니다.

59
00:02:59,460 --> 00:03:04,010
당신이 인식해야 할 유일한 일이다
이 const를 char *로 단어를 걸립니다.

60
00:03:04,010 --> 00:03:08,960
그래서 문자열을 입력 복용하고 있어요
출력으로 서명 int를 반환.

61
00:03:08,960 --> 00:03:12,360
그래서 그 모든 해시 함수입니다, 그것은이다
입력에 소요하고 당신에게를 제공합니다

62
00:03:12,360 --> 00:03:14,490
해시 테이블에 인덱스.

63
00:03:14,490 --> 00:03:18,530
>> 우리가 NUM_BUCKETS으로 moding 있다는 것을 주목
그래서 값이 반환

64
00:03:18,530 --> 00:03:21,730
실제로 해시 테이블에 대한 인덱스는
그리고 않는 이상하지 인덱스

65
00:03:21,730 --> 00:03:24,320
어레이의 경계.

66
00:03:24,320 --> 00:03:28,060
그래서 기능, 우리는거야 주어진
우리가 읽고 단어를 해시

67
00:03:28,060 --> 00:03:29,390
사전.

68
00:03:29,390 --> 00:03:31,700
그리고 우리가 사용하는거야
삽입하는 해시

69
00:03:31,700 --> 00:03:33,750
해시 테이블에 항목.

70
00:03:33,750 --> 00:03:38,520
>> 이제 해시 테이블 해시 전류
표에 목록을 연결했다.

71
00:03:38,520 --> 00:03:41,410
그리고 그것은 매우 가능
그냥 NULL 있다고.

72
00:03:41,410 --> 00:03:44,960
우리는에서 우리의 항목을 삽입 할
이 연결리스트의 시작.

73
00:03:44,960 --> 00:03:48,600
그래서 우리는 우리의 현재를해야 할 것입니다
무엇 해시 테이블에 엔트리 포인트

74
00:03:48,600 --> 00:03:50,380
현재를 가리 킵니다.

75
00:03:50,380 --> 00:03:53,310
그리고 우리는, 저장하는거야
의 해시 테이블에있는

76
00:03:53,310 --> 00:03:55,350
해시, 현재 항목.

77
00:03:55,350 --> 00:03:59,320
그래서이 두 줄이 성공적으로 삽입
의 시작 부분에 항목

78
00:03:59,320 --> 00:04:02,260
그 인덱스에 연결된 목록
해시 테이블.

79
00:04:02,260 --> 00:04:04,900
>> 우리가 그와 함께 완료되면, 우리는 알고있다
우리는 다른 단어를 발견

80
00:04:04,900 --> 00:04:07,790
사전에, 우리는 다시 증가.

81
00:04:07,790 --> 00:04:13,960
그래서 우리는 일을 계속하는 fscanf까지
마지막에 비 1 뭔가를 반환

82
00:04:13,960 --> 00:04:16,950
어떤 순간 그 기억
우리는 항목을 해제해야합니다.

83
00:04:16,950 --> 00:04:19,459
그래서 여기까지 우리는 항목을 malloc으로 할당.

84
00:04:19,459 --> 00:04:21,329
그리고 우리는 무언가를 읽으려고
사전에서.

85
00:04:21,329 --> 00:04:23,910
그리고 우리는 성공적으로 읽지 않았다
에서 사전에서 무엇인가,

86
00:04:23,910 --> 00:04:26,650
우리는 항목을 해제해야하는 경우
우리는 실제로 투입 결코

87
00:04:26,650 --> 00:04:29,140
해시 테이블, 그리고 마지막으로 휴식.

88
00:04:29,140 --> 00:04:32,750
>> 우리가 파괴되면 우리가 볼 필요가, 잘,
때문에 우리는이 탈옥 않았다

89
00:04:32,750 --> 00:04:34,360
오류가 파일에서 읽고 있었다?

90
00:04:34,360 --> 00:04:37,120
아니면 우리가 탈옥 하니까
파일의 끝에 도달?

91
00:04:37,120 --> 00:04:39,480
오류는 다음이 있다면
우리는 false를 반환합니다.

92
00:04:39,480 --> 00:04:40,930
로드가 성공하지 않았기 때문입니다.

93
00:04:40,930 --> 00:04:43,890
그 과정에서 우리는 언로드 할
모두 우리가 읽고 단어 및

94
00:04:43,890 --> 00:04:45,670
사전 파일을 닫습니다.

95
00:04:45,670 --> 00:04:48,740
>> 우리가 성공 않은 가정, 우리 단지
여전히 사전을 닫을 필요

96
00:04:48,740 --> 00:04:53,040
파일, 그리고 마지막으로 true를 반환 이후 우리
성공적으로 사전 적재했다.

97
00:04:53,040 --> 00:04:54,420
그리고 그 부하 그거야.

98
00:04:54,420 --> 00:04:59,020
그래서 지금,로드 해시 테이블에 주어진 확인
다음과 같이 할 것입니다.

99
00:04:59,020 --> 00:05:03,140
따라서, 이는이 부울을 반환 확인
통과했는지 여부를 표시하는 것

100
00:05:03,140 --> 00:05:07,530
char *로 단어, 여부 전달
문자열에 우리의 사전에 있습니다.

101
00:05:07,530 --> 00:05:09,890
그것은 사전에있는 경우에 따라서
우리의 해시 테이블에있는 경우,

102
00:05:09,890 --> 00:05:11,170
우리는 true를 돌려줍니다.

103
00:05:11,170 --> 00:05:13,380
그렇지 않은 경우에, 우리는 거짓을 반환합니다.

104
00:05:13,380 --> 00:05:17,740
>> 이 단어에 전달 감안할 때, 우린
단어를 해시하는 것.

105
00:05:17,740 --> 00:05:22,110
이제 인식 중요한 것은
부하에 우리가 알고있는 것을 그 모든

106
00:05:22,110 --> 00:05:23,820
우리가 낮은 경우가 될 것입니다 단어.

107
00:05:23,820 --> 00:05:25,820
그러나 여기에서 우리는 그렇게 확실하지 않다.

108
00:05:25,820 --> 00:05:29,510
우리는 우리의 해시 함수를 살펴 경우,
실제로 우리 해시 함수

109
00:05:29,510 --> 00:05:32,700
하부 케이싱은 각 캐릭터
단어의.

110
00:05:32,700 --> 00:05:37,940
그래서 관계없이 총액
단어, 우리의 해시 함수는 반환합니다

111
00:05:37,940 --> 00:05:42,270
무엇에 대해 동일한 인덱스
대문자는 것 등이다

112
00:05:42,270 --> 00:05:45,280
완전히 소문자에 대해 반환
단어의 버전.

113
00:05:45,280 --> 00:05:46,600
좋아.

114
00:05:46,600 --> 00:05:49,790
즉, 우리의 인덱스로이다의
이 단어를 해시 테이블.

115
00:05:49,790 --> 00:05:52,940
>> 이제 루프이 예정
연결리스트를 반복

116
00:05:52,940 --> 00:05:55,000
즉, 해당 인덱스에 있었다.

117
00:05:55,000 --> 00:05:59,610
그래서 우리는 항목을 초기화하는 통지
해당 인덱스를 가리 키도록.

118
00:05:59,610 --> 00:06:02,750
우리는 계속할 예정
항목! = NULL있다.

119
00:06:02,750 --> 00:06:07,770
그리고 기억하는 포인터를 업데이트
다음에 우리의 링크리스트의 항목 항목을 =>.

120
00:06:07,770 --> 00:06:14,400
그래서 현재의 엔트리 포인트가
링크 된 목록에서 다음 항목을 선택합니다.

121
00:06:14,400 --> 00:06:19,250
>> 따라서 링크 된 목록의 각 항목에 대한,
우리는 strcasecmp를 사용하는 것입니다.

122
00:06:19,250 --> 00:06:20,330
그것은에서는 StrComp 아니다.

123
00:06:20,330 --> 00:06:23,780
다시 한 번, 우리가 원하기 때문에
소문자를 구별 가지 사례를 않습니다.

124
00:06:23,780 --> 00:06:27,870
그래서 우리는 비교 strcasecmp를 사용하는
이 통과 된 단어

125
00:06:27,870 --> 00:06:31,860
단어에 대한 기능
즉,이 항목에 있습니다.

126
00:06:31,860 --> 00:06:35,570
그것은 0을 반환하면 해당이있었습니다 의미
우리가 할 경우 경기 일정,

127
00:06:35,570 --> 00:06:36,630
true를 반환합니다.

128
00:06:36,630 --> 00:06:39,590
우리는 성공적으로 발견
우리의 해시 테이블에있는 단어입니다.

129
00:06:39,590 --> 00:06:43,040
>> 일치가 아니었다면, 우리는거야
다시 루프에 가서 봐

130
00:06:43,040 --> 00:06:43,990
다음 항목.

131
00:06:43,990 --> 00:06:47,640
그리고 우리는 거기있는 동안 루프를 계속합니다
이 연결 목록에있는 항목입니다.

132
00:06:47,640 --> 00:06:50,160
우리가 중단하면 어떻게됩니까
루프이 중?

133
00:06:50,160 --> 00:06:55,110
즉, 우리는 항목을 찾을 수 없습니다 의미
이 경우,이 단어를 일치

134
00:06:55,110 --> 00:07:00,220
우리는 표시 할 false를 반환 우리의
해시 테이블은이 단어를 포함하지 않았다.

135
00:07:00,220 --> 00:07:02,540
그리고 그 수표입니다.

136
00:07:02,540 --> 00:07:04,790
>> 그래서 크기에 대해 살펴 보겠습니다.

137
00:07:04,790 --> 00:07:06,970
현재 크기는 매우 간단 될 것입니다.

138
00:07:06,970 --> 00:07:11,080
이후 각 단어에 대해, 부하 기억
우리는 우리가 글로벌을 증가 발견

139
00:07:11,080 --> 00:07:12,880
변수 해시 테이블의 크기입니다.

140
00:07:12,880 --> 00:07:16,480
그래서 크기 기능은 것입니다
전역 변수를 반환합니다.

141
00:07:16,480 --> 00:07:18,150
그리고 바로 그거야.

142
00:07:18,150 --> 00:07:22,300
>> 이제 마지막으로, 우리는 언로드 할 필요가
사전에 모든 것을 끝낼 번.

143
00:07:22,300 --> 00:07:25,340
그래서 우리가 어떻게 그렇게 할거야?

144
00:07:25,340 --> 00:07:30,440
바로 여기에 우리는 이상 반복하고
우리 테이블의 모든 버킷.

145
00:07:30,440 --> 00:07:33,240
그래서 NUM_BUCKETS 버킷이 있습니다.

146
00:07:33,240 --> 00:07:37,410
그리고 각 연결리스트에 대한 우리의
해시 테이블, 우리는 반복 할거야

147
00:07:37,410 --> 00:07:41,070
연결리스트의 전체,
각 요소를 자유롭게.

148
00:07:41,070 --> 00:07:42,900
>> 이제 우리는주의해야합니다.

149
00:07:42,900 --> 00:07:47,910
그래서 여기에 우리는 임시 변수가
그 다음에 포인터를 저장하는 것

150
00:07:47,910 --> 00:07:49,730
링크 된 목록의 요소입니다.

151
00:07:49,730 --> 00:07:52,140
그리고 우리는 자유에가는거야
현재 요소.

152
00:07:52,140 --> 00:07:55,990
우리는 우리가 우리 때문에이 작업을 수행해야 할 필요가
다만 현재 요소에게 무료로 할 수

153
00:07:55,990 --> 00:07:59,180
다음 다음 포인터에 액세스하려고,
한 번 있기 때문에 우리는 그것을 해제했습니다,

154
00:07:59,180 --> 00:08:00,870
메모리는 무효가됩니다.

155
00:08:00,870 --> 00:08:04,990
>> 그래서 우리는 포인터를 주위에 유지해야
다음 요소는, 우리가 확보 할 수 있습니다

156
00:08:04,990 --> 00:08:08,360
현재 요소, 그리고, 우리는 업데이트 할 수 있습니다
를 가리 키도록 현재의 요소

157
00:08:08,360 --> 00:08:09,550
다음 요소.

158
00:08:09,550 --> 00:08:12,800
우리는 요소는 루프가 있습니다 동안
이 연결리스트에서.

159
00:08:12,800 --> 00:08:15,620
우리는 모든 연결을 위해 그렇게 할 것이다
해시 테이블에있는 목록.

160
00:08:15,620 --> 00:08:19,460
우리가 그와 함께 완료되면, 우리는했습니다
완전히 해시 테이블을 언로드하고,

161
00:08:19,460 --> 00:08:20,190
우리는 끝났어.

162
00:08:20,190 --> 00:08:23,200
그래서 언로드 불가능
이제까지 false를 반환합니다.

163
00:08:23,200 --> 00:08:26,470
그리고 우리가 끝나면, 우리
진실이 돌아갑니다.

164
00:08:26,470 --> 00:08:29,000
>> 의이 솔루션 시도해 보자.

165
00:08:29,000 --> 00:08:33,070
그럼 어떻게 우리를 살펴 보자
구조체의 노드가 같이 표시됩니다.

166
00:08:33,070 --> 00:08:36,220
여기에서 우리는 우리가 부울을해야 할 것입니다 참조
단어와 구조체 노드 * 어린이

167
00:08:36,220 --> 00:08:37,470
브래킷의 알파벳입니다.

168
00:08:37,470 --> 00:08:38,929

169
00:08:38,929 --> 00:08:42,020
당신이있을 수 있습니다 그래서 우선
궁금, 왜 알파벳입니다

170
00:08:42,020 --> 00:08:44,660
ED (27)로 정의?

171
00:08:44,660 --> 00:08:47,900
글쎄, 우리가 필요 해요 기억
아포스트로피를 처리합니다.

172
00:08:47,900 --> 00:08:51,910
그래서 어느 정도 될 것
이 프로그램 전반에 걸쳐 특별한 경우.

173
00:08:51,910 --> 00:08:54,710
>> 지금 기억하는 방법 트라이
실제로 작동합니다.

174
00:08:54,710 --> 00:08:59,380
의 우리가 단어를 색인하고 있다고 가정 해 봅시다
"고양이." 그런 다음 트라이의 루트에서,

175
00:08:59,380 --> 00:09:02,610
우리는 아이들을 보는거야
배열, 우리는 보는거야

176
00:09:02,610 --> 00:09:08,090
문자에 해당하는 인덱스
2 색인화 할 C. 그래서.

177
00:09:08,090 --> 00:09:11,530
그래서 주어진, 그 의지
우리에게 새 노드를 제공합니다.

178
00:09:11,530 --> 00:09:13,820
그리고 우리는 그 노드에서 작동합니다.

179
00:09:13,820 --> 00:09:17,770
>> 그래서 노드 주어, 우리는 다시 한 번이야
아이들의 배열을 볼 줄.

180
00:09:17,770 --> 00:09:22,110
그리고 우리는 인덱스 0에 보는거야
고양이에 해당합니다.

181
00:09:22,110 --> 00:09:27,170
그래서 우리는 그 노드에 가서,
해당 노드 주어진 우리는거야

182
00:09:27,170 --> 00:09:31,090
최종보고는 대응의
T. 그리고 그 노드로 이동,에

183
00:09:31,090 --> 00:09:35,530
마지막으로, 우리는 완전히 보았다
을 통해 우리의 단어 "고양이." 그리고 지금을 bool

184
00:09:35,530 --> 00:09:40,960
단어 여부를 표시하도록되어
이 주어진 단어는 실제로 단어입니다.

185
00:09:40,960 --> 00:09:43,470
>> 그럼 왜 우리는 특별한 경우를 필요합니까?

186
00:09:43,470 --> 00:09:47,700
그럼 어떤 단어의 "재앙"
우리 사전에 있지만

187
00:09:47,700 --> 00:09:50,150
단어 "고양이"아닌가요?

188
00:09:50,150 --> 00:09:54,580
그래서와보고 찾고 경우 단어 "고양이"
우리의 사전에, 우리는 야한다

189
00:09:54,580 --> 00:09:59,970
성공적으로 통해 볼 것
지역 노드의 인덱스는 C-A-T.

190
00:09:59,970 --> 00:10:04,290
하지만 그건 단지 때문에 재앙
길에 노드를 만들 수 있었

191
00:10:04,290 --> 00:10:07,190
C-A-T에서 모든 방법을
단어의 끝.

192
00:10:07,190 --> 00:10:12,020
그래서 BOOL 단어 여부를 나타내는 데 사용된다
이 특정 위치

193
00:10:12,020 --> 00:10:14,310
실제로 단어를 나타냅니다.

194
00:10:14,310 --> 00:10:15,140
>> 괜찮아요.

195
00:10:15,140 --> 00:10:19,310
그래서 지금 우리가 트라이가 무엇인지 알고
처럼 보이게하는 것,의를 살펴 보자

196
00:10:19,310 --> 00:10:20,730
기능을로드합니다.

197
00:10:20,730 --> 00:10:24,610
그래서 부하는 부울을 반환하는 것입니다
여부를 우리가 성공적으로 나에 대한

198
00:10:24,610 --> 00:10:26,720
실패 사전 적재했다.

199
00:10:26,720 --> 00:10:30,460
그리고 이것은 사전이 될 것입니다
우리는로드 할 것을.

200
00:10:30,460 --> 00:10:33,930
>> 우리가 할 수있는 좋은 방법입니다 그래서 일단 열려
독서하는 사전입니다.

201
00:10:33,930 --> 00:10:36,160
그리고 우리는 확인해야
우리는 실패하지 않았다.

202
00:10:36,160 --> 00:10:39,580
사전은 아니었다 그렇다면
성공적으로 열려, 그것은 반환

203
00:10:39,580 --> 00:10:42,400
널 (null),이 경우 우리는 야
false를 반환하는 것.

204
00:10:42,400 --> 00:10:47,230
그러나 가정 그것이 성공적으로
열, 우리는 실제로 읽을 수 있습니다

205
00:10:47,230 --> 00:10:48,220
사전을 통해.

206
00:10:48,220 --> 00:10:50,880
>> 우리가 갈거야 그래서 일단
하고 싶은 우리는이 가지고있다

207
00:10:50,880 --> 00:10:52,500
전역 변수 루트.

208
00:10:52,500 --> 00:10:56,190
이제 루트 * 노드가 될 것입니다.

209
00:10:56,190 --> 00:10:59,760
그것은 우리가있어 우리의 트라이의 정상의
반복 할 것.

210
00:10:59,760 --> 00:11:02,660
우리는거야 그래서 우선
하고 싶어하는 할당입니다

211
00:11:02,660 --> 00:11:04,140
우리의 뿌리에 대한 기억.

212
00:11:04,140 --> 00:11:07,980
우리는 buf는을 사용하는 것을 알 수
기본적으로 동일 기능,

213
00:11:07,980 --> 00:11:11,500
의 malloc 함수를 제외하고는의
무언가를 반환 보장

214
00:11:11,500 --> 00:11:13,180
완전히 제로.

215
00:11:13,180 --> 00:11:17,290
우리의 malloc을 사용하는 경우에, 우리는해야합니다
의 모든 포인터를 이동 우리

216
00:11:17,290 --> 00:11:20,160
노드 및 있는지 확인
그들은 모두 널 (null)입니다.

217
00:11:20,160 --> 00:11:22,710
그래서 buf는 우리를 위해 그렇게 할 것이다.

218
00:11:22,710 --> 00:11:26,330
>> 지금 만의 malloc처럼, 우리가해야 할
할당이 사실은 확인

219
00:11:26,330 --> 00:11:27,520
성공.

220
00:11:27,520 --> 00:11:29,990
이 null을 반환하는 경우에, 우리
닫거나 사전 필요

221
00:11:29,990 --> 00:11:32,100
파일 및 false를 반환합니다.

222
00:11:32,100 --> 00:11:36,835
그래서 할당 된 가정
성공, 우리는 * 노드를 사용하는 것입니다

223
00:11:36,835 --> 00:11:40,270
우리의 트라이를 반복하는 커서.

224
00:11:40,270 --> 00:11:43,890
그래서 우리의 뿌리를 변경하려고하지 않습니다,
그러나 우리는 커서를 사용하는 것입니다

225
00:11:43,890 --> 00:11:47,875
실제로 노드에서 노드로 이동합니다.

226
00:11:47,875 --> 00:11:50,940
>> 그래서 이것 루프 우리가 읽고
사전 파일을 통해.

227
00:11:50,940 --> 00:11:53,670
그리고 우리는 fgetc를 사용하고 있습니다.

228
00:11:53,670 --> 00:11:56,290
는 fgetc는 하나를 잡아 것입니다
파일에서 문자.

229
00:11:56,290 --> 00:11:59,370
우리는 잡는 계속할 예정
자 우리가 도달하지 않는 동안

230
00:11:59,370 --> 00:12:01,570
파일의 끝.

231
00:12:01,570 --> 00:12:03,480
>> 우리가 처리해야하는 두 가지 경우가 있습니다.

232
00:12:03,480 --> 00:12:06,610
첫 번째, 만약 문자
새로운 라인이 아니었다.

233
00:12:06,610 --> 00:12:10,450
그래서 우리는 그 다음, 새 줄 있었는지
우리는 새로운 단어로 이동하려합니다.

234
00:12:10,450 --> 00:12:15,240
하지만, 그것이 새로운 라인이 아니었다 가정
여기에 우리가 알아 내야 할

235
00:12:15,240 --> 00:12:18,380
인덱스 우리는에 인덱스에가는거야
어린이 배열이

236
00:12:18,380 --> 00:12:19,810
우리는 전에 바라 보았다.

237
00:12:19,810 --> 00:12:23,880
>> 그래서, 내가 전에 말했듯이, 우리는 필요
특별한 경우 아포스트로피.

238
00:12:23,880 --> 00:12:26,220
우리가 삼진을 사용하는주의
여기 운영자.

239
00:12:26,220 --> 00:12:29,580
그래서 우리는 경우에,이 글을 읽을거야
우리가 읽은 문자가 있었다

240
00:12:29,580 --> 00:12:35,330
아포스트로피, 우리는 만들 것이다
인덱스 = "ALPHABET"-1, 어떤 것

241
00:12:35,330 --> 00:12:37,680
인덱스 26 수.

242
00:12:37,680 --> 00:12:41,130
>> 그렇지 않으면, 아포스트로피가 아니었다면,이
우리는 인덱스를 설정하는거야

243
00:12:41,130 --> 00:12:43,760
C에 해당 -.

244
00:12:43,760 --> 00:12:49,030
그래서 다시 이전 P-세트의 기억,
C -이 우리에게 줄 수 있겠나?

245
00:12:49,030 --> 00:12:53,410
C.의 알파벳 위치의 경우 지금
C는이 것, 편지입니다

246
00:12:53,410 --> 00:12:54,700
우리 지수 제로를 제공합니다.

247
00:12:54,700 --> 00:12:58,120
문자 B의 경우, 줄 것이다
그래서 우리 인덱스 1합니다.

248
00:12:58,120 --> 00:13:03,010
>> 그래서 이것은 우리에 대한 인덱스를 제공
우리가 원하는 것을 아이 배열입니다.

249
00:13:03,010 --> 00:13:08,890
지금이 지수는 현재 null의 경우
아이들은 그 의미 노드

250
00:13:08,890 --> 00:13:11,830
현재 존재하지 않는
그 길에서.

251
00:13:11,830 --> 00:13:15,160
그래서 우리는 할당해야
해당 경로에 대한 노드.

252
00:13:15,160 --> 00:13:16,550
즉, 우리가 여기서 무엇을 할 거 야입니다.

253
00:13:16,550 --> 00:13:20,690
>> 그래서 우리는 다시 calloc을 사용할 예정입니다
기능은, 우리가 할 필요가 없도록

254
00:13:20,690 --> 00:13:22,880
모든 포인터를 제로.

255
00:13:22,880 --> 00:13:27,240
그리고 우리는 다시 확인해야합니다
그 buf는 실패하지 않았다.

256
00:13:27,240 --> 00:13:30,700
buf는 실패 않은 경우에, 우리는 필요
모든 언로 닫으 우리

257
00:13:30,700 --> 00:13:32,820
사전 및 false를 반환합니다.

258
00:13:32,820 --> 00:13:40,050
그래서 그 다음, 실패하지 않았다고 가정
이것은 우리의 새로운 아이를 작성합니다.

259
00:13:40,050 --> 00:13:41,930
그리고 우리는 그 아이로 이동합니다.

260
00:13:41,930 --> 00:13:44,960
우리의 커서가 반복됩니다
그 아이에 이르기까지.

261
00:13:44,960 --> 00:13:49,330
>> 지금은 처음부터 null이 있다면,
다음 커서가 단지 반복 할 수

262
00:13:49,330 --> 00:13:52,590
실제로하지 않고 그 아이에 이르기까지
아무것도 할당하는 데.

263
00:13:52,590 --> 00:13:56,730
이것은 우리가 처음 일어난 경우입니다
단어 할당 "고양이." 과

264
00:13:56,730 --> 00:14:00,330
우리가 할당 갈 때 그 의미
"재앙,"우리는 만들 필요가 없습니다

265
00:14:00,330 --> 00:14:01,680
다시 C-A-T에 대한 노드.

266
00:14:01,680 --> 00:14:04,830
그들은 이미 존재합니다.

267
00:14:04,830 --> 00:14:06,080
>> 다른 사람이 무엇입니까?

268
00:14:06,080 --> 00:14:10,480
이 C 한 상태이다
C는 새로운 라인이었다 백 슬래시 N,.

269
00:14:10,480 --> 00:14:13,710
이것은 우리가 성공적으로해야 함을 의미
단어를 완료했습니다.

270
00:14:13,710 --> 00:14:16,860
지금 우리는 무엇을 하시겠습니까 때 우리
성공적으로 단어를 완성?

271
00:14:16,860 --> 00:14:21,100
우리는이 단어 필드를 사용하는 것입니다
우리의 구조체 노드의 내부.

272
00:14:21,100 --> 00:14:23,390
우리는 참으로이 부분을 설정합니다.

273
00:14:23,390 --> 00:14:27,150
그래서 나타냅니다이 노드
성공을 나타냅니다

274
00:14:27,150 --> 00:14:29,250
단어, 실제 단어.

275
00:14:29,250 --> 00:14:30,940
>> 이제 참으로 그 설정합니다.

276
00:14:30,940 --> 00:14:35,150
우리는 점에 우리의 커서를 재설정 할
다시 트라이의 시작.

277
00:14:35,150 --> 00:14:40,160
그리고 마지막으로, 우리의 사전을 증가
크기, 우리는 다른 일을 찾을 수 있기 때문이다.

278
00:14:40,160 --> 00:14:43,230
그래서 우리는 그 일을 계속하는 것입니다,
, 문자로 문자 독서

279
00:14:43,230 --> 00:14:49,150
우리의 트라이에 새 노드를 구성하고
사전에, 때까지 각 단어에 대한

280
00:14:49,150 --> 00:14:54,020
우리는 마침내 C에 도달! = EOF,하는
경우 우리는 파일의 탈옥.

281
00:14:54,020 --> 00:14:57,050
>> 지금 이가지 경우에 따라이 있습니다
우리는 EOF 칠 수도있다.

282
00:14:57,050 --> 00:15:00,980
오류가 발생했을 경우는 우선
파일 읽기.

283
00:15:00,980 --> 00:15:03,470
오류가 발생했습니다 그래서, 우리
일반적인 작업을 수행해야합니다.

284
00:15:03,470 --> 00:15:06,460
가까운 모든 것을 언로드
파일은 false를 반환합니다.

285
00:15:06,460 --> 00:15:09,810
오류가 없었습니다 가정하면
우리가 실제로의 끝을 명중 의미

286
00:15:09,810 --> 00:15:13,750
파일은,이 경우에, 우리는 이서
파일 및 true를 반환 이후 우리

287
00:15:13,750 --> 00:15:17,330
성공적으로로드 사전
우리의 트라이에.

288
00:15:17,330 --> 00:15:20,170
>> 그래서 지금의이 체크 아웃을 확인 할 수 있습니다.

289
00:15:20,170 --> 00:15:25,156
체크 기능을 보면, 우리는 참조
그 검사는 부울을 반환하는 것입니다.

290
00:15:25,156 --> 00:15:29,680
이 단어가 있다는 경우는 true를 반환
전달되는 우리의 트라이에 있습니다.

291
00:15:29,680 --> 00:15:32,110
그것은 그렇지 않으면 false를 반환합니다.

292
00:15:32,110 --> 00:15:36,050
어떻게 당신이 있는지 여부를 확인하는
이 말씀은 우리의 트라이에?

293
00:15:36,050 --> 00:15:40,190
>> 우리는 여기에서 보는 그 직전처럼,
우리는 반복하는 커서를 사용하는 것입니다

294
00:15:40,190 --> 00:15:41,970
우리의 트라이를 통해.

295
00:15:41,970 --> 00:15:46,600
지금 여기에 우리가 반복하는거야
우리의 전체 단어 이상.

296
00:15:46,600 --> 00:15:50,620
그래서, 우리는 지난 수있는 단어 반복
우리가 결정하는거야

297
00:15:50,620 --> 00:15:56,400
인덱스 어린이 배열에 그
단어 브래킷 I.에 해당 따라서이

298
00:15:56,400 --> 00:15:59,670
정확히처럼 보이는 것입니다
부하 여기서 경우 ​​단어 [I]

299
00:15:59,670 --> 00:16:03,310
아포스트로피는, 우리가 원하는됩니다
인덱스 "알파벳"사용하기 - 1.

300
00:16:03,310 --> 00:16:05,350
우리는 결정하기 때문이
우리가 저장가는 곳입니다

301
00:16:05,350 --> 00:16:07,100
아포스트로피.

302
00:16:07,100 --> 00:16:11,780
>> 그렇지 않으면 우리는 아래 두 단어를 사용하는 것입니다
브래킷 I. 그래서 그 단어를 기억할 수

303
00:16:11,780 --> 00:16:13,920
임의의 총액이있다.

304
00:16:13,920 --> 00:16:17,540
그래서 우리는 우리가다는 것을 확인하고 싶다
사물의 소문자 버전을 사용하여.

305
00:16:17,540 --> 00:16:21,920
그리고 그 'A'1 회에서 빼기
다시 우리에게 알파벳을 제공

306
00:16:21,920 --> 00:16:23,880
그 문자의 위치.

307
00:16:23,880 --> 00:16:27,680
그래서 색인 될 것
어린이 배열에.

308
00:16:27,680 --> 00:16:32,420
>> 그리고 지금의 경우 자녀에 해당 인덱스
배열이 null, 그것은 우리에게 의미

309
00:16:32,420 --> 00:16:34,990
더 이상 반복 할을 계속할 수
우리의 트라이 다운.

310
00:16:34,990 --> 00:16:38,870
그런 경우,이 단어는 할 수 없습니다
아마도 우리의 트라이로합니다.

311
00:16:38,870 --> 00:16:42,340
그것이 있다면, 그 것 때문에
경로가 될 것이다 의미

312
00:16:42,340 --> 00:16:43,510
그 단어에 이르기까지.

313
00:16:43,510 --> 00:16:45,290
그리고 당신은 널 (null)이 발생하지 않을 것입니다.

314
00:16:45,290 --> 00:16:47,850
그래서 널 (null)가 발생, 우리는 false를 반환합니다.

315
00:16:47,850 --> 00:16:49,840
이 단어는 사전에없는 것입니다.

316
00:16:49,840 --> 00:16:53,660
null이 아니었다면, 우리는거야
반복하기를 계속하는 것.

317
00:16:53,660 --> 00:16:57,220
>> 그래서 우리는 거기에 커서를거야
특정를 가리 키도록

318
00:16:57,220 --> 00:16:59,760
해당 인덱스의 노드.

319
00:16:59,760 --> 00:17:03,150
우리는 내내 그 일을 계속
전체 단어, 가정

320
00:17:03,150 --> 00:17:03,950
우리는 널 (null)에 충돌하지 마십시오.

321
00:17:03,950 --> 00:17:07,220
즉, 우리가 통과 할 수 있었다 의미
전체 단어 찾기

322
00:17:07,220 --> 00:17:08,920
우리 시도의 노드.

323
00:17:08,920 --> 00:17:10,770
그러나 우리는 확실히 아직 끝나지 않았습니다.

324
00:17:10,770 --> 00:17:12,290
>> 우리는 단지 true를 반환하지 않습니다.

325
00:17:12,290 --> 00:17:14,770
우리는 커서> 단어를 반환합니다.

326
00:17:14,770 --> 00:17:18,980
다시 기억 때문에, "고양이"이용하실 수 있습니다
우리의 사전에, 그리고 "재앙"

327
00:17:18,980 --> 00:17:22,935
, 우리는 성공적으로 우리가 얻을 것이다
을 통해 단어 "고양이." 그러나 커서

328
00:17:22,935 --> 00:17:25,760
말은 거짓과 진실되지 않습니다.

329
00:17:25,760 --> 00:17:30,930
그래서 우리는 표시하기 위해 커서의 단어를 반환
여부를이 노드는 실제로 단어입니다.

330
00:17:30,930 --> 00:17:32,470
그리고 그 확인을 위해의.

331
00:17:32,470 --> 00:17:34,250
>> 그래서 크기를 확인 할 수 있습니다.

332
00:17:34,250 --> 00:17:37,350
그래서 크기는 매우 쉽게 될 것입니다
이후, 부하 기억, 우린

333
00:17:37,350 --> 00:17:41,430
위한 사전의 크기를 증가
우리는 발생하는 각 단어.

334
00:17:41,430 --> 00:17:45,350
그래서 크기는 단지 예정
사전의 크기를 반환합니다.

335
00:17:45,350 --> 00:17:47,390
그리고 바로 그거야.

336
00:17:47,390 --> 00:17:50,590
>> 그래서 마지막으로 우리는 언로드했다.

337
00:17:50,590 --> 00:17:55,100
그래서 언로드, 우리가 사용하는거야
실제로 모든 할 수있는 재귀 함수

338
00:17:55,100 --> 00:17:56,530
우리의 작업.

339
00:17:56,530 --> 00:17:59,340
그래서 우리의 기능을 것입니다
언 로더를 호출 할.

340
00:17:59,340 --> 00:18:01,650
무엇 언 로더는 할거야?

341
00:18:01,650 --> 00:18:06,580
우리는 언 로더가 예정 여기를 참조하십시오
모든 아이들에서을 반복

342
00:18:06,580 --> 00:18:08,410
이 특정 노드.

343
00:18:08,410 --> 00:18:11,750
및 자식 노드가 아닌 경우
널 (null), 우리는거야

344
00:18:11,750 --> 00:18:13,730
자식 노드를 언로드.

345
00:18:13,730 --> 00:18:18,010
>> 그래서이 재귀 적으로 언로드합니다
우리 아이들의 모든.

346
00:18:18,010 --> 00:18:21,080
우리는 있는지 들어가면 우리 아이들의 모든
언로드 된, 우리

347
00:18:21,080 --> 00:18:25,210
자신을 확보, 그렇게 할 수 있습니다
자신을 언로드.

348
00:18:25,210 --> 00:18:29,460
이 재귀 적으로 작동합니다
전체 트라이 언로드.

349
00:18:29,460 --> 00:18:32,850
그리고 그 끝났어하면,
우리는 단지 true를 반환 할 수 있습니다.

350
00:18:32,850 --> 00:18:34,210
언로드가 실패 할 수 없습니다.

351
00:18:34,210 --> 00:18:35,710
우리는 단지 물건을 확보하고 있습니다.

352
00:18:35,710 --> 00:18:38,870
그래서 일단 우리가 확보 완료
모든 것이 true를 반환.

353
00:18:38,870 --> 00:18:40,320
그리고 바로 그거야.

354
00:18:40,320 --> 00:18:41,080
내 이름은 롭입니다.

355
00:18:41,080 --> 00:18:42,426
그리고 이것은 철자했다.

356
00:18:42,426 --> 00:18:47,830
>> [음악 연주]