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

2
00:00:11,856 --> 00:00:13,050
>> ರಾಬ್ ಬೌಡೆನ್: ಹಾಯ್.

3
00:00:13,050 --> 00:00:16,210
ನಾನು ರಾಬ್ ಮನುಷ್ಯ, ಮತ್ತು ಲೆಟ್ಸ್ ಹ್ಯಾಶ್
ಈ ಪರಿಹಾರ ಔಟ್.

4
00:00:16,210 --> 00:00:20,070
ಇಲ್ಲಿ ನಾವು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನೀನು
ಸಾಮಾನ್ಯ ಹ್ಯಾಷ್ ಟೇಬಲ್.

5
00:00:20,070 --> 00:00:24,090
ನಾವು ನೋಡಿ ನಮ್ಮ ಹ್ಯಾಶ್ Struct ನೋಡ್ನ
ಟೇಬಲ್ ಈ ರೀತಿ ಹೋಗುತ್ತದೆ.

6
00:00:24,090 --> 00:00:28,710
ಆದ್ದರಿಂದ ಒಂದು ಚಾರ್ ಪದ ಹೋಗುವುದಿಲ್ಲ
ಗಾತ್ರ ಉದ್ದ ಜೊತೆಗೆ 1 ರಚನೆಯ.

7
00:00:28,710 --> 00:00:32,259
ಗರಿಷ್ಠ ರಿಂದ 1 ಮರೆಯಬೇಡಿ
ನಿಘಂಟು ಪದ 45

8
00:00:32,259 --> 00:00:35,110
ಪಾತ್ರಗಳು, ನಂತರ ನಾವು ನೀನು
ಒಂದು ಹೆಚ್ಚುವರಿ ಪಾತ್ರ ಅಗತ್ಯವಿದೆ

9
00:00:35,110 --> 00:00:37,070
ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ 0.

10
00:00:37,070 --> 00:00:40,870
>> ತದನಂತರ ಪ್ರತಿ ನಮ್ಮ ಹ್ಯಾಷ್ ಟೇಬಲ್
ಬಕೆಟ್ ಶೇಖರಿಸಿಡಲು ಹೋಗುತ್ತದೆ ಒಂದು

11
00:00:40,870 --> 00:00:42,320
ನೋಡ್ಗಳ ಲಿಂಕ್ ಪಟ್ಟಿ.

12
00:00:42,320 --> 00:00:44,420
ನಾವು ಇಲ್ಲಿ ತನಿಖೆಯನ್ನು ರೇಖೀಯ ಏನು ಇಲ್ಲ.

13
00:00:44,420 --> 00:00:48,430
ಆದ್ದರಿಂದ ಸಲುವಾಗಿ ಮುಂದಿನ ಲಿಂಕ್
ಬಕೆಟ್ ಅಂಶ, ನಾವು ಒಂದು ಅಗತ್ಯವಿದೆ

14
00:00:48,430 --> 00:00:51,110
struct ನೋಡ್ * ಮುಂದಿನ.

15
00:00:51,110 --> 00:00:53,090
ಆದ್ದರಿಂದ ಒಂದು ನೋಡ್ ಕಾಣುತ್ತದೆ.

16
00:00:53,090 --> 00:00:56,180
ಈಗ, ಇಲ್ಲಿ ಘೋಷಣೆಯಾಗಿದೆ
ನಮ್ಮ ಹ್ಯಾಶ್ ಮೇಜಿನ.

17
00:00:56,180 --> 00:01:01,910
ಇದು 16.384 ಬಕೆಟ್ ಮಾಡಲಿಕ್ಕೆ, ಆದರೆ
ಎಂದು ನಿಜವಾಗಿಯೂ ಅಪ್ರಸ್ತುತವಾಗುತ್ತದೆ.

18
00:01:01,910 --> 00:01:05,450
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾವು ಹೊಂದಿರುವ ನೀನು
ಜಾಗತಿಕ ವೇರಿಯಬಲ್ hashtable_size, ಇದು

19
00:01:05,450 --> 00:01:08,640
0 ಎಂದು ಆಫ್ ಆರಂಭಿಸಲು ಹೋಗುವ, ಮತ್ತು ಅದು ಇದೆ
ಟ್ರ್ಯಾಕ್ ಹೋಗುವ ಎಷ್ಟು ಪದಗಳ

20
00:01:08,640 --> 00:01:10,080
ನಮ್ಮ ನಿಘಂಟು ಇದ್ದವು.

21
00:01:10,080 --> 00:01:10,760
ಸರಿ.

22
00:01:10,760 --> 00:01:13,190
>> ಆದ್ದರಿಂದ ಲೋಡ್ ಅವಲೋಕಿಸೋಣ.

23
00:01:13,190 --> 00:01:16,390
ಆದ್ದರಿಂದ ಲೋಡ್ ಗಮನಕ್ಕೆ,
ಇದು ಒಂದು bool ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

24
00:01:16,390 --> 00:01:20,530
ಇದು ಯಶಸ್ವಿಯಾಗಿ ವೇಳೆ ನೀವು ನಿಜವಾದ ಮರಳಿ
ಇಲ್ಲದಿದ್ದರೆ ಲೋಡ್ ಮತ್ತು ತಪ್ಪು.

25
00:01:20,530 --> 00:01:23,990
ಮತ್ತು ಇದು ಒಂದು const ಚಾರ್ * ಸ್ಟಾರ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
ನಿಘಂಟು ಇದು ನಿಘಂಟು,

26
00:01:23,990 --> 00:01:25,280
ನಾವು ತೆರೆಯಲು ಬಯಸುವ.

27
00:01:25,280 --> 00:01:27,170
ಆದ್ದರಿಂದ ಮೊದಲ ವಿಷಯ
ನಾವು ಮಾಡಲು ನೀನು.

28
00:01:27,170 --> 00:01:30,420
ನಾವು ನಿಘಂಟು fopen ನೀನು
ಓದುವ, ಮತ್ತು ನಾವು ನೀನು

29
00:01:30,420 --> 00:01:34,700
ಅದು ವೇಳೆ ಯಶಸ್ವಿಯಾದರು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ
ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮರಳಿದರು, ನಂತರ ನಾವು ಮಾಡಲಿಲ್ಲ

30
00:01:34,700 --> 00:01:37,440
ಯಶಸ್ವಿಯಾಗಿ ನಿಘಂಟು ತೆರೆಯಲು
ಮತ್ತು ನಾವು ತಪ್ಪು ಹಿಂದಿರುಗಿಸಬೇಕಾಗುತ್ತದೆ.

31
00:01:37,440 --> 00:01:41,580
>> ಆದರೆ ಯಶಸ್ವಿಯಾಗಿ ಮಾಡಿದರು ಎಂದು ಊಹಿಸಿಕೊಂಡು
ಮುಕ್ತ, ನಾವು ಓದಲು ಬಯಸುವ

32
00:01:41,580 --> 00:01:42,400
ನಿಘಂಟು.

33
00:01:42,400 --> 00:01:46,210
ನಾವು ಕೆಲವು ಹೇಗೆ ರವರೆಗೆ ಆದ್ದರಿಂದ ಲೂಪಿಂಗ್ ಇರಿಸಿಕೊಳ್ಳಲು
ಈ ಔಟ್ ಮುರಿಯಲು ಕಾರಣ

34
00:01:46,210 --> 00:01:47,570
ನಾವು ನೋಡುತ್ತಾರೆ ಲೂಪ್.

35
00:01:47,570 --> 00:01:51,780
ಆದ್ದರಿಂದ ಲೂಪಿಂಗ್ ಇರಿಸಿಕೊಳ್ಳಲು, ಮತ್ತು ಈಗ ನಾವು ನೀನು
ಒಂದು ನೋಡ್ malloc ಗೆ.

36
00:01:51,780 --> 00:01:56,800
ಮತ್ತು ಸಹಜವಾಗಿ, ನಾವು ಚೆಕ್ ದೋಷಕ್ಕೆ ಅಗತ್ಯವಿದೆ
ಮತ್ತೆ mallocing ಯಶಸ್ವಿಯಾಗಲಿಲ್ಲ ಹಾಗಾಗಿ

37
00:01:56,800 --> 00:02:00,660
ಮತ್ತು ನಾವು ನಾವು ಯಾವುದೇ ನೋಡ್ ಇಳಿಸುವುದನ್ನು ಬಯಸುವ
ಮೊದಲು malloc ಗೆ ಏನಾಯಿತು, ಮುಚ್ಚಿ

38
00:02:00,660 --> 00:02:02,590
ನಿಘಂಟು ಸುಳ್ಳು ಹಿಂತಿರುಗಿ.

39
00:02:02,590 --> 00:02:07,440
>> ಆದರೆ ನಿರ್ಲಕ್ಷಿಸಿ, ಊಹಿಸಿಕೊಂಡು ನಾವು
ಯಶಸ್ವಿಯಾದರು, ನಾವು fscanf ಬಳಸಲು ಬಯಸುವ

40
00:02:07,440 --> 00:02:12,400
ಒಂದೇ ಒಂದು ಪದ ಓದಲು ನಮ್ಮ
ನಮ್ಮ ನೋಡ್ ಡಿಕ್ಷನರಿ.

41
00:02:12,400 --> 00:02:17,310
ಆದ್ದರಿಂದ ಪ್ರವೇಶ> ಪದ ನೆನಪು ಚಾರ್
ಪದ ಗಾತ್ರ ಉದ್ದದ ಬಫರ್ ಜೊತೆಗೆ

42
00:02:17,310 --> 00:02:20,300
ನಾವು ನೀನು ಒಂದು
ಸೈನ್ ಪದ ಶೇಖರಿಸಿಡಲು

43
00:02:20,300 --> 00:02:25,280
ಆದ್ದರಿಂದ fscanf 1 ಎಲ್ಲಿಯವರೆಗೆ ಮರಳಲು ಹೋಗುತ್ತದೆ
ಯಶಸ್ವಿಯಾಗಿ ಓದಲು ಸಾಧ್ಯವಾಯಿತು ಎಂದು

44
00:02:25,280 --> 00:02:26,750
ಕಡತದಿಂದ ಪದ.

45
00:02:26,750 --> 00:02:31,030
>> ದೋಷ ಎರಡೂ ಸಂಭವಿಸುತ್ತದೆ ಅಥವಾ ನಾವು ತಲುಪಿದಲ್ಲಿ
ಕಡತದ ಕೊನೆಯಲ್ಲಿ, ಇದು ತಿನ್ನುವೆ

46
00:02:31,030 --> 00:02:34,950
ಇದು ಇದ್ದರೆ ಸಂದರ್ಭದಲ್ಲಿ 1 ಮರಳಲು
1 ಮರಳಲು, ನಾವು ಅಂತಿಮವಾಗಿ ಮುರಿಯಲು ನೀನು

47
00:02:34,950 --> 00:02:37,280
ಈ ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಔಟ್.

48
00:02:37,280 --> 00:02:42,770
ಆದ್ದರಿಂದ ನಾವು ನೋಡಿ ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಒಮ್ಮೆ
ಒಂದು ಪದ ಓದಲು

49
00:02:42,770 --> 00:02:48,270
ಪ್ರವೇಶ> ಪದ, ನಾವು ಹ್ಯಾಶ್ ನೀನು
ನಮ್ಮ ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಬಳಸಿ ಆ ಪದ.

50
00:02:48,270 --> 00:02:49,580
ನಲ್ಲಿ ಅವಲೋಕಿಸೋಣ
ಹ್ಯಾಶ್ ಕ್ರಿಯೆ.

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

52
00:02:52,430 --> 00:02:55,610
>> ಆದ್ದರಿಂದ ನೀವು ನಿಜವಾಗಿಯೂ ಅಗತ್ಯವಿಲ್ಲ
ಈ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು.

53
00:02:55,610 --> 00:02:59,460
ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ನಾವು ಈ ಎಳೆದ
ಇಂಟರ್ನೆಟ್ ಕಾರ್ಯ ಹ್ಯಾಶ್.

54
00:02:59,460 --> 00:03:04,010
ನೀವು ಗುರುತಿಸಲು ಅಗತ್ಯವಿದೆ ಮಾತ್ರ ವಿಷಯ
ಈ ಒಂದು const ಚಾರ್ * ಪದ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ,

55
00:03:04,010 --> 00:03:08,960
ಆದ್ದರಿಂದ ಇನ್ಪುಟ್ ಆಗಿ ಸ್ಟ್ರಿಂಗ್ ಪಡೆದು ವಿಶೇಷವೇನು
ಔಟ್ಪುಟ್ ಒಂದು ಇಂಟ್ ರುಜುಮಾಡದ ಹಿಂದಿರುಗಿದ.

56
00:03:08,960 --> 00:03:12,360
ಆದ್ದರಿಂದ ಎಲ್ಲಾ ಒಂದು ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಇಲ್ಲಿದೆ, ಇದು
ಒಂದು ಆದಾನ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ನೀವು ಒಂದು ನೀಡುತ್ತದೆ

57
00:03:12,360 --> 00:03:14,490
ಹ್ಯಾಶ್ ಟೇಬಲ್ಲಿಗೆ ಸೂಚ್ಯಂಕ.

58
00:03:14,490 --> 00:03:18,530
ನಾವು NUM_BUCKETS ಮೂಲಕ ಮೊಡ್ಡಿಂಗ್ ನೀವು ಗಮನಿಸಬಹುದು
ಆದ್ದರಿಂದ ಹ್ಯಾಶ್ ಮೌಲ್ಯವನ್ನು ಮರಳಿದರು

59
00:03:18,530 --> 00:03:21,730
ವಾಸ್ತವವಾಗಿ ಹ್ಯಾಶ್ ಟೇಬಲ್ಲಿಗೆ ಸೂಚ್ಯಂಕ
ಮತ್ತು ಮಾಡುತ್ತದೆ ಮೀರಿ ಸೂಚ್ಯಂಕ

60
00:03:21,730 --> 00:03:24,320
ರಚನೆಯ ಪರಿಮಿತಿಗಳನ್ನು.

61
00:03:24,320 --> 00:03:27,855
>> ಆದ್ದರಿಂದ ಹ್ಯಾಶ್ ಕ್ರಿಯೆ, ನಾವು ನೀನು ಕೊಟ್ಟಿರುವ
ನಾವು ಓದುವ ಪದ ಹ್ಯಾಶ್

62
00:03:27,855 --> 00:03:31,700
ನಿಘಂಟು ಮತ್ತು ನಂತರ ನಾವು ನೀನು
ಎಂದು ಬಳಸಲು ಸೇರಿಸಲು ಹೊಂದಿದೆ

63
00:03:31,700 --> 00:03:33,750
ಹ್ಯಾಶ್ ಟೇಬಲ್ಲಿಗೆ ಪ್ರವೇಶ.

64
00:03:33,750 --> 00:03:38,830
ಈಗ, hashtable ಹ್ಯಾಶ್ ಪ್ರಸ್ತುತ
ಲಿಂಕ್ ಹ್ಯಾಷ್ ಟೇಬಲ್ ನಲ್ಲಿ ಪಟ್ಟಿ, ಮತ್ತು

65
00:03:38,830 --> 00:03:41,410
ಇದು ಕೇವಲ ಶೂನ್ಯ ಎಂದು ತುಂಬಾ ಸಂಭಾವ್ಯ.

66
00:03:41,410 --> 00:03:45,640
ನಾವು ನಮ್ಮ ನಮೂದನ್ನು ಸೇರಿಸಲು ಬಯಸುವ
ಈ ಲಿಂಕ್ ಪಟ್ಟಿ ಆರಂಭದಲ್ಲಿ, ಮತ್ತು ಆದ್ದರಿಂದ

67
00:03:45,640 --> 00:03:48,910
ನಾವು ನಮ್ಮ ಪ್ರಸ್ತುತ ಪ್ರವೇಶ ಮಾಡಲಿಕ್ಕೆ
ಪ್ರಸ್ತುತ ಯಾವ ಹ್ಯಾಷ್ ಟೇಬಲ್ ಬೆಟ್ಟು

68
00:03:48,910 --> 00:03:54,030
ಅಂಕಗಳ ನಂತರ ನಾವು ಶೇಖರಿಸಿಡಲು ನೀನು
ಹ್ಯಾಶ್ ನಲ್ಲಿ ಹ್ಯಾಷ್ ಟೇಬಲ್ ನಲ್ಲಿ

69
00:03:54,030 --> 00:03:55,350
ಈಗಿರುವ ನಮೂದನ್ನು.

70
00:03:55,350 --> 00:03:59,320
>> ಆದ್ದರಿಂದ ಈ ಎರಡು ಸಾಲುಗಳನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಸೇರಿಸಲು
ಆರಂಭದಲ್ಲಿ ಪ್ರವೇಶ

71
00:03:59,320 --> 00:04:02,270
ಎಂದು ಇಂಡೆಕ್ಸ್ನಲ್ಲಿ ಲಿಂಕ್ ಪಟ್ಟಿ
ಹ್ಯಾಷ್ ಟೇಬಲ್ ನಲ್ಲಿ.

72
00:04:02,270 --> 00:04:04,900
ನಾವು ಪೂರೈಸಿದ ನಂತರ, ನಾವು ತಿಳಿದಿರುವಂತೆ
ನಾವು ಮತ್ತೊಂದು ಪದ ಕಂಡು

73
00:04:04,900 --> 00:04:07,800
ನಿಘಂಟು ಮತ್ತು ನಾವು ಮತ್ತೆ ಹೆಚ್ಚಿಸಲು.

74
00:04:07,800 --> 00:04:13,960
ನಾವು ನಡೆಸುವ ಎಂದು fscanf ರವರೆಗೆ
ಅಂತಿಮವಾಗಿ ಅಲ್ಲದ ಏನಾದರೂ 1 ಹಿಂದಿರುಗಿಸುತ್ತದೆ

75
00:04:13,960 --> 00:04:18,560
ಪಾಯಿಂಟ್ ನಾವು ಅಗತ್ಯವಿದೆ ಎಂದು ನೆನಪಿಡಿ
ಉಚಿತ ಪ್ರವೇಶ, ಆದ್ದರಿಂದ ಇಲ್ಲಿ, ನಾವು ಒಂದು malloced

76
00:04:18,560 --> 00:04:21,329
ಪ್ರವೇಶ ಮತ್ತು ನಾವು ಏನನ್ನಾದರೂ ಓದಲು ಪ್ರಯತ್ನಿಸಿದ
ನಿಘಂಟು ನಿಂದ.

77
00:04:21,329 --> 00:04:24,110
ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಓದಲು ಮಾಡಲಿಲ್ಲ
ನಿಘಂಟು ಏನನ್ನೋ ಇದರಲ್ಲಿ

78
00:04:24,110 --> 00:04:27,440
ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ನಾವು ಪ್ರವೇಶ ಮುಕ್ತಗೊಳಿಸಲು ಅಗತ್ಯವಿದೆ
ವಾಸ್ತವವಾಗಿ ಹ್ಯಾಶ್ ಟೇಬಲ್ಲಿಗೆ ಯಾವತ್ತೂ

79
00:04:27,440 --> 00:04:29,110
ಮತ್ತು ಅಂತಿಮವಾಗಿ ಮುರಿಯಲು.

80
00:04:29,110 --> 00:04:32,750
>> ನಾವು ಭೇದಿಸಿ ಒಮ್ಮೆ ನಾವು, ಚೆನ್ನಾಗಿ, ನೋಡಿ ಅಗತ್ಯವಿದೆ
ನಾವು ಏಕೆಂದರೆ ಅಲ್ಲಿ ಮುರಿದಿದ್ದಾರೆ

81
00:04:32,750 --> 00:04:35,840
ದೋಷ ಕಡತ ಓದುವ, ಅಥವಾ
ನಾವು ತಲುಪಿತು ಏಕೆಂದರೆ ನಾವು ಮುರಿದಿದ್ದಾರೆ

82
00:04:35,840 --> 00:04:37,120
ಕಡತದ ಕೊನೆಯಲ್ಲಿ?

83
00:04:37,120 --> 00:04:40,150
ದೋಷವಿತ್ತು ವೇಳೆ, ನಾವು ಬಯಸುವ
ಲೋಡ್ ಏಕೆಂದರೆ ತಪ್ಪು ಹಿಂತಿರುಗಿ

84
00:04:40,150 --> 00:04:43,260
ಯಶಸ್ಸು ಮತ್ತು ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ, ನಾವು ಬಯಸುವ
ನಾವು ಓದಲು ಎಲ್ಲಾ ಪದಗಳನ್ನು ಇಳಿಸುವುದನ್ನು

85
00:04:43,260 --> 00:04:45,670
ಮತ್ತು ನಿಘಂಟು ಕಡತ ಮುಚ್ಚಿ.

86
00:04:45,670 --> 00:04:48,740
ನಾವು ಯಶಸ್ವಿಯಾಗಲು ಮಾಡಲಿಲ್ಲ ಭಾವಿಸಿಕೊಂಡು, ನಂತರ ನಾವು
ಇನ್ನೂ ನಿಘಂಟು ಮುಚ್ಚಲು ಅಗತ್ಯ

87
00:04:48,740 --> 00:04:51,970
ಫೈಲ್, ಮತ್ತು ಅಂತಿಮವಾಗಿ ರಿಂದ ನಿಜವಾದ ಹಿಂತಿರುಗಿ
ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಲೋಡ್ ಮಾಡಿದ

88
00:04:51,970 --> 00:04:53,040
ನಿಘಂಟು.

89
00:04:53,040 --> 00:04:54,420
ಮತ್ತು ಲೋಡ್ ಅದು.

90
00:04:54,420 --> 00:04:59,020
>> ಈಗ ಹೊತ್ತ ಹ್ಯಾಷ್ ಟೇಬಲ್ ನೀಡಿದ ಪರಿಶೀಲಿಸಿ,
ಈ ರೀತಿ ಹೋಗುತ್ತದೆ.

91
00:04:59,020 --> 00:05:02,690
ಆದ್ದರಿಂದ, ಇದು ಒಂದು bool ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಪರಿಶೀಲಿಸಿ ಇದು
ಸೂಚಿಸಲು ಹೋಗುವ ಎಂಬುದನ್ನು

92
00:05:02,690 --> 00:05:07,530
ಜಾರಿಗೆ ಇನ್ ಚಾರ್ * ಪದ, ಎಂಬುದನ್ನು
ಜಾರಿಗೆ ಇನ್ ಸ್ಟ್ರಿಂಗ್ ನಮ್ಮ ನಿಘಂಟು ಹೊಂದಿದೆ.

93
00:05:07,530 --> 00:05:10,530
ನಿಘಂಟಿನಲ್ಲಿ ಅದು ಹಾಗಿದ್ದರೆ, ವೇಳೆ
ನಮ್ಮ ಹ್ಯಾಶ್ ಕೋಷ್ಟಕದಲ್ಲಿ, ನಾವು ಹಿಂದಿರುಗುವ

94
00:05:10,530 --> 00:05:13,380
ನಿಜವಾದ, ಮತ್ತು ಇದು ಅಲ್ಲ,
ನಾವು ತಪ್ಪು ಹಿಂತಿರುಗುವುದು.

95
00:05:13,380 --> 00:05:17,770
ಈ ಜಾರಿಗೆ ಇನ್ ಪದ ನೀಡಲಾಗಿದೆ, ನಾವು ಕೋರುತ್ತೇವೆ
ಪದ ಹ್ಯಾಶ್ ಹೋಗುವ.

96
00:05:17,770 --> 00:05:22,020
>> ಈಗ, ಗುರುತಿಸಲು ಪ್ರಮುಖ ವಿಷಯ
ಲೋಡ್, ನಾವು ತಿಳಿದಿದ್ದು ಆ ಎಲ್ಲಾ

97
00:05:22,020 --> 00:05:25,820
ಪದಗಳನ್ನು ಕಡಿಮೆ ಕೇಸ್ ಎಂದು ಹೊರಟಿದ್ದ,
ಆದರೆ ಇಲ್ಲಿ, ನಾವು ಖಚಿತವಾಗಿ ಇಲ್ಲ.

98
00:05:25,820 --> 00:05:29,510
ನಮ್ಮ ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ನೋಡೋಣ ವೇಳೆ,
ವಾಸ್ತವವಾಗಿ ನಮ್ಮ ಹ್ಯಾಶ್ ಕ್ರಿಯೆ

99
00:05:29,510 --> 00:05:32,700
ಪ್ರತಿ ಪಾತ್ರದ lowercasing ಇದೆ
ಪದದ.

100
00:05:32,700 --> 00:05:37,580
ಆದ್ದರಿಂದ ಲೆಕ್ಕಿಸದೆ ಬಂಡವಾಳದ
ಪದ, ನಮ್ಮ ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಹೋಗುತ್ತದೆ

101
00:05:37,580 --> 00:05:42,270
ಏನೇ ಅದೇ ಸೂಚ್ಯಂಕ ಹಿಂದಿರುಗುತ್ತಿದ್ದವು
ಬಂಡವಾಳೀಕರಣ ಇದು ಎಂದು ಎಂದು ಹೊಂದಿದೆ

102
00:05:42,270 --> 00:05:45,280
ಒಂದು ಸಂಪೂರ್ಣವಾಗಿ ಸಣ್ಣ ಮರಳಿದರು
ಪದ ಆವೃತ್ತಿ.

103
00:05:45,280 --> 00:05:45,950
ಸರಿ.

104
00:05:45,950 --> 00:05:47,410
>> ಆದ್ದರಿಂದ ನಮ್ಮ ಸೂಚ್ಯಂಕ.

105
00:05:47,410 --> 00:05:49,790
ಇದು ಈ ಪದ ಹ್ಯಾಶ್ ಕೋಷ್ಟಕವನ್ನು.

106
00:05:49,790 --> 00:05:52,940
ಈಗ, ಲೂಪ್ ಈ ಹೋಗುತ್ತದೆ
ಲಿಂಕ್ ಪಟ್ಟಿ ಮೇಲೆ ಗೆ

107
00:05:52,940 --> 00:05:55,000
ಆ ಸೂಚ್ಯಂಕ ಆಗಿತ್ತು.

108
00:05:55,000 --> 00:05:59,630
ನಾವು ಪ್ರವೇಶ ಆರಂಭಿಸುವಲ್ಲಿ ಗಮನಕ್ಕೆ
ಸೂಚ್ಯಂಕ ತೋರಿಸಲು.

109
00:05:59,630 --> 00:06:03,480
ನಾವು ಪ್ರವೇಶ ಮಾಡುತ್ತದೆ ಮುಂದುವರಿಯಲು ನೀನು
ಸಮಾನ ಶೂನ್ಯ, ಮತ್ತು ನೆನಪು

110
00:06:03,480 --> 00:06:08,350
ನಮ್ಮ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಪಾಯಿಂಟರ್ ಅಪ್ಡೇಟ್
ಪ್ರವೇಶ ಮುಂದಿನ ಪ್ರವೇಶ> ಸಮ, ಆದ್ದರಿಂದ ಹೊಂದಿವೆ

111
00:06:08,350 --> 00:06:13,840
ನಮ್ಮ ಪ್ರಸ್ತುತ ಪ್ರವೇಶ ಬಿಂದು
ಲಿಂಕ್ ಪಟ್ಟಿ ಮುಂದಿನ ಐಟಂ.

112
00:06:13,840 --> 00:06:14,400
ಸರಿ.

113
00:06:14,400 --> 00:06:19,150
>> ಆದ್ದರಿಂದ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಪ್ರತಿಯೊಂದು ನಮೂದು,
ನಾವು strcasecmp ಬಳಸಲು ನೀನು.

114
00:06:19,150 --> 00:06:23,780
ಇದು strcmp ಏಕೆಂದರೆ ಮತ್ತೊಮ್ಮೆ, ನಾವು
ತೋರದಂತೆ ವಿಷಯಗಳನ್ನು ಸಂದರ್ಭದಲ್ಲಿ ಮಾಡಲು ಬಯಸುವ.

115
00:06:23,780 --> 00:06:28,830
ನಾವು ಪದ ಹೋಲಿಸಿ strcasecmp ಬಳಸಲು
ಈ ಕಾರ್ಯ ರವಾನಿಸಲಾಗಿದೆ

116
00:06:28,830 --> 00:06:31,860
ಪದ ವಿರುದ್ಧದ
ಈ ನಮೂದನ್ನು ರಲ್ಲಿ ಆಗಿದೆ.

117
00:06:31,860 --> 00:06:35,570
ಇದು 0 ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಇರಲಿಲ್ಲ ಅರ್ಥ
ನಾವು ಬಯಸುವ ಸಂದರ್ಭದಲ್ಲಿ ಒಂದು ಪಂದ್ಯದಲ್ಲಿ,

118
00:06:35,570 --> 00:06:36,630
ನಿಜವಾದ ಹಿಂತಿರುಗಿ.

119
00:06:36,630 --> 00:06:39,590
ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಕಂಡು
ನಮ್ಮ ಹ್ಯಾಶ್ ಕೋಷ್ಟಕದಲ್ಲಿ ಪದ.

120
00:06:39,590 --> 00:06:43,040
>> ಪಂದ್ಯದಲ್ಲಿ ಇರಲಿಲ್ಲ, ಆಗ ನಾವು ಆರ್
ಮತ್ತೆ ಲೂಪ್ ಹೋಗುವ ಮತ್ತು ನೋಡಲು

121
00:06:43,040 --> 00:06:43,990
ಮುಂದಿನ ಪ್ರವೇಶ.

122
00:06:43,990 --> 00:06:47,640
ನಾವು ಹಾಗೆಯೇ ಇಲ್ಲ ಆವರ್ತಿಸುವ ಮುಂದುವರಿಸುತ್ತೇವೆ
ಈ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ನಮೂದುಗಳು.

123
00:06:47,640 --> 00:06:50,160
ನಾವು ಮುರಿಯಲು ಏನಾಗುತ್ತದೆ
ಲೂಪ್ ಈ ಔಟ್?

124
00:06:50,160 --> 00:06:55,110
ನಾವು ಒಂದು ನಮೂದನ್ನು ಕಾಣಲಿಲ್ಲ ಅರ್ಥ
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಈ ಪದ ದಾಖಲೆಗಳುಸರಿಹೊಂದಿವೆ

125
00:06:55,110 --> 00:07:00,220
ನಾವು ಸೂಚಿಸಲು ತಪ್ಪು ಹಿಂತಿರುಗಿ ನಮ್ಮ
ಹ್ಯಾಷ್ ಟೇಬಲ್ ಈ ಪದ ಹೊಂದಿರುವುದಿಲ್ಲ.

126
00:07:00,220 --> 00:07:01,910
ಮತ್ತು ಚೆಕ್ ಅದು.

127
00:07:01,910 --> 00:07:02,540
ಸರಿ.

128
00:07:02,540 --> 00:07:04,790
>> ಆದ್ದರಿಂದ ಗಾತ್ರದಲ್ಲಿ ಅವಲೋಕಿಸೋಣ.

129
00:07:04,790 --> 00:07:09,280
ಈಗ, ಗಾತ್ರ ಬಹಳ ಸರಳ ಏರಲಿದೆ
ರಿಂದ ಪ್ರತಿ ಪದಕ್ಕೆ, ಲೋಡ್ ನೆನಪು

130
00:07:09,280 --> 00:07:12,880
ನಾವು ಜಾಗತಿಕ ವೃದ್ಧಿಯಾಗಲ್ಪಡಬಹುದು ಕಂಡು
ವೇರಿಯಬಲ್ hashtable_size.

131
00:07:12,880 --> 00:07:15,830
ಆದ್ದರಿಂದ ಗಾತ್ರ ಕಾರ್ಯ ಕೇವಲ
ಜಾಗತಿಕ ಮರಳಿ ಹೋಗುವ

132
00:07:15,830 --> 00:07:18,150
ವೇರಿಯಬಲ್, ಮತ್ತು ಅದು ಇಲ್ಲಿದೆ.

133
00:07:18,150 --> 00:07:22,300
>> ಈಗ ಅಂತಿಮವಾಗಿ, ನಾವು ಇಳಿಸುವುದನ್ನು ಅಗತ್ಯವಿದೆ
ನಿಘಂಟು ಎಲ್ಲವೂ ಮಾಡಲಾಗುತ್ತದೆ ಒಮ್ಮೆ.

134
00:07:22,300 --> 00:07:25,340
ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು ಏನು ಮಾಡೋಣ?

135
00:07:25,340 --> 00:07:30,440
ಇಲ್ಲಿಯೇ, ನಾವು ಎಲ್ಲಾ ಮೇಲೆ ಲೂಪ್ ನೀವು
ನಮ್ಮ ಹ್ಯಾಶ್ ಮೇಜಿನ ಬಕೆಟ್.

136
00:07:30,440 --> 00:07:33,240
ಆದ್ದರಿಂದ NUM_BUCKETS ಬಕೆಟ್ ಇವೆ.

137
00:07:33,240 --> 00:07:37,490
ಮತ್ತು ನಮ್ಮ ಹ್ಯಾಶ್ ಪ್ರತಿ ಲಿಂಕ್ ಪಟ್ಟಿ
ಟೇಬಲ್, ನಾವು ಮೇಲೆ ಲೂಪ್ ನೀನು

138
00:07:37,490 --> 00:07:41,070
ಲಿಂಕ್ ಪಟ್ಟಿ ಸಂಪೂರ್ಣ
ಪ್ರತಿ ಅಂಶ ಮುಕ್ತಗೊಳಿಸಿದ.

139
00:07:41,070 --> 00:07:46,070
ಈಗ, ನಾವು ಎಚ್ಚರಿಕೆಯಿಂದ ಮಾಡಬೇಕಾಗುತ್ತದೆ, ಇಲ್ಲಿ ನಾವು
ಎಂದು ತಾತ್ಕಾಲಿಕ ವೇರಿಯಬಲ್

140
00:07:46,070 --> 00:07:49,740
ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಸಂಗ್ರಹಿಸುವ
ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಅಂಶ.

141
00:07:49,740 --> 00:07:52,140
ನಂತರ ನಾವು ಉಚಿತ ನೀನು
ಪ್ರಸ್ತುತ ಅಂಶ.

142
00:07:52,140 --> 00:07:55,990
>> ನಾವು ಈ ಮಾಡಲು ಮರೆಯಬೇಡಿ ಅಗತ್ಯವಿದೆ
ಕೇವಲ ಪ್ರಸ್ತುತ ಅಂಶ ಮುಕ್ತಗೊಳಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ

143
00:07:55,990 --> 00:07:59,260
ತದನಂತರ ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸಿ
ಕಾರಣ ಒಮ್ಮೆ ನಾವು ಬಿಡುಗಡೆ

144
00:07:59,260 --> 00:08:00,870
ಮೆಮೊರಿ ಅಮಾನ್ಯ ಆಗುತ್ತದೆ.

145
00:08:00,870 --> 00:08:04,990
ನಾವು ಒಂದು ಪಾಯಿಂಟರ್ ಸುಮಾರು ಇರಿಸಿಕೊಳ್ಳಲು ಅಗತ್ಯವಿದೆ
ಮುಂದಿನ ಅಂಶ, ನಾವು ಮುಕ್ತಗೊಳಿಸಲು

146
00:08:04,990 --> 00:08:08,360
ಪ್ರಸ್ತುತ ಅಂಶ, ಮತ್ತು ನಂತರ ನಾವು ಅಪ್ಡೇಟ್
ತೋರಿಸಲು ನಮ್ಮ ಪ್ರಸ್ತುತ ಅಂಶ

147
00:08:08,360 --> 00:08:09,590
ಮುಂದಿನ ಅಂಶ.

148
00:08:09,590 --> 00:08:12,770
>> ನಾವು ಅಂಶಗಳನ್ನು ಲೂಪ್ ಇವೆ ವಿಲ್
ಈ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ.

149
00:08:12,770 --> 00:08:16,450
ನಾವು ಎಲ್ಲಾ ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು ಹಾಗೆ ಮಾಡುತ್ತೇವೆ
ಹ್ಯಾಷ್ ಟೇಬಲ್, ಮತ್ತು ನಾವು ಪೂರೈಸಿದ ಒಮ್ಮೆ

150
00:08:16,450 --> 00:08:20,180
, ನಾವು ಸಂಪೂರ್ಣವಾಗಿ ಕೆಳಗಿಳಿಸಲಾಯಿತು ಬಂದಿದೆ
ಹ್ಯಾಷ್ ಟೇಬಲ್, ಮತ್ತು ನಾವು ಮುಗಿಸಿದ್ದೀರಿ.

151
00:08:20,180 --> 00:08:24,050
ಆದ್ದರಿಂದ unloads ಫಾರ್ ಎಂದಿಗೂ ಅಸಾಧ್ಯ
ಸುಳ್ಳು ಹಿಂತಿರುಗಿ ನಾವು ಪೂರೈಸಿದಾಗ, ನಾವು

152
00:08:24,050 --> 00:08:25,320
ಕೇವಲ ನಿಜವಾದ ಹಿಂತಿರುಗಿ.

153
00:08:25,320 --> 00:08:27,563