1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [ವಿಭಾಗ 6] [ಅಧಿಕ ಆರಾಮದಾಯಕ]

2
00:00:01,000 --> 00:00:04,000
[ರಾಬ್ ಬೌಡೆನ್] [ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ]

3
00:00:04,000 --> 00:00:09,000
[ಈ CS50 ಹೊಂದಿದೆ.] [CS50.TV]

4
00:00:09,000 --> 00:00:11,000
>> ನಾವು ಪ್ರಶ್ನೆಗಳನ್ನು ನಮ್ಮ ಭಾಗಕ್ಕೆ ಹೋಗಿ ಮಾಡಬಹುದು.

5
00:00:11,000 --> 00:00:17,000
ನಾನು ಮೊದಲು ಸ್ಥಳದ URL ಅನ್ನು ಕಳುಹಿಸಲಾಗಿದೆ.

6
00:00:17,000 --> 00:00:22,000
ಪ್ರಶ್ನೆಗಳನ್ನು ವಿಭಾಗದ ಪ್ರಾರಂಭದ ಹೇಳುತ್ತಾರೆ-

7
00:00:22,000 --> 00:00:26,000
ಸ್ಪಷ್ಟವಾಗಿ ನಾನು ಬಹಳ ಸುಲಭವಾದ ಪ್ರಶ್ನೆ unsick-ಹೊಂದಿದೆ ಸಂಪೂರ್ಣವಾಗಿ ಅಲ್ಲ

8
00:00:26,000 --> 00:00:28,000
valgrind ಸ್ವಲ್ಪ ಏನು?

9
00:00:28,000 --> 00:00:30,000
Valgrind ಏನು ಮಾಡುತ್ತದೆ?

10
00:00:30,000 --> 00:00:34,000
ಯಾರಾದರೂ valgrind ಏನು ಹೇಳಲು ಬಯಸುತ್ತೀರಿ?

11
00:00:34,000 --> 00:00:36,000
[ವಿದ್ಯಾರ್ಥಿ] ಪರೀಕ್ಷಣೆ ಮೆಮೊರಿ ಸೋರುವಿಕೆ.

12
00:00:36,000 --> 00:00:41,000
ಹೌದು, valgrind ಸಾಮಾನ್ಯ ಮೆಮೊರಿ ಪರೀಕ್ಷಕ ಹೊಂದಿದೆ.

13
00:00:41,000 --> 00:00:44,000
ನೀವು ಯಾವುದೇ ಮೆಮೊರಿ ಸೋರುವಿಕೆ ಹೊಂದಿದ್ದರೆ ಇದು ಕೊನೆಯಲ್ಲಿ, ನೀವು ಹೇಳುತ್ತದೆ

14
00:00:44,000 --> 00:00:49,000
ನೀವು ಬಯಸುವ ನಾವು ಏಕೆಂದರೆ ಅದನ್ನು ಬಳಸಿಕೊಂಡು ಏನನ್ನು ಬಹುಮಟ್ಟಿಗೆ

15
00:00:49,000 --> 00:00:54,000
ಸಮಸ್ಯೆ ಸೆಟ್ ಅಥವಾ ನೀವು ಬಯಸುವ ವೇಳೆ ಉತ್ತಮವಾಗಿ

16
00:00:54,000 --> 00:00:59,000
ದೊಡ್ಡ ಮಂಡಳಿಯಲ್ಲಿ ಪಡೆಯುವುದು, ನೀವು ಯಾವುದೇ ಮೆಮೊರಿ ಸೋರುವಿಕೆ ಮಾಡಬೇಕು

17
00:00:59,000 --> 00:01:01,000
ಮತ್ತು ಸಂದರ್ಭದಲ್ಲಿ ನೀವು ಹೇಗೆ ಸಾಧ್ಯವಿಲ್ಲ ಒಂದು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಹೊಂದಿವೆ

18
00:01:01,000 --> 00:01:04,000
ನೀವು ಒಂದು ಕಡತವನ್ನು ತೆರೆಯಲು ಮಾಡಿದಾಗ ಸಹ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ

19
00:01:04,000 --> 00:01:07,000
ಮತ್ತು ನೀವು ಇದನ್ನು ಮುಚ್ಚಿ ಹೋದರೆ, ಒಂದು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಇಲ್ಲಿದೆ.

20
00:01:07,000 --> 00:01:10,000
>> ಬಹಳಷ್ಟು ಜನರು ಅವರು ಮುಕ್ತಗೊಳಿಸಿದ ಇಲ್ಲ ಕೆಲವು ನೋಡ್ ಹುಡುಕುತ್ತಿರುವ

21
00:01:10,000 --> 00:01:15,000
ಆಗ ನಿಜವಾಗಿಯೂ, ಅವರು ಮೊದಲ ಹಂತದಲ್ಲಿ ನಿಘಂಟು ಮುಚ್ಚಿ ಮಾಡಲಿಲ್ಲ.

22
00:01:15,000 --> 00:01:19,000
ಇದು, ನೀವು ಯಾವುದೇ ಅಮಾನ್ಯವಾಗಿದೆ ಹೊಂದಿದ್ದರೆ ಓದುತ್ತದೆ ತಿಳಿಸುವುದು ಅಥವಾ ಬರೆಯುತ್ತಾರೆ

23
00:01:19,000 --> 00:01:22,000
ನೀವು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಮೌಲ್ಯವನ್ನು ವೇಳೆ ಇದು ಅರ್ಥ

24
00:01:22,000 --> 00:01:26,000
ಆ ರಾಶಿ ಕೊನೆಯ ಆಚೆಗೆ ಮತ್ತು ಇದು seg ತಪ್ಪು ಸಂಭವಿಸಿದಾಗ ಇಲ್ಲ

25
00:01:26,000 --> 00:01:30,000
ಆದರೆ valgrind, ನಿಜವಾಗಿಯೂ ಅಲ್ಲಿ ಬರೆಯಲು ಮಾಡಬಾರದು ಎಂದು, ಅದನ್ನು ಹಿಡಿಯಲು

26
00:01:30,000 --> 00:01:33,000
ಆದ್ದರಿಂದ ನೀವು ಖಂಡಿತವಾಗಿ ಆ ಎರಡೂ ಯಾವುದೇ ಹಾಗಿಲ್ಲ.

27
00:01:33,000 --> 00:01:38,000
ನೀವು ಹೇಗೆ valgrind ಬಳಸುತ್ತಾರೆಯೇ?

28
00:01:38,000 --> 00:01:42,000
ನೀವು ಹೇಗೆ valgrind ಬಳಸುತ್ತಾರೆಯೇ?

29
00:01:42,000 --> 00:01:45,000
>> ಇದು ಒಂದು ಸಾಮಾನ್ಯ ಪ್ರಶ್ನೆ ಇಲ್ಲಿದೆ

30
00:01:45,000 --> 00:01:49,000
ರೀತಿಯ ಚಾಲನೆ ಮತ್ತು ಔಟ್ಪುಟ್ ನೋಡಲು.

31
00:01:49,000 --> 00:01:51,000
ಔಟ್ಪುಟ್ ಬಾರಿ ಬಹಳಷ್ಟು ಸುಲಭವಾಗಿ ಇದೆ.

32
00:01:51,000 --> 00:01:54,000
ನೀವು ಕೆಲವು ಭಯಾನಕ ತಪ್ಪು ವಿಷಯ ಹೊಂದಿದ್ದರೆ ವಿನೋದ ದೋಷಗಳು ಇಲ್ಲ

33
00:01:54,000 --> 00:01:59,000
ಒಂದು ಆವರ್ತನದಲ್ಲಿ ನಡೆಯುತ್ತಿದೆ, ನಂತರ ಅಂತಿಮವಾಗಿ ", ವೇ ಹಲವಾರು ದೋಷಗಳನ್ನು ಹೇಳುವುದಿಲ್ಲ.

34
00:01:59,000 --> 00:02:03,000
ನಾನು ಈಗ ಎಣಿಸುವ ನಿಲ್ಲಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ. "

35
00:02:03,000 --> 00:02:08,000
ಇದು ಮೂಲತಃ ನೀವು ಬಿಡಿಸಿ ಅವುಗಳ ಗ್ರಾಂಥಿಕ ಔಟ್ಪುಟ್ ಇಲ್ಲಿದೆ.

36
00:02:08,000 --> 00:02:13,000
ಕೊನೆಯಲ್ಲಿ, ಇದು, ನೀವು ಯಾವುದೇ ಮೆಮೊರಿ ಸೋರುವಿಕೆ ತಿಳಿಸುವರು

37
00:02:13,000 --> 00:02:16,000
ಉಪಯುಕ್ತ ಎಷ್ಟು ಬ್ಲಾಕ್ಗಳನ್ನು, ಮಾಡಬಹುದು ಏಕೆಂದರೆ

38
00:02:16,000 --> 00:02:20,000
ಒಂದು ಬ್ಲಾಕ್ unfreed ಇದ್ದರೆ, ನಂತರ ಅದನ್ನು ಪಡೆಯುವ ಸಾಮಾನ್ಯವಾಗಿ ಸುಲಭ

39
00:02:20,000 --> 00:02:23,000
1,000 ಬ್ಲಾಕ್ಗಳನ್ನು unfreed ಹೆಚ್ಚು.

40
00:02:23,000 --> 00:02:26,000
Unfreed 1,000 ಬ್ಲಾಕ್ಗಳನ್ನು ಬಹುಶಃ ನೀವು ಮುಕ್ತಗೊಳಿಸಿದ ಇಲ್ಲ ಅರ್ಥ

41
00:02:26,000 --> 00:02:30,000
ಸೂಕ್ತವಾಗಿ ಅಥವಾ ಏನಾದರೂ ನಿಮ್ಮ ಲಿಂಕ್ ಪಟ್ಟಿಗಳು.

42
00:02:30,000 --> 00:02:32,000
ಆ valgrind ನ.

43
00:02:32,000 --> 00:02:35,000
>> ಈಗ ನಾವು, ಪ್ರಶ್ನೆಗಳನ್ನು ನಮ್ಮ ವಿಭಾಗ ಹೊಂದಿವೆ

44
00:02:35,000 --> 00:02:38,000
ನೀವು ಡೌನ್ಲೋಡ್ ಅಗತ್ಯವಿಲ್ಲ.

45
00:02:38,000 --> 00:02:41,000
ನೀವು ನನ್ನ ಹೆಸರನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ ಮತ್ತು ಸ್ಥಳದಲ್ಲಿ ಅವುಗಳನ್ನು ಬರಬಹುದು.

46
00:02:41,000 --> 00:02:44,000
ಈಗ ನನ್ನ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡಿ.

47
00:02:44,000 --> 00:02:46,000
ಪರಿಷ್ಕರಣೆ 1 ನಾವು ಮೊದಲ ಮಾಡುತ್ತಿರುವುದು ಇದು ಸ್ಟಾಕ್, ಎಂದು ಕಾಣಿಸುತ್ತದೆ.

48
00:02:46,000 --> 00:02:55,000
ಪರಿಷ್ಕರಣೆ 2 ಕ್ಯೂ ಇರುತ್ತದೆ, ಮತ್ತು ಪುನರಾವರ್ತನಾ 3 ಏಕಸ್ವರೂಪದಲ್ಲಿ ಲಿಂಕ್ ಪಟ್ಟಿ ಇರುತ್ತದೆ.

49
00:02:55,000 --> 00:02:58,000
ನಮ್ಮ ಸ್ಟಾಕ್ ಜೊತೆಗೆ ಪ್ರಾರಂಭ.

50
00:02:58,000 --> 00:03:02,000
ಇಲ್ಲಿ ಹೇಳುವಂತೆ, ಒಂದು ಸ್ಟಾಕ್, ಮೂಲಭೂತ ಒಂದಾಗಿದೆ

51
00:03:02,000 --> 00:03:07,000
ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದ ಮೂಲಭೂತ ಅಕ್ಷಾಂಶ ರಚನೆಗಳು.

52
00:03:07,000 --> 00:03:11,000
ಅತ್ಯಂತ ಪಕ್ಕಾ ಉದಾಹರಣೆಯಾಗಿದೆ

53
00:03:11,000 --> 00:03:13,000
ಊಟದ ಪ್ರಾಂಗಣದಲ್ಲಿ ಟ್ರೇಗಳು ಸ್ಟಾಕ್.

54
00:03:13,000 --> 00:03:16,000
ನೀವು ಸ್ಟಾಕ್ ಜಾರಿಗೊಳಿಸಲಾಗಿದೆ ಮಾಡಿದಾಗ ಇದು, ಮೂಲತಃ ಇಲ್ಲಿದೆ

55
00:03:16,000 --> 00:03:20,000
ಯಾರಾದರೂ, ಹೇಳಲು ಹೋಗುತ್ತದೆ "ಟ್ರೇನಲ್ಲಿ ಒಂದು ಸ್ಟಾಕ್ ನಂತಹ, ಓ."

56
00:03:20,000 --> 00:03:22,000
ನೀವು ಟ್ರೇಗಳು ಅಪ್ ಬಣವೆ.

57
00:03:22,000 --> 00:03:24,000
ನಂತರ ನೀವು ಒಂದು ಟ್ರೇ ಎಳೆಯಲು ಹೋಗಿ,

58
00:03:24,000 --> 00:03:31,000
ಎಳೆದ ಪ್ರಕಟಗೊಳ್ಳಲಿದೆ ಎಂದು ಮೊದಲ ಟ್ರೇ ಸ್ಟಾಕ್ ಸೇರಿಸಲಾಗಿತ್ತು ಕೊನೆಯ ಒಂದಾಗಿದೆ.

59
00:03:31,000 --> 00:03:34,000
ಇದು ರೀತಿಯ ಸ್ಟ್ಯಾಕ್ ಇಲ್ಲಿಗೆ ಹೇಳುತ್ತಾರೆ

60
00:03:34,000 --> 00:03:37,000
ನಾವು ಸ್ಟಾಕ್ ಎಂಬ ಸ್ಮರಣೆ ಭಾಗವನ್ನು ಹೊಂದಿರುತ್ತವೆ.

61
00:03:37,000 --> 00:03:40,000
ಮತ್ತು ಏಕೆ ಸ್ಟಾಕ್ ಕರೆಯಲಾಗುತ್ತದೆ?

62
00:03:40,000 --> 00:03:42,000
>> ಏಕೆಂದರೆ ಒಂದು ಸ್ಟಾಕ್ ಅಕ್ಷಾಂಶ ರಚನೆಯಾಗಿದೆ,

63
00:03:42,000 --> 00:03:46,000
ಇದು, ಸ್ಟಾಕ್ ಮೇಲೆ ಸ್ಟಾಕ್ ಚೌಕಟ್ಟುಗಳು ತಳ್ಳುತ್ತದೆ ಮತ್ತು ಪಾಪ್ಸ್

64
00:03:46,000 --> 00:03:53,000
ಸ್ಟಾಕ್ ಚೌಕಟ್ಟುಗಳು ಕ್ರಿಯೆಯ ನಿರ್ದಿಷ್ಟ ಕಾಲ್ ಹಾಗೆ ಅಲ್ಲಿ ಇವೆ.

65
00:03:53,000 --> 00:03:57,000
ಮತ್ತು ಒಂದು ಸ್ಟಾಕ್ ರೀತಿಯಲ್ಲಿ ನೀವು ಯಾವಾಗಲೂ ಮರಳಲು ಹೊಂದಿರುತ್ತದೆ

66
00:03:57,000 --> 00:04:03,000
ಒಂದು ಕಾರ್ಯ ಕರೆ ನೀವು ಮತ್ತೆ ಕಡಿಮೆ ಸ್ಟಾಕ್ ಚೌಕಟ್ಟುಗಳು ಕೆಳಭಾಗಕ್ಕೆ ಪಡೆಯಲು ಮೊದಲು.

67
00:04:03,000 --> 00:04:08,000
ನೀವು ಮುಖ್ಯ ಕರೆ foo ಕರೆ ಬಾರ್ ಮತ್ತು ಮುಖ್ಯ ನೇರವಾಗಿ ಗೆ ಬಾರ್ ರಿಟರ್ನ್ ಹೊಂದುವಂತಿಲ್ಲ.

68
00:04:08,000 --> 00:04:14,000
ಯಾವಾಗಲೂ ತಳ್ಳುವುದು ಮತ್ತು ಪಾಪಿಂಗ್ ಸರಿಯಾದ ಸ್ಟಾಕ್ ಅನುಸರಿಸಲು ಅವರಲ್ಲಿದೆ.

69
00:04:14,000 --> 00:04:18,000
ಎರಡು ಕಾರ್ಯಾಚರಣೆಗಳು, ನಾನು ಹೇಳಿದ ಹಾಗೆ, ಪುಶ್ ಮತ್ತು ಪಾಪ್ ಇವೆ.

70
00:04:18,000 --> 00:04:20,000
ಆ ಸಾರ್ವತ್ರಿಕ ಪದಗಳು.

71
00:04:20,000 --> 00:04:26,000
ನೀವು ರಾಶಿಯನ್ನು ಯಾವುದೇ ಪರಿಭಾಷೆಯಲ್ಲಿ ಪುಶ್ ಮತ್ತು ಪಾಪ್ ತಿಳಿಯಬೇಕಿದೆ.

72
00:04:26,000 --> 00:04:28,000
ನಾವು ಸಾಲುಗಳನ್ನು ವಿವಿಧ ರೀತಿಯ ಅವು ನೋಡುತ್ತಾರೆ.

73
00:04:28,000 --> 00:04:32,000
ಇದು ನಿಜವಾಗಿಯೂ ಒಂದು ಸಾರ್ವತ್ರಿಕ ಪದವನ್ನು ಹೊಂದಿಲ್ಲ, ಆದರೆ ಪುಶ್ ಮತ್ತು ಪಾಪ್ ರಾಶಿಯನ್ನು ಸಾರ್ವತ್ರಿಕ ಇವೆ.

74
00:04:32,000 --> 00:04:34,000
ಪುಶ್ ಕೇವಲ ಸ್ಟಾಕ್ ಇಡಲಾಗುತ್ತದೆ.

75
00:04:34,000 --> 00:04:37,000
ಪಾಪ್ ಸ್ಟಾಕ್ ತೆಗೆದುಕೊಳ್ಳಲು ಹೊಂದಿದೆ.

76
00:04:37,000 --> 00:04:43,000
ಮತ್ತು ನಾವು ನಮ್ಮ typedef struct ಸ್ಟಾಕ್ ಹೊಂದಿವೆ ಇಲ್ಲಿ ನೋಡಿ

77
00:04:43,000 --> 00:04:46,000
ಆದ್ದರಿಂದ ನಾವು ಚಾರ್ ** ತಂತುಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ.

78
00:04:46,000 --> 00:04:51,000
ಯಾವುದೇ ** ಗಾಬರಿಯಾಗಿ ಇರುವುದಿಲ್ಲ.

79
00:04:51,000 --> 00:04:54,000
ಈ ತಂತಿಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಅಷ್ಟೇ ಆಗಿ ಕೊನೆಗೊಳ್ಳುತ್ತಿದೆ ಹಾಕುತ್ತದೆ

80
00:04:54,000 --> 00:04:58,000
ಪಾತ್ರಗಳಿಗೆ ಪಾಯಿಂಟರ್ಗಳ ಅಥವಾ ರಚನೆಯ ಅಲ್ಲಿ

81
00:04:58,000 --> 00:05:00,000
ಪಾತ್ರಗಳು ರೀತಿಯು ತಂತಿಗಳನ್ನು ಒಲವು.

82
00:05:00,000 --> 00:05:05,000
ಇದು ತಂತಿಗಳನ್ನು ಎಂದು ಹೊಂದಿಲ್ಲ, ಆದರೆ ಇಲ್ಲಿ ಅವರು ತಂತಿಗಳನ್ನು ಎಂದು ನೀನು.

83
00:05:05,000 --> 00:05:08,000
>> ನಾವು ತಂತಿಗಳ ಒಂದು ಸರಣಿ.

84
00:05:08,000 --> 00:05:14,000
ನಾವು ಸ್ಟಾಕ್ ಪ್ರಸ್ತುತ ಎಷ್ಟು ಅಂಶಗಳು ಪ್ರತಿನಿಧಿಸುವ ಒಂದು ಗಾತ್ರವನ್ನು ಹೊಂದಿರುತ್ತವೆ

85
00:05:14,000 --> 00:05:19,000
ನಂತರ ನಾವು ಸ್ಟಾಕ್ ಮೇಲೆ ಎಷ್ಟು ಅಂಶಗಳು ಇರಬಹುದು ಇದು ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿರುತ್ತವೆ.

86
00:05:19,000 --> 00:05:22,000
ಸಾಮರ್ಥ್ಯ, 1 ಹೆಚ್ಚಿನ ಏನೋ ಎಂದು ಆಫ್ ಪ್ರಾರಂಭಿಸಬೇಕು

87
00:05:22,000 --> 00:05:27,000
ಆದರೆ ಗಾತ್ರ 0 ಎಂದು ಆಫ್ ಆರಂಭಿಸಲು ಹೋಗುತ್ತದೆ.

88
00:05:27,000 --> 00:05:36,000
ಈಗ, ನೀವು ಸ್ಟಾಕ್ ನಗರದ ಮೂರು ಬೇರೆ ವಿಧಿಗಳಿವೆ.

89
00:05:36,000 --> 00:05:39,000
ಜೊತೆಗೆ, ಅಲ್ಲಿ ಬಹುಶಃ ಹೆಚ್ಚು, ಆದರೆ ಎರಡು ಪ್ರಮುಖ ವಿಧಾನಗಳಿವೆ

90
00:05:39,000 --> 00:05:43,000
ನೀವು ಒಂದು ವ್ಯೂಹವನ್ನು ಬಳಸಿಕೊಂಡು ಅದನ್ನು ಬಳಸಿಕೊಂಡು, ಅಥವಾ ನೀವು ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ಉಪಯೋಗಿಸಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸಾಧ್ಯ.

91
00:05:43,000 --> 00:05:48,000
ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು ರೀತಿಯ ರಿಂದ ರಾಶಿಯನ್ನು ಮಾಡಲು ಅಲ್ಪ.

92
00:05:48,000 --> 00:05:51,000
ಇದು, ಸಂಬಂಧಿತ ಪಟ್ಟಿಗಳನ್ನು ಬಳಸಿ ಸ್ಟಾಕ್ ಮಾಡಲು ಬಹಳ ಸುಲಭ

93
00:05:51,000 --> 00:05:55,000
ಇಲ್ಲಿ, ನಾವು, ಸರಣಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಟಾಕ್ ಮಾಡಲು ನೀನು

94
00:05:55,000 --> 00:05:59,000
ತದನಂತರ ಸರಣಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು, ನೀವು ಅದರ ಬಗ್ಗೆ ಯೋಚಿಸಲು ಎರಡು ಮಾರ್ಗಗಳಿವೆ ಸಹ ಇಲ್ಲ.

95
00:05:59,000 --> 00:06:01,000
ಮೊದಲು, ನಾನು ಹೇಳಿದ ನಾವು, ಸ್ಟಾಕ್ ಒಂದು ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿವೆ

96
00:06:01,000 --> 00:06:04,000
ಆದ್ದರಿಂದ ನಾವು ಸ್ಟಾಕ್ ಮೇಲೆ ಅಂಶ ಹೊಂದುವುದು.

97
00:06:04,000 --> 00:06:09,000
>> ಇದು ಆಗಬಹುದು ಒಂದು ರೀತಿಯಲ್ಲಿ ತಕ್ಷಣ ನೀವು 10 ಅಂಶಗಳನ್ನು ಹಿಟ್ ಎಂದು, ನಂತರ ನೀವು ಮುಗಿಸಿದ್ದೀರಿ ಹೊಂದಿದೆ.

98
00:06:09,000 --> 00:06:13,000
ನೀವು ಜಗತ್ತಿನ 10 ವಸ್ತುಗಳ ಬೌಂಡ್ ಒಂದು ಮೇಲ್ ಎಂದು ಪರಿಚಯವಿರಬಹುದಾದ

99
00:06:13,000 --> 00:06:16,000
ನೀವು, ನಿಮ್ಮ ಸ್ಟಾಕ್ ಹೆಚ್ಚು 10 ವಿಷಯಗಳನ್ನು ಎಂದಿಗೂ ಆ

100
00:06:16,000 --> 00:06:20,000
ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಿಮ್ಮ ಸ್ಟಾಕ್ ಗಾತ್ರವನ್ನು ಬೌಂಡ್ ಒಂದು ಮೇಲ್ ಹೊಂದಬಹುದು.

101
00:06:20,000 --> 00:06:23,000
ಅಥವಾ ನೀವು ನಿಮ್ಮ ಸ್ಟಾಕ್ ಮಿತಿ ಎಂದು ತೋರಿಸಬಹುದಿತ್ತು

102
00:06:23,000 --> 00:06:27,000
ನೀವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಮಾಡುತ್ತಿರುವುದು ಆದರೆ, ಆ, ಪ್ರತಿಯೊಂದು ಬಾರಿ 10 ಅಂಶಗಳನ್ನು ಹಿಟ್ ಅರ್ಥ

103
00:06:27,000 --> 00:06:29,000
ನೀವು 20 ಅಂಶಗಳನ್ನು ಹೊಡೆದಾಗ ನಂತರ ನೀವು, 20 ಅಂಶಗಳ ಬೆಳೆಯುತ್ತದೆ ಮಾಡಲಿಕ್ಕೆ, ಮತ್ತು ನೀವು

104
00:06:29,000 --> 00:06:33,000
ನೀವು 30 ಅಂಶಗಳನ್ನು ಅಥವಾ 40 ಅಂಶಗಳನ್ನು ನಿಮ್ಮ ರಚನೆಯ ಬೆಳೆಯಲು ಹೊಂದಿರುವ ನೀನು.

105
00:06:33,000 --> 00:06:37,000
ನಾವು ಇಲ್ಲಿ ಹೋಗಿ ಏನನ್ನು ಇದು ಸಾಮರ್ಥ್ಯವನ್ನು ಹೆಚ್ಚಿಸುವ ಅಗತ್ಯವಿದೆ ಎಂದು ನೀನು.

106
00:06:37,000 --> 00:06:40,000
ನಾವು, ನಮ್ಮ ಸ್ಟಾಕ್ ಗರಿಷ್ಠ ಗಾತ್ರವನ್ನು ತಲುಪಲು ಪ್ರತಿಯೊಂದು ಸಮಯ

107
00:06:40,000 --> 00:06:46,000
ನಾವು ಯಾರ ಮೇಲೆ ಏನೋ ಪುಶ್ ನಾವು ಸಾಮರ್ಥ್ಯ ಹೆಚ್ಚಿಸುವ ಅಗತ್ಯವಿದೆ ಎಂದು ನೀನು.

108
00:06:46,000 --> 00:06:50,000
ಇಲ್ಲಿ, ನಾವು ಪುಶ್ bool ಪುಶ್ (ಚಾರ್ * Str) ಎಂದು ಘೋಷಿಸಿದರು.

109
00:06:50,000 --> 00:06:54,000
ಚಾರ್ * Str, ನಾವು ಸ್ಟಾಕ್ ಮೇಲೆ ತಳ್ಳುವುದು ಎಂದು ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ

110
00:06:54,000 --> 00:06:58,000
ಮತ್ತು bool ನಾವು ಯಶಸ್ವಿಯಾದರು ಅಥವಾ ವಿಫಲವಾಗಿದೆ ಎಂಬುದನ್ನು ಹೇಳುತ್ತದೆ.

111
00:06:58,000 --> 00:07:00,000
>> ಹೇಗೆ ನಾವು ವಿಫಲಗೊಳ್ಳಬಹುದು?

112
00:07:00,000 --> 00:07:04,000
ನೀವು ನಗರದ ಏಕೈಕ ಪರಿಸ್ಥಿತಿ ಏನು

113
00:07:04,000 --> 00:07:07,000
ನಾವು ತಪ್ಪು ಹಿಂದಿರುಗಿಸಬೇಕಾಗುತ್ತದೆ ಅಲ್ಲಿ?

114
00:07:07,000 --> 00:07:09,000
ಹೌದು.

115
00:07:09,000 --> 00:07:12,000
[ವಿದ್ಯಾರ್ಥಿ] ಇದು ಪೂರ್ಣ ಮತ್ತು ನಾವು ಸುತ್ತುವರಿದಿದೆ ಅನುಷ್ಠಾನ ಬಳಸುತ್ತಿದ್ದರೆ.

116
00:07:12,000 --> 00:07:17,000
ಹೌದು, ಆದ್ದರಿಂದ ನಾವು ಹೇಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲು-ಅವನು ಉತ್ತರ

117
00:07:17,000 --> 00:07:23,000
ಪೂರ್ಣ ಮತ್ತು ನಾವು ಪರಿಮಿತಿಗೊಳಪಟ್ಟ ಅನುಷ್ಠಾನ ಬಳಸುತ್ತಿದ್ದರೆ.

118
00:07:23,000 --> 00:07:26,000
ನಾವು ಖಂಡಿತವಾಗಿಯೂ ತಪ್ಪು ಹಿಂತಿರುಗುವುದು.

119
00:07:26,000 --> 00:07:31,000
ತಕ್ಷಣ ನಾವು ಶ್ರೇಣಿಯಲ್ಲಿನ 10 ವಿಷಯಗಳನ್ನು ಹಿಟ್ ಎಂದು, ನಾವು 11 ಹೊಂದಿಕೊಳ್ಳುತ್ತವೆ ಸಾಧ್ಯವಿಲ್ಲ, ನಾವು ತಪ್ಪು ಹಿಂತಿರುಗಿ ಆದ್ದರಿಂದ.

120
00:07:31,000 --> 00:07:32,000
ಇದು ಮಿತಿ ಏನು? ಹೌದು.

121
00:07:32,000 --> 00:07:38,000
ನೀವು ಕೆಲವು ಕಾರಣಕ್ಕಾಗಿ ಶ್ರೇಣಿಯನ್ನು ವಿಸ್ತರಿಸಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ ವೇಳೆ.

122
00:07:38,000 --> 00:07:43,000
ಹೌದು, ಆದ್ದರಿಂದ ಮೆಮೊರಿ, ಸೀಮಿತ ಸಂಪನ್ಮೂಲವಾಗಿದೆ

123
00:07:43,000 --> 00:07:51,000
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾವು ಮತ್ತೆ ಮತ್ತು ಮೇಲೆ ಸ್ಟಾಕ್ ಮೇಲೆ ತಳ್ಳುವುದು ವಸ್ತುಗಳು ಇದ್ದರೆ,

124
00:07:51,000 --> 00:07:54,000
ನಾವು ಹೊಂದಿಕೊಳ್ಳಲು ದೊಡ್ಡ ವ್ಯೂಹ ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ನಿಯೋಜಿಸಿ ಎಂದು ನೀನು

125
00:07:54,000 --> 00:07:59,000
ನಾವು ಬಳಸುತ್ತಿರುವ ದೊಡ್ಡ ಸಾಮರ್ಥ್ಯ, ಮತ್ತು malloc ಅಥವಾ ಯಾವುದೇ ತಪ್ಪು ಮರಳಲು ಹೋಗುತ್ತದೆ.

126
00:07:59,000 --> 00:08:02,000
ಅಲ್ಲದೆ, malloc ಶೂನ್ಯ ಹಿಂತಿರುಗುವುದು.

127
00:08:02,000 --> 00:08:05,000
>> ನೆನಪಿಡಿ, ನೀವು ಎಂದಾದರೂ malloc ಕರೆ ಪ್ರತಿಯೊಂದು ಸಮಯ, ನೀವು ನೋಡಲು ತಪಾಸಣೆ ಮಾಡಬೇಕು ಅದು

128
00:08:05,000 --> 00:08:12,000
ಶೂನ್ಯ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಅಥವಾ ಯಾವುದೇ ಒಂದು ಸರಿಯಾಗಿವೆ ವ್ಯವಕಲನವಾಗುತ್ತದೆ.

129
00:08:12,000 --> 00:08:17,000
ನಾವು ಒಂದು ಅಸೀಮ ಸ್ಟಾಕ್ ಬೇಕು ಏಕೆಂದರೆ,

130
00:08:17,000 --> 00:08:21,000
ನಾವು ಪ್ರಯತ್ನಿಸಿ ನಾವು ತಪ್ಪು ಮರಳುವುದಾಗಿ ಎಂದು ನೀನು ಮಾತ್ರ ಸಂದರ್ಭದಲ್ಲಿ

131
00:08:21,000 --> 00:08:26,000
ಸಾಮರ್ಥ್ಯ ಮತ್ತು malloc ಹೆಚ್ಚಿಸಲು ಅಥವಾ ಸುಳ್ಳು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಯಾವುದೇ.

132
00:08:26,000 --> 00:08:30,000
ನಂತರ ಪಾಪ್, ಆರ್ಗುಮೆಂಟುಗಳಿಲ್ಲದೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

133
00:08:30,000 --> 00:08:37,000
ಮತ್ತು ಸ್ಟಾಕ್ ಮೇಲೆ ಎಂದು ಸ್ಟ್ರಿಂಗ್ ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

134
00:08:37,000 --> 00:08:41,000
ಏನೇ ಇತ್ತೀಚೆಗೆ ಸ್ಟಾಕ್ ಮೇಲೆ ಹಾಕಲಾಯಿತು, ಹಿಂದಿರುಗಿದ ಯಾವ ಪಾಪ್

135
00:08:41,000 --> 00:08:44,000
ಮತ್ತು ಇದು ಸ್ಟಾಕ್ ಇದು ತೆಗೆದುಹಾಕುತ್ತದೆ.

136
00:08:44,000 --> 00:08:50,000
ಮತ್ತು ಸ್ಟಾಕ್ ಮೇಲೆ ಏನೂ ಇಲ್ಲ ಅದು ಶೂನ್ಯ ಮರಳಿಸುವ ಗಮನಿಸುವುದಿಲ್ಲ.

137
00:08:50,000 --> 00:08:53,000
ಇದು ಸ್ಟಾಕ್ ಖಾಲಿ ಎಂದು ಯಾವಾಗಲೂ ಸಾಧ್ಯವಿದೆ.

138
00:08:53,000 --> 00:08:55,000
ಜಾವಾದಲ್ಲಿ, ಆ, ಅಥವಾ ಇತರ ಭಾಷೆಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ ಬಳಸುತ್ತಿದ್ದರೆ,

139
00:08:55,000 --> 00:09:01,000
ಖಾಲಿ ಸ್ಟಾಕ್ ಪಾಪ್ ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಹೊರತುಪಡಿಸಿ ಅಥವಾ ಏನಾದರೂ ಕಾರಣವಾಗಬಹುದು.

140
00:09:01,000 --> 00:09:09,000
>> ಆದರೆ ಸಿ, ಶೂನ್ಯ ಈ ಸಮಸ್ಯೆಗಳನ್ನು ನಿಭಾಯಿಸಲು ಹೇಗೆ ಸಂದರ್ಭಗಳಲ್ಲಿ ಸಾಕಷ್ಟು ರೀತಿಯ.

141
00:09:09,000 --> 00:09:13,000
ಶೂನ್ಯ ಮರಳಿದ ನಾವು ಸ್ಟಾಕ್ ಖಾಲಿ ಎಂದು ಸೂಚಿಸುತ್ತದೆ ಎಂದು ನೀನು ಹೇಗೆ.

142
00:09:13,000 --> 00:09:16,000
ನಾವು, ನಿಮ್ಮ ಸ್ಟ್ಯಾಕ್ನ ಕಾರ್ಯತ್ಮಕತೆಯನ್ನು ಪರೀಕ್ಷಿಸಲು ಎಂದು ಕೋಡ್ ಒದಗಿಸಲಾದ

143
00:09:16,000 --> 00:09:19,000
ಪುಶ್ ಮತ್ತು ಪಾಪ್ ಜಾರಿಗೆ.

144
00:09:19,000 --> 00:09:23,000
ಈ ಕೋಡ್ ಒಂದು ಸಾಕಷ್ಟು ಆಗುವುದಿಲ್ಲ.

145
00:09:23,000 --> 00:09:40,000
ಅದನ್ನೇ ತಿನ್ನುವೆ-ವಾಸ್ತವವಾಗಿ, ನಾವು ಹಾಗೆ ಮೊದಲು, ಸುಳಿವನ್ನು, ಸುಳಿವನ್ನು-

146
00:09:40,000 --> 00:09:44,000
ನೀವು ಕಾಣಬಹುದು ಇದ್ದರೆ, malloc ಮಾತ್ರ ಕಾರ್ಯ ಅಲ್ಲ

147
00:09:44,000 --> 00:09:47,000
ಎಂದು ನೀವು ರಾಶಿ ಮೆಮೊರಿಯ ಗೊತ್ತುಪಡಿಸುತ್ತದೆ.

148
00:09:47,000 --> 00:09:51,000
Alloc ಕಾರ್ಯಗಳನ್ನು ಒಂದು ಕುಟುಂಬ ಇವೆ.

149
00:09:51,000 --> 00:09:53,000
ಮೊದಲ ನೀವು ಬಳಸಲಾಗುತ್ತದೆ ನೀವು ಯಾವ malloc, ಆಗಿದೆ.

150
00:09:53,000 --> 00:09:56,000
ನಂತರ malloc ಅದೇ ಕೆಲಸವನ್ನು ಮಾಡುತ್ತದೆ ಇದು calloc, ಇಲ್ಲ

151
00:09:56,000 --> 00:09:59,000
ಆದರೆ ನೀವು ಎಲ್ಲವನ್ನೂ ಔಟ್ ಸೊನ್ನೆಗೆ ಕಾಣಿಸುತ್ತದೆ.

152
00:09:59,000 --> 00:10:04,000
ನೀವು ಎಂದಾದರೂ ಏನಾದರೂ mallocing ನಂತರ ಶೂನ್ಯ ಎಲ್ಲವನ್ನೂ ಸೆಟ್ ಬಯಸಿದರು ನೀವು

153
00:10:04,000 --> 00:10:06,000
ಬದಲಿಗೆ ನೀವು ಬರೆಯುವ ಮೊದಲ ಸ್ಥಾನದಲ್ಲಿ calloc ಬಳಸಬೇಕಿತ್ತು

154
00:10:06,000 --> 00:10:09,000
ಮೆಮೊರಿ ಸಂಪೂರ್ಣ ಬ್ಲಾಕ್ ಔಟ್ ಸೊನ್ನೆಗೆ ಲೂಪ್ ಒಂದು.

155
00:10:09,000 --> 00:10:15,000
>> Realloc, malloc ಹಾಗೆ ಹಾಗೂ ವಿಶೇಷ ಸಂದರ್ಭಗಳಲ್ಲಿ ಬಹಳಷ್ಟು ಹೊಂದಿದೆ

156
00:10:15,000 --> 00:10:19,000
ಆದರೆ ಮೂಲತಃ realloc ಏನು ಆಗಿದೆ

157
00:10:19,000 --> 00:10:24,000
ಇದು ಈಗಾಗಲೇ ಹಂಚಲಾಗಿತ್ತು ಎಂದು ಪಾಯಿಂಟರ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

158
00:10:24,000 --> 00:10:27,000
Realloc ನೀವು ಇಲ್ಲಿ ಗಮನ ಪಾವತಿ ಬೇಕಿರುವ ಕಾರ್ಯ.

159
00:10:27,000 --> 00:10:31,000
ಇದು ಈಗಾಗಲೇ malloc ಹಿಂದಿರುಗಿದ ಎಂದು ಒಂದು ಪಾಯಿಂಟರ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

160
00:10:31,000 --> 00:10:35,000
ಲೆಟ್ಸ್ ನೀವು malloc 10 ಬೈಟ್ಗಳು ಒಂದು ಪಾಯಿಂಟರ್ ಮನವಿ ಹೇಳುತ್ತಾರೆ.

161
00:10:35,000 --> 00:10:38,000
ನಂತರ ನೀವು 20 ಬೈಟ್ಗಳು ಬಯಸಿದ್ದರು ಅರ್ಥ

162
00:10:38,000 --> 00:10:42,000
ಆದ್ದರಿಂದ, 20 ಬೈಟ್ಗಳು ಆ ಪಾಯಿಂಟರ್ ಮೇಲೆ realloc ಕರೆ

163
00:10:42,000 --> 00:10:47,000
ಮತ್ತು realloc ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಎಲ್ಲವನ್ನೂ ಲಿಂಕುಗಳು ಕಾಣಿಸುತ್ತದೆ.

164
00:10:47,000 --> 00:10:51,000
ನೀವು ನಾನು 10 ಬೈಟ್ಗಳು ಒಂದು ಬ್ಲಾಕ್ ಮಾಡಿದಂತೆ ಮತ್ತೆ malloc ಕರೆಯಲಾಗುತ್ತದೆ. ವೇಳೆ

165
00:10:51,000 --> 00:10:53,000
ಈಗ ನಾನು 20 ಬೈಟ್ಗಳು ಒಂದು ಬ್ಲಾಕ್, ಅಗತ್ಯವಿದೆ

166
00:10:53,000 --> 00:10:58,000
ಆದ್ದರಿಂದ ನಾನು malloc 20 ಬೈಟ್ಗಳು, ಆಗ ನಾನು ಕೈಯಿಂದ ಮೊದಲನೆಯದಾಗಿ 10 ಬೈಟ್ಗಳು ಲಿಂಕುಗಳು ಮಾಡಬೇಕು

167
00:10:58,000 --> 00:11:01,000
ಮೊದಲನೆಯದಾಗಿ ಎರಡನೇ ವಿಷಯ ಆಗಿ ತದನಂತರ ಉಚಿತ.

168
00:11:01,000 --> 00:11:04,000
Realloc ನೀವು ಆ ನಿರ್ವಹಿಸುವಿರಿ.

169
00:11:04,000 --> 00:11:11,000
>> ಸಹಿ, ಶೂನ್ಯವನ್ನು * ಎಂದು ಹೋಗುತ್ತದೆ ಗಮನಿಸಿ

170
00:11:11,000 --> 00:11:15,000
ಇದು ಕೇವಲ, ಮೆಮೊರಿ ಬ್ಲಾಕ್ಗೆ ಒಂದು ಪಾಯಿಂಟರ್ ಮರಳಲಿದ್ದಾರೆ

171
00:11:15,000 --> 00:11:17,000
ನಂತರ ಅನೂರ್ಜಿತ * ptr.

172
00:11:17,000 --> 00:11:22,000
ನೀವು ಒಂದು ಜೆನೆರಿಕ್ ಪಾಯಿಂಟರ್ ಮಾಹಿತಿ ಅನೂರ್ಜಿತ * ನಗರದ.

173
00:11:22,000 --> 00:11:27,000
ಸಾಮಾನ್ಯವಾಗಿ, ನೀವು, ಶೂನ್ಯವನ್ನು * ವ್ಯವಹರಿಸಲು ಇಲ್ಲ

174
00:11:27,000 --> 00:11:30,000
ಆದರೆ malloc ಒಂದು ಶೂನ್ಯವನ್ನು * ಹಿಂದಿರುಗಿದ, ಮತ್ತು ಅದು ಕೇವಲ ರೀತಿಯ ಬಳಕೆಯ

175
00:11:30,000 --> 00:11:34,000
ಈ ವಾಸ್ತವವಾಗಿ ಚಾರ್ * ಎಂದು ಹೋಗುತ್ತದೆ.

176
00:11:34,000 --> 00:11:37,000
malloc ನೀಡಿದ ಎಂದು ಹಿಂದಿನ ಅನೂರ್ಜಿತ *

177
00:11:37,000 --> 00:11:41,000
ಈಗ ಗಾತ್ರ ನಂತರ realloc ರವಾನಿಸಬಹುದು ಹೋಗುವ, ಮತ್ತು

178
00:11:41,000 --> 00:11:49,000
ನೀವು ನಿಯೋಜಿಸಿ ಬಯಸುವ ಬೈಟ್ಗಳು ಹೊಸ ಸಂಖ್ಯೆ, ನಿಮ್ಮ ಹೊಸ ಸಾಮರ್ಥ್ಯ ಹೊಂದಿದೆ.

179
00:11:49,000 --> 00:11:57,000
ನಾನು ನೀವು ಒಂದೆರಡು ನಿಮಿಷಗಳ ಸಮಯ ನೀಡಿ, ಮತ್ತು ನಮ್ಮ ಜಾಗದಲ್ಲಿ ಅದನ್ನು ಮಾಡುತ್ತೇನೆ.

180
00:11:57,000 --> 00:12:02,000
ಪರಿಷ್ಕರಣೆ 1 ಆರಂಭಿಸಿ.

181
00:12:16,000 --> 00:12:21,000
ನಾನು, ಪುಷ್ ಅನುಷ್ಠಾನಕ್ಕೆ ಸಾಕಷ್ಟು ಸಮಯ ಸುಮಾರು ನಂತರ ಆಶಾದಾಯಕವಾಗಿ ನೀವು ನಿಲ್ಲಿಸಲು ವಿಲ್

182
00:12:21,000 --> 00:12:24,000
ತದನಂತರ ನಾನು ಪಾಪ್ ಮಾಡಲು ಮತ್ತೊಂದು ಬ್ರೇಕ್ ನೀಡುತ್ತೇನೆ.

183
00:12:24,000 --> 00:12:27,000
ಆದರೆ ನಿಜವಾಗಿಯೂ ಅದು ಸಾಕಷ್ಟು ಕೋಡ್ ಅಲ್ಲ.

184
00:12:27,000 --> 00:12:35,000
ಅತ್ಯಂತ ಕೋಡ್ ವಿಸ್ತರಣೆಗೆ, ಬಹುಶಃ ವಿಸ್ತರಿಸುವ ವಿಷಯವನ್ನು ಹೊಂದಿದೆ.

185
00:12:35,000 --> 00:12:39,000
ಸರಿ, ಸಂಪೂರ್ಣವಾಗಿ ಮಾಡಲಾಗುತ್ತದೆ ಯಾವುದೇ ಒತ್ತಡ,

186
00:12:39,000 --> 00:12:47,000
ಆದರೆ ಎಲ್ಲಿಯವರೆಗೆ ನೀವು ಸರಿಯಾದ ಹಾದಿಯಲ್ಲಿ ಭಾವಿಸುತ್ತಾರೆ ಎಂದು, ಅದು ಒಳ್ಳೆಯದು.

187
00:12:47,000 --> 00:12:53,000
>> ಯಾರಾದರೂ ನನ್ನ ಪಡೆದುಕೊಳ್ಳಬಹುದು ಜೊತೆ ಹಾಯಾಗಿರುತ್ತೇನೆ ಯಾವುದೇ ಕೋಡ್ ಹೊಂದಿದೆ?

188
00:12:53,000 --> 00:12:59,000
ಹೌದು, ಅದನ್ನೇ ತಿನ್ನುವೆ, ಆದರೆ ಯಾರಾದರೂ ನಾನು ಬರಬಹುದು ಯಾವುದೇ ಕೋಡ್ ಹೊಂದಿದೆ?

189
00:12:59,000 --> 00:13:05,000
ಸರಿ, ನೀವು ಯಾವುದೇ, ಅದನ್ನು ಉಳಿಸಲು, ಪ್ರಾರಂಭಿಸಬಹುದು?

190
00:13:05,000 --> 00:13:09,000
ನಾನು ಯಾವಾಗಲೂ ಆ ಹಂತದ ಮರೆಯಬೇಡಿ.

191
00:13:09,000 --> 00:13:15,000
ಸರಿ, ಪುಶ್ ನೋಡಿ,

192
00:13:15,000 --> 00:13:18,000
ನಿಮ್ಮ ಕೋಡ್ ವಿವರಿಸಲು ಬಯಸುತ್ತೀರಿ?

193
00:13:18,000 --> 00:13:24,000
[ವಿದ್ಯಾರ್ಥಿ] ಎಲ್ಲಾ ಮೊದಲ, ನಾನು ಗಾತ್ರ ಹೆಚ್ಚಾಗಿದೆ.

194
00:13:24,000 --> 00:13:28,000
ನಾನು ಬಹುಶಃ ನಾನು-ಹೇಗಾದರೂ ಇರಬೇಕು ಊಹೆ, ನಾನು, ಗಾತ್ರ ಹೆಚ್ಚಳ

195
00:13:28,000 --> 00:13:31,000
ಇದು ಸಾಮರ್ಥ್ಯವನ್ನು ಕಡಿಮೆ ಇದ್ದರೆ ಮತ್ತು ನಾನು ನೋಡಿ.

196
00:13:31,000 --> 00:13:36,000
ಮತ್ತು ಸಾಮರ್ಥ್ಯ ಕಡಿಮೆ ಇದ್ದರೆ, ನಾವು ಈಗಾಗಲೇ ಹೊಂದಿರುವ ವ್ಯೂಹ ಸೇರಿಸಲು.

197
00:13:36,000 --> 00:13:42,000
ಇದು ಅಲ್ಲ, ನಾನು, 2 ಸಾಮರ್ಥ್ಯವನ್ನು ಗುಣಿಸಿ

198
00:13:42,000 --> 00:13:50,000
ನಾನು ಈಗ ಒಂದು ದೊಡ್ಡ ಸಾಮರ್ಥ್ಯ ಗಾತ್ರದೊಂದಿಗೆ ಕೆಲಸಕ್ಕೆ ತಂತಿಗಳನ್ನು ರಚನೆಯ ಪುನರ್ವಿಂಗಡಿಸು.

199
00:13:50,000 --> 00:13:55,000
ಆ ವಿಫಲವಾದಲ್ಲಿ ನಂತರ, ನಾನು ಬಳಕೆದಾರ ಹೇಳುತ್ತೇನೆ, ಸುಳ್ಳು ಹಿಂತಿರುಗಿ

200
00:13:55,000 --> 00:14:04,000
ಇದು ಉತ್ತಮ ಇದ್ದರೆ ಮತ್ತು, ನಂತರ ನಾನು ಗದ್ದೆಯನ್ನು ತಂತುವನ್ನು ಪುಟ್.

201
00:14:04,000 --> 00:14:07,000
>> [ರಾಬ್ ಬಿ] ನಾವು ಇಲ್ಲಿ ಉತ್ತಮ bitwise ಆಯೋಜಕರು ಬಳಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ

202
00:14:07,000 --> 00:14:09,000
2 ರಿಂದ ಗುಣಿಸುವುದು.

203
00:14:09,000 --> 00:14:11,000
ನೆನಪಿಡಿ, ಎಡ ಶಿಫ್ಟ್ ಯಾವಾಗಲೂ 2 x ಏರಲಿದೆ.

204
00:14:11,000 --> 00:14:15,000
ನೀವು ಅರ್ಥ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಮಾಹಿತಿ ಹಕ್ಕು ಶಿಫ್ಟ್ ಕಾಲ 2 ರಿಂದ ಭಾಗಿಸಿದಾಗ

205
00:14:15,000 --> 00:14:18,000
2 ಭಾಗಿಸಿ ಒಂದು ಪೂರ್ಣಾಂಕ ರಲ್ಲಿ 2 ರಿಂದ ಭಾಗಿಸಿ.

206
00:14:18,000 --> 00:14:20,000
ಇಲ್ಲಿ ಅಥವಾ ಅಲ್ಲಿ ಒಂದು 1 ಮೊಟಕುಗೊಳಿಸಲು ಇರಬಹುದು.

207
00:14:20,000 --> 00:14:26,000
ಆದರೆ 1 ಬಿಟ್ಟು ಶಿಫ್ಟ್ ಯಾವಾಗಲೂ, 2 x ಏರಲಿದೆ

208
00:14:26,000 --> 00:14:32,000
ನೀವು ಉಕ್ಕಿ ಪೂರ್ಣಾಂಕದ ಪರಿಧಿಯಿಂದ ಹೊರತು, ಮತ್ತು ಅದು ಸಾಧ್ಯವಿಲ್ಲ.

209
00:14:32,000 --> 00:14:34,000
ಒಂದು ಅಡ್ಡ ಕಾಮೆಂಟ್.

210
00:14:34,000 --> 00:14:39,000
ನಾನು, ಏನು ಇದು ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ಕೋಡಿಂಗ್ ಬದಲಾಯಿಸಲು ಹೋಗುತ್ತಿಲ್ಲ ಇದೆ ನೀವು

211
00:14:39,000 --> 00:14:48,000
ಆದರೆ ನಾನು ಈ ರೀತಿಯ ಮಾಡಲು ಇಷ್ಟ.

212
00:14:48,000 --> 00:14:51,000
ವಾಸ್ತವವಾಗಿ ಇದು ಸ್ವಲ್ಪ ಮುಂದೆ ಮಾಡಲು ಹೋಗುತ್ತದೆ.

213
00:15:04,000 --> 00:15:08,000
ಬಹುಶಃ ಇದು ಈ ತೋರಿಸಲು ಪರಿಪೂರ್ಣ ನಿಜವಲ್ಲ

214
00:15:08,000 --> 00:15:14,000
ಆದರೆ ಆಫ್ ಈ ಭಾಗಗಳನ್ನು ಖಂಡದ ಇಷ್ಟವಾದಲ್ಲಿ

215
00:15:14,000 --> 00:15:17,000
ಈ ಉಂಟಾದರೆ ವೇಳೆ ಸರಿ, ನಂತರ ನಾನು ಏನಾದರೂ ಪಡೆಯಲಿದ್ದೇನೆ

216
00:15:17,000 --> 00:15:19,000
ತದನಂತರ ಕಾರ್ಯವನ್ನು ಮಾಡಲಾಗುತ್ತದೆ.

217
00:15:19,000 --> 00:15:22,000
ನಾನು ಕಾರ್ಯ ಕೆಳಗೆ ನನ್ನ ಕಣ್ಣುಗಳು ಎಲ್ಲ ರೀತಿಯಲ್ಲಿ ಸ್ಕ್ರಾಲ್ ಅಗತ್ಯವಿಲ್ಲ

218
00:15:22,000 --> 00:15:25,000
ಬೇರೆ ನಂತರ ಏನಾಗುತ್ತದೆ ಎಂಬುದನ್ನು.

219
00:15:25,000 --> 00:15:27,000
ಈ ಉಂಟಾದರೆ ವೇಳೆ ಇದು, ನಂತರ ನಾನು ಹಿಂತಿರುಗಿ.

220
00:15:27,000 --> 00:15:30,000
ಇದು ಈ ಮೀರಿ ಎಲ್ಲ ಸಂತೋಷವನ್ನು ಅಧಿಕ ಲಾಭ ಹೊಂದಿದೆ

221
00:15:30,000 --> 00:15:33,000
ಈಗ ಒಮ್ಮೆ ಬಿಟ್ಟು ವರ್ಗಾಯಿಸಲ್ಪಟ್ಟಿದೆ.

222
00:15:33,000 --> 00:15:40,000
ನಾನು ಇನ್ನು ಮುಂದೆ, ಮಾಡಲು ನೀವು ಎಂದಾದರೂ ಹಾಸ್ಯಾಸ್ಪದವಾಗಿ ಉದ್ದ ಸಾಲಿನ ಹತ್ತಿರ ಅಗತ್ಯವಿದೆ

223
00:15:40,000 --> 00:15:45,000
, ಆ 4 ಬೈಟ್ಗಳು ಸಹಾಯ ಮಾಡಬಹುದು, ಮತ್ತು ಹೆಚ್ಚು ಎಡ ವಿಷಯ

224
00:15:45,000 --> 00:15:48,000
ಕಡಿಮೆ ಸಮಾನ ಸರಿ, ನಾನು ನೆನಪಿಡುವ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ ನೀವು ಭಾವಿಸಿದರೆ ಚಿತ್ತಸ್ಥೈರ್ಯವು

225
00:15:48,000 --> 00:15:53,000
ನಾನು ಲೂಪ್ ಒಂದು ಒಂದು ಬೇರೆ ಒಳಗೆ ಒಳಗೆ ಸ್ವಲ್ಪ ಲೂಪ್ ಪ್ರಸ್ತುತ ಆಗಿದ್ದೇನೆ.

226
00:15:53,000 --> 00:15:58,000
ಎಲ್ಲಿಯಾದರೂ ನೀವು ನಾನು ರೀತಿಯ ಹಾಗೆ, ತಕ್ಷಣ ಮರಳಿ ಮಾಡಬಹುದು.

227
00:15:58,000 --> 00:16:05,000
ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಐಚ್ಛಿಕ ಮತ್ತು ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ನಿರೀಕ್ಷೆಯಿಲ್ಲ.

228
00:16:05,000 --> 00:16:12,000
>> [ವಿದ್ಯಾರ್ಥಿ] ಅಲ್ಲಿ ಒಂದು ಗಾತ್ರ ಹೀಗಿರಬೇಕು - ಅನುತ್ತೀರ್ಣ ಸ್ಥಿತಿಯಲ್ಲಿ?

229
00:16:12,000 --> 00:16:19,000
ಇಲ್ಲಿ ಅನುತ್ತೀರ್ಣ ಸ್ಥಿತಿಯನ್ನು ನಾವು ಹೌದು, realloc ವಿಫಲವಾಯಿತು ಇದೆ.

230
00:16:19,000 --> 00:16:22,000
, ಸಂಭಾವ್ಯವಾಗಿ, ಅನುತ್ತೀರ್ಣ ಸ್ಥಿತಿಯಲ್ಲಿ ಹೇಗೆ ಗಮನಿಸಿ

231
00:16:22,000 --> 00:16:26,000
ನಾವು ಮುಕ್ತ ಸ್ಟಫ್ ನಂತರ, ನಾವು ಯಾವಾಗಲೂ ವಿಫಲವಾದ ನೀನು

232
00:16:26,000 --> 00:16:29,000
ನಾವು ಏನನ್ನಾದರೂ ತಳ್ಳಲು ಪ್ರಯತ್ನಿಸಬಹುದು ಎಷ್ಟು ಬಾರಿ ಯಾವುದೇ.

233
00:16:29,000 --> 00:16:32,000
ನಾವು ತಳ್ಳುವುದು ಇದ್ದರೆ, ನಾವು, ಏರಿಕೆಯ ಗಾತ್ರ ಇರಿಸಿಕೊಳ್ಳಲು

234
00:16:32,000 --> 00:16:36,000
ನಾವು ಸ್ಟಾಕ್ ಮೇಲೆ ಏನು ಪುಟ್ಟಿಂಗ್ ಇಲ್ಲದಿದ್ದರೂ ಸಹ.

235
00:16:36,000 --> 00:16:39,000
ಸಾಮಾನ್ಯವಾಗಿ ನಾವು ತನಕ ಗಾತ್ರ ಹೆಚ್ಚಿಸಲು ಇಲ್ಲ

236
00:16:39,000 --> 00:16:43,000
ನಾವು ಯಶಸ್ವಿಯಾಗಿ ಸ್ಟಾಕ್ ಮೇಲೆ ಹೇಳಿಕೆಯ ನಂತರ.

237
00:16:43,000 --> 00:16:50,000
ನಾವು ಎರಡೂ ಇಲ್ಲಿ ಮತ್ತು ಇಲ್ಲಿ, ಹೇಳುತ್ತಾರೆ, ಇದು ಮಾಡಬೇಕಾಗುವುದು.

238
00:16:50,000 --> 00:16:56,000
ಬದಲಿಗೆ ≤ ಸಾಮರ್ಥ್ಯ s.size ಹೇಳುವ ಮತ್ತು ನಂತರ, ಇದು ಸಾಮರ್ಥ್ಯವನ್ನು ಕಡಿಮೆ ಇಲ್ಲಿದೆ

239
00:16:56,000 --> 00:17:01,000
ಎಲ್ಲವೂ ಆಗಿತ್ತು ಅಲ್ಲಿ ನಾವು ಹೋದರು ಮಾತ್ರ ಕಾರಣ.

240
00:17:01,000 --> 00:17:07,000
>> ಮತ್ತು ನೆನಪಿಡಿ, ನಾವು ಬಹುಶಃ ತಪ್ಪು ಮಾತ್ರ ಹಿಂದಿರುಗಬಹುದು ಎಂದು

241
00:17:07,000 --> 00:17:14,000
realloc ಶೂನ್ಯ ಹಿಂದಿರುಗಿದರು ಅಲ್ಲಿ, ಇಲ್ಲಿ

242
00:17:14,000 --> 00:17:19,000
ಮತ್ತು ನೀವು ಪ್ರಮಾಣಿತ ದೋಷ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಸಂಭವಿಸಿದಾಗ

243
00:17:19,000 --> 00:17:22,000
ನೀವು ಒಂದು ಶಿಷ್ಟ ದೋಷ ಮುದ್ರಿಸಲು ಎಲ್ಲಿ ಬಹುಶಃ ನಿಮಗೆ, ಈ ಒಂದು ಸಂದರ್ಭದಲ್ಲಿ ಪರಿಗಣಿಸಬಹುದಾಗಿದೆ

244
00:17:22,000 --> 00:17:26,000
ಬದಲಿಗೆ ಕೇವಲ ಪ್ರಮಾಣಿತ ಔಟ್ ನೇರವಾಗಿ ಮುದ್ರಿಸುವ ಆದ್ದರಿಂದ fprintf stderr.

245
00:17:26,000 --> 00:17:31,000
ಮತ್ತೆ, ಒಂದು ನಿರೀಕ್ಷೆ ಅಲ್ಲ, ಆದರೆ ಒಂದು ದೋಷ ವೇಳೆ

246
00:17:31,000 --> 00:17:41,000
printf ನಮೂದಿಸಿ, ನಂತರ ನೀವು ಬದಲಿಗೆ ಗುಣಮಟ್ಟದ ಔಟ್ ಪ್ರಮಾಣಿತ ದೋಷದ ಮುದ್ರಿಸಲು ಮಾಡಲು ಬಯಸಬಹುದು.

247
00:17:41,000 --> 00:17:44,000
>> ಯಾರಾದರೂ ಗಮನಿಸುವುದು ಬೇರೆ ಏನೂ? ಹೌದು.

248
00:17:44,000 --> 00:17:47,000
[ವಿದ್ಯಾರ್ಥಿ] ನೀವು [ಕೇಳಿಸುವುದಿಲ್ಲ] ಮೇಲೆ ಹೋಗಬಹುದು?

249
00:17:47,000 --> 00:17:55,000
[ರಾಬ್ ಬಿ] ಹೌದು, ನಿಜವಾದ ಅದರ binariness ಅಥವಾ ಏನು ಅದು?

250
00:17:55,000 --> 00:17:57,000
[ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ ನೀವು 2 ಗುಣಿಸುತ್ತೇವೆ?

251
00:17:57,000 --> 00:17:59,000
[ರಾಬ್ ಬಿ] ಹೌದು, ಮೂಲತಃ.

252
00:17:59,000 --> 00:18:11,000
ಅವಳಿ ಭೂಮಿ, ನಾವು ಯಾವಾಗಲೂ ಅಂಕೆಗಳು ನಮ್ಮ ಸೆಟ್.

253
00:18:11,000 --> 00:18:22,000
ಬಲಭಾಗದ ನಲ್ಲಿ ಇಲ್ಲಿ ಮೂಲಭೂತವಾಗಿ ಒಳಸೇರಿಸಿದನು ಇದು 1 ಈ ಎಡ ಶಿಫ್ಟಿಂಗ್.

254
00:18:22,000 --> 00:18:25,000
ಹಿಂದೆ ಇದಕ್ಕೆ ಕೇವಲ ಅವಳಿ ಆ ಎಲ್ಲವನ್ನೂ ನೆನೆದು

255
00:18:25,000 --> 00:18:28,000
, 2 ಒಂದು ಶಕ್ತಿ, ಆದ್ದರಿಂದ ಈ 0 2 ಪ್ರತಿನಿಧಿಸುತ್ತದೆ

256
00:18:28,000 --> 00:18:30,000
1 ಈ 2 ಈ 2 2.

257
00:18:30,000 --> 00:18:33,000
ಈಗ ಬಲಭಾಗದ ಒಂದು 0 ಅಳವಡಿಸುವುದರ ಮೂಲಕ, ನಾವು ಎಲ್ಲವನ್ನೂ ಮೇಲೆ ರಜೆ.

258
00:18:33,000 --> 00:18:38,000
ವಾಟ್ 0 2 ಇದನ್ನು 2 ಈಗ 2 1 2 ಆಗಿರುತ್ತದೆ.

259
00:18:38,000 --> 00:18:41,000
ನಾವು ಸೇರಿಸಲಾಗಿದೆ ಎಂದು ಬಲಭಾಗದ

260
00:18:41,000 --> 00:18:44,000
ಅಗತ್ಯವಾಗಿ 0 ಏರಲಿದೆ,

261
00:18:44,000 --> 00:18:46,000
ಇದು ಅರ್ಥವಿಲ್ಲ.

262
00:18:46,000 --> 00:18:49,000
ನೀವು ಎಂದಾದರೂ 2 ಒಂದು ಸಂಖ್ಯೆಯನ್ನು ಗುಣಿಸಿದಾಗ, ಇದು, ಬೆಸ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಹಿಂದಿರುಗಬಹುದೆಂದು

263
00:18:49,000 --> 00:18:54,000
ಹಾಗೆ 0 ಸ್ಥಳಕ್ಕೆ 2, 0 ಆಗಿರಬೇಕು

264
00:18:54,000 --> 00:18:59,000
ನೀವು ಬದಲಾಗುವ ಸಂಭವಿಸಿ ವೇಳೆ ಮತ್ತು ನಾನು ಅರ್ಧದಷ್ಟು ಮೊದಲು ಬಗ್ಗೆ ಎಚ್ಚರಿಕೆ ಏನು

265
00:18:59,000 --> 00:19:01,000
ಒಂದು ಪೂರ್ಣಾಂಕದಿಂದ ಬೈಟ್ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಮೀರಿ,

266
00:19:01,000 --> 00:19:04,000
ಈ 1 ಆಫ್ ಹೋಗುವ ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು ಹೋಗುತ್ತದೆ.

267
00:19:04,000 --> 00:19:10,000
ನೀವು ನಿಜವಾಗಿಯೂ ದೊಡ್ಡ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ವ್ಯವಹರಿಸುವಾಗ ಎಂದು ಸಂಭವಿಸಿದಾಗ ಮಾತ್ರ ಆತಂಕಕ್ಕೂ ಇಲ್ಲಿದೆ.

268
00:19:10,000 --> 00:19:15,000
ಆದರೆ ಆ ಸಮಯದಲ್ಲಿ, ನಂತರ ನೀವು, ವಸ್ತುಗಳ ಶತಕೋಟಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಮಾತಾಡುತ್ತಿದ್ದೀರಿ

269
00:19:15,000 --> 00:19:25,000
ಹೇಗಾದರೂ ಮೆಮೊರಿ ಸೂಕ್ತವಾಗಿರಬಹುದು ಇರಬಹುದು ಇದು.

270
00:19:25,000 --> 00:19:31,000
>> ಈಗ ನಾವು ಸುಲಭವಾಗಿ ಇದು ಪಾಪ್, ಗೆ ಪಡೆಯಬಹುದು.

271
00:19:31,000 --> 00:19:36,000
ನೀವು ಒಂದು ಇಡೀ ಗುಂಪೇ ಪಾಪ್ ಸಂಭವಿಸಿದಾಗ ನೀವು ಅದನ್ನು ಇಷ್ಟಪಡುತ್ತೀರಿ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

272
00:19:36,000 --> 00:19:38,000
ಈಗ ನೀವು ಮತ್ತೆ ಅರ್ಧ ಸಾಮರ್ಥ್ಯವನ್ನು ಆರ್.

273
00:19:38,000 --> 00:19:42,000
ನೀವು, ನಿಮ್ಮ ಮೆಮೊರಿ ಪ್ರಮಾಣವನ್ನು ಸಂಕುಚಿಸುತ್ತವೆ realloc ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

274
00:19:42,000 --> 00:19:47,000
ಆದರೆ ಆ ಬಗ್ಗೆ ಚಿಂತೆ ಇಲ್ಲ, ಆದ್ದರಿಂದ ಕೇವಲ realloc ಸಂದರ್ಭದಲ್ಲಿ ಏರಲಿದೆ

275
00:19:47,000 --> 00:19:50,000
, ಮೆಮೊರಿ ಕುಗ್ಗುತ್ತಿರುವ ಎಂದಿಗೂ, ಮೆಮೊರಿ ಬೆಳೆಯುತ್ತಿರುವ

276
00:19:50,000 --> 00:19:59,000
ಇದು ಪಾಪ್ ಸೂಪರ್ ಸುಲಭವಾಗಿ ಹೋಗುತ್ತದೆ.

277
00:19:59,000 --> 00:20:02,000
ರಾಶಿಯನ್ನು ಹಾಗೆ ಹೋಗುವ ಇದು ಈಗ ಸಾಲುಗಳನ್ನು,

278
00:20:02,000 --> 00:20:06,000
ಆದರೆ ನೀವು ವಿಷಯಗಳನ್ನು ತೆಗೆಯುವಂತೆ ಆದೇಶ ವ್ಯತಿರಿಕ್ತವಾಗಿದೆ ಇದೆ.

279
00:20:06,000 --> 00:20:10,000
ಒಂದು ಕ್ಯೂ ಪ್ರೋಟೊಟಿಪಿಕಲ್ ಉದಾಹರಣೆಗೆ, ಒಂದು ರೇಖೆ

280
00:20:10,000 --> 00:20:12,000
ಆದ್ದರಿಂದ ನಾನು ಇಂಗ್ಲೀಷ್ ವೇಳೆ ಊಹೆ, ನಾನು ಹೇಳಿರಬಹುದು

281
00:20:12,000 --> 00:20:17,000
ಒಂದು ಸರತಿ ಒಂದು ಪಕ್ಕಾ ಉದಾಹರಣೆಯಾಗಿದೆ ಕ್ಯೂ ಹೊಂದಿದೆ.

282
00:20:17,000 --> 00:20:22,000
ಆದ್ದರಿಂದ ಒಂದು ಲೈನ್ನ, ನೀವು ಸಾಲಿನ ಮೊದಲ ವ್ಯಕ್ತಿ ಇಂತಹ,

283
00:20:22,000 --> 00:20:24,000
ನೀವು ಸಾಲಿನ ಔಟ್ ಮೊದಲ ವ್ಯಕ್ತಿ ಎಂದು ನಿರೀಕ್ಷಿಸಬಹುದು.

284
00:20:24,000 --> 00:20:31,000
ನೀವು ಸಾಲಿನಲ್ಲಿ ಕೊನೆಯ ವ್ಯಕ್ತಿ, ನೀವು ಸೇವೆಯುಕ್ತ ಕೊನೆಯ ವ್ಯಕ್ತಿ ಎಂದು ಹೋಗುವ.

285
00:20:31,000 --> 00:20:35,000
ಸ್ಟಾಕ್ LIFO ನಮೂನೆಯಾಗಿತ್ತು ಆದರೆ ನಾವು ಆ FIFO ಮಾದರಿ ಕರೆ.

286
00:20:35,000 --> 00:20:40,000
ಆ ಪದಗಳನ್ನು ಬಹಳ ಸಾರ್ವತ್ರಿಕವಾಗಿವೆ.

287
00:20:40,000 --> 00:20:46,000
>> ರಾಶಿಯನ್ನು ಲೈಕ್ ಮತ್ತು ಸರಣಿಗಳ ಭಿನ್ನವಾಗಿ, ಸಾಲುಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಮಧ್ಯಮ ಅಂಶಗಳ ಪ್ರವೇಶವನ್ನು ಅನುಮತಿಸುವುದಿಲ್ಲ.

288
00:20:46,000 --> 00:20:50,000
ಇಲ್ಲಿ, ಒಂದು ಸ್ಟಾಕ್, ನಾವು ಪುಶ್ ಮತ್ತು ಪಾಪ್ ಹೊಂದಿರುತ್ತವೆ.

289
00:20:50,000 --> 00:20:54,000
ಇಲ್ಲಿ, ನಾವು ಅವುಗಳನ್ನು ಎನ್ಕ್ಯೂ ಮತ್ತು dequeue ಎಂದು ಸಂಭವಿಸಬಹುದು.

290
00:20:54,000 --> 00:20:58,000
ನಾನು ಸಹ ಅವರನ್ನು ಶಿಫ್ಟ್ ಮತ್ತು unshift ಎಂದು ಕೇಳಿರಬಹುದು.

291
00:20:58,000 --> 00:21:02,000
ನಾನು ಜನರು ಪುಶ್ ಮತ್ತು ಪಾಪ್ ಸಾಲುಗಳನ್ನು ಸಹ ಅನ್ವಯಿಸಲು ಹೇಳುತ್ತಾರೆ ಕೇಳಿರುವ.

292
00:21:02,000 --> 00:21:05,000
ನಾನು, ತೆಗೆದುಹಾಕಲು, ಸೇರಿಸಲು ಕೇಳಿರಬಹುದು

293
00:21:05,000 --> 00:21:11,000
ಆದ್ದರಿಂದ ತಳ್ಳಲು ಮತ್ತು ನೀವು ರಾಶಿಯನ್ನು ಬಗ್ಗೆ, ನೀವು ತಳ್ಳುವುದು ಮತ್ತು ವರ್ಧಿಸುತ್ತಿವೆ, ಪಾಪ್.

294
00:21:11,000 --> 00:21:16,000
ನೀವು ಸಾಲುಗಳನ್ನು ಬಗ್ಗೆ ಬಳಸುತ್ತಿದ್ದರೆ, ನೀವು ಬಳಸುವ ಪದಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು

295
00:21:16,000 --> 00:21:23,000
ಅಳವಡಿಕೆ ಮತ್ತು ತೆಗೆಯಲು, ಮತ್ತು ಎಂದು ಏನನ್ನು ಒಮ್ಮತ ಇಲ್ಲ.

296
00:21:23,000 --> 00:21:27,000
ಆದರೆ ಇಲ್ಲಿ, ನಾವು ಎನ್ಕ್ಯೂ ಮತ್ತು dequeue ಹೊಂದಿರುತ್ತವೆ.

297
00:21:27,000 --> 00:21:37,000
ಈಗ, struct ಸ್ಟಾಕ್ struct ಏಕಸ್ವರೂಪದ್ದಾಗಿತ್ತು ಕಾಣುತ್ತದೆ.

298
00:21:37,000 --> 00:21:40,000
ಆದರೆ ತಲೆಯ ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಹೊಂದಿವೆ.

299
00:21:40,000 --> 00:21:44,000
ಅದನ್ನು ಇಲ್ಲಿ ಹೇಳುತ್ತಾರೆ ಊಹಿಸುತ್ತಾರೆ, ಆದರೆ ಏಕೆ ನಾವು ತಲೆ ಬೇಕು?

300
00:21:53,000 --> 00:21:57,000
ಮೂಲಮಾದರಿಗಳ ತಳ್ಳಲು ಮತ್ತು ಪಾಪ್ ಮೂಲತಃ ಒಂದೇ.

301
00:21:57,000 --> 00:21:59,000
ನೀವು ಪುಶ್ ಮತ್ತು ಪಾಪ್ ಎಂದು ನಗರದ.

302
00:21:59,000 --> 00:22:08,000
ಒಂದೇ ಒಂದು ವ್ಯತ್ಯಾಸವೆಂದರೆ ಪಾಪ್ ಹಿಂದಿರುಗಿದ-ಬದಲಿಗೆ ಕೊನೆಯ, ಇದು ಮೊದಲ ಹಿಂದಿರುಗಿದ ಪಡೆದುಕೊಳ್ಳಬಹುದಾಗಿದೆ.

303
00:22:08,000 --> 00:22:12,000
2, 1, 3, 4, ಅಥವಾ ಏನಾದರೂ.

304
00:22:12,000 --> 00:22:14,000
ಮತ್ತು ಇಲ್ಲಿ ಆರಂಭಿಸೋಣ.

305
00:22:14,000 --> 00:22:17,000
ನಮ್ಮ ಕ್ಯೂ ಸಂಪೂರ್ಣವಾಗಿ ಪೂರ್ಣ, ಆದ್ದರಿಂದ ನಾಲ್ಕು ಅಂಶಗಳು ಇಲ್ಲ.

306
00:22:17,000 --> 00:22:21,000
ನಮ್ಮ ಕ್ಯೂ ಕೊನೆಯಲ್ಲಿ, ಪ್ರಸ್ತುತ 2

307
00:22:21,000 --> 00:22:24,000
ಮತ್ತು ಈಗ ನಾವು ಯಾವುದೋ ತೂರಿಸಲು ಹೋಗಿ.

308
00:22:24,000 --> 00:22:29,000
>> ನಾವು ಸ್ಟಾಕ್ ಆವೃತ್ತಿಯ ನಾವು ಏನು ಬೇರೆ ವಿಷಯ, ಸೇರಿಸಲು ಬಯಸಿದರೆ

309
00:22:29,000 --> 00:22:36,000
ನಾವು ಮೆಮೊರಿ ನಮ್ಮ ಬ್ಲಾಕ್ ವಿಸ್ತರಿಸಲಾಗಿದೆ.

310
00:22:36,000 --> 00:22:40,000
ಈ ಸಮಸ್ಯೆ ಏನು?

311
00:22:40,000 --> 00:22:45,000
[ವಿದ್ಯಾರ್ಥಿ] ನೀವು 2 ಸರಿಸಲು.

312
00:22:45,000 --> 00:22:51,000
ನಾನು ಸರತಿ ಕೊನೆಯಲ್ಲಿ ಬಗ್ಗೆ ಮೊದಲು ತಿಳಿಸಿದರು, ವಾಟ್

313
00:22:51,000 --> 00:22:57,000
ಈ, 1 ನಾವು ಆರಂಭಿಸುವ ಅರ್ಥದಲ್ಲಿ ಮಾಡುವುದಿಲ್ಲ

314
00:22:57,000 --> 00:23:01,000
ನಾವು ನಂತರ dequeue 3, dequeue 4, dequeue 1 ಬಯಸುವ

315
00:23:01,000 --> 00:23:05,000
ನಂತರ dequeue 2, ನಂತರ ಈ ಒಂದು dequeue.

316
00:23:05,000 --> 00:23:08,000
ನಾವು ಈಗ realloc ಬಳಸುವಂತಿಲ್ಲ

317
00:23:08,000 --> 00:23:11,000
ಅಥವಾ ಕನಿಷ್ಟ ಪಕ್ಷ, ನೀವು ಬೇರೆ ರೀತಿಯಲ್ಲಿ realloc ಬಳಸಲು ಹೊಂದಿರುತ್ತವೆ.

318
00:23:11,000 --> 00:23:15,000
ಆದರೆ ನೀವು ಬಹುಶಃ ಕೇವಲ realloc ಉಪಯೋಗಿಸಬಾರದು.

319
00:23:15,000 --> 00:23:18,000
ನೀವು ಕೈಯಾರೆ ನಿಮ್ಮ ಮೆಮೊರಿ ನಕಲಿಸಲು ಹೊಂದಿವೆ ಹೋಗುವ.

320
00:23:18,000 --> 00:23:21,000
>> ಮೆಮೊರಿ ನಕಲಿಸಲು ಎರಡು ಕಾರ್ಯಗಳು ಇವೆ.

321
00:23:21,000 --> 00:23:25,000
Memcopy ಮತ್ತು memmove ಇಲ್ಲ.

322
00:23:25,000 --> 00:23:29,000
ನಾನು ಪ್ರಸ್ತುತ ನೀವು ಬಳಸಲು ಬಯಸುವ ಎಂದು ನೀನು ಒಂದು ನೋಡಲು ಮ್ಯಾನ್ ಪುಟಗಳನ್ನು ಓದುವ ನುಡಿದರು.

323
00:23:29,000 --> 00:23:35,000
ಸರಿ, memcopy, ವ್ಯತ್ಯಾಸ

324
00:23:35,000 --> 00:23:38,000
memcopy ಮತ್ತು memmove, ಒಂದು ಸರಿಯಾಗಿ ಕೇಸ್ ನಿರ್ವಹಿಸುತ್ತದೆ

325
00:23:38,000 --> 00:23:41,000
ನೀವು ಪ್ರದೇಶ ಹರಡಿರುತ್ತವೆ ಸಂಭವಿಸಿದರೆ ಒಂದು ಪ್ರದೇಶದ ನಕಲು ನೀವು ಅಲ್ಲಿ

326
00:23:41,000 --> 00:23:46,000
ನೀವು ನಕಲಿಸಲು ನೀವು.

327
00:23:46,000 --> 00:23:50,000
Memcopy ನಿರ್ವಹಿಸಲು ಇಲ್ಲ. Memmove ಮಾಡುತ್ತದೆ.

328
00:23:50,000 --> 00:23:59,000
ನೀವು ಸಮಸ್ಯೆ ನಗರದ

329
00:23:59,000 --> 00:24:09,000
ಈಗ, ನಾನು ಈ ವ್ಯಕ್ತಿ ನಕಲಿಸಲು ಬಯಸುವ ಹೇಳುತ್ತಾರೆ

330
00:24:09,000 --> 00:24:13,000
ಈ ವ್ಯಕ್ತಿ ಈ ನಾಲ್ಕು.

331
00:24:13,000 --> 00:24:16,000
ಕೊನೆಯಲ್ಲಿ, ರಚನೆಯ ರೀತಿಯಲ್ಲಿ ಎಂಬುದನ್ನು ನೋಡಬೇಕು

332
00:24:16,000 --> 00:24:26,000
ನಕಲು ನಂತರ 2, 1, 2, 1, 3, 4, ಮತ್ತು ಕೊನೆಯಲ್ಲಿ ಕೆಲವು ವಿಷಯವನ್ನು ನಂತರ.

333
00:24:26,000 --> 00:24:29,000
ಆದರೆ, ನಾವು ವಾಸ್ತವವಾಗಿ ನಕಲಿಸಿ ಯಾವ ಕ್ರಮದಲ್ಲಿ ಅವಲಂಬಿಸಿದೆ

334
00:24:29,000 --> 00:24:32,000
ನಾವು ಪ್ರದೇಶದಲ್ಲಿ ನಾವು ನಕಲು ನೀವು ವಾಸ್ತವವಾಗಿ ಪರಿಗಣಿಸುವುದಿಲ್ಲ ವೇಳೆ ರಿಂದ

335
00:24:32,000 --> 00:24:35,000
ಅತಿಕ್ರಮಿಸುತ್ತದೆ ನಾವು ನಕಲು ನೀವು ಒಂದು,

336
00:24:35,000 --> 00:24:46,000
ನಂತರ ನಾವು, ಇಲ್ಲಿ ಆರಂಭದ ಇಷ್ಟಪಡುತ್ತೀರಿ ನಾವು ಹೋಗಲು ಬಯಸುವ ಸ್ಥಾನಕ್ಕೇರಿತು 2 ನಕಲು ಇರಬಹುದು

337
00:24:46,000 --> 00:24:52,000
ನಂತರ ಮುಂದೆ ನಮ್ಮ ಪಾಯಿಂಟರ್ಸ್ ಸರಿಸಲು.

338
00:24:52,000 --> 00:24:56,000
>> ಈಗ ನಾವು ಇಲ್ಲಿ ಮತ್ತು ಇಲ್ಲಿ ಎಂದು ನೀನು, ಮತ್ತು ಈಗ ನಾವು ನಕಲಿಸಲು ಬಯಸುವ

339
00:24:56,000 --> 00:25:04,000
ಈ ವ್ಯಕ್ತಿ ಮೇಲೆ ಗೈ ಮತ್ತು ಮುಂದೆ ನಮ್ಮ ಪಾಯಿಂಟರ್ಸ್ ಸರಿಸಲು.

340
00:25:04,000 --> 00:25:07,000
ನಾವು ಪಡೆಯುವಲ್ಲಿ ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು ನೀನು, 1, 2, 1, 2, 1 2

341
00:25:07,000 --> 00:25:10,000
ಬದಲಿಗೆ ಸೂಕ್ತ 2, 1, 2, 1, 3, 4 ಏಕೆಂದರೆ

342
00:25:10,000 --> 00:25:15,000
2, 1 ಮೂಲ 3, 4 overrode.

343
00:25:15,000 --> 00:25:19,000
Memmove ಸರಿಯಾಗಿ ಎಂದು ನಿಭಾಯಿಸುತ್ತದೆ.

344
00:25:19,000 --> 00:25:23,000
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಮೂಲತಃ ಕೇವಲ ಯಾವಾಗಲೂ memmove ಬಳಸಿ

345
00:25:23,000 --> 00:25:26,000
ಇದು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುತ್ತದೆ ಏಕೆಂದರೆ.

346
00:25:26,000 --> 00:25:29,000
ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಯಾವುದೇ ಕೆಟ್ಟ ಮಾಡುವುದಿಲ್ಲ.

347
00:25:29,000 --> 00:25:32,000
ಕಲ್ಪನೆ ಬದಲಿಗೆ ಆರಂಭದಿಂದ ಮತ್ತು ಈ ರೀತಿಯಲ್ಲಿ ನಕಲು ಹೊಂದಿದೆ

348
00:25:32,000 --> 00:25:35,000
ನಾವು ಇಲ್ಲಿ ಮಾಡಿದ ಹಾಗೆ, ಅದು, ತುದಿಯಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಮತ್ತು ನಕಲಿಸುತ್ತದೆ

349
00:25:35,000 --> 00:25:38,000
ಆ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ಸಮಸ್ಯೆ ಎಂದಿಗೂ.

350
00:25:38,000 --> 00:25:40,000
ಯಾವುದೇ ಪ್ರದರ್ಶನವನ್ನು ಇಲ್ಲವಾಗುತ್ತದೆ.

351
00:25:40,000 --> 00:25:47,000
ಯಾವಾಗಲೂ memmove ಬಳಸಿ. Memcopy ಬಗ್ಗೆ ಚಿಂತೆ ಇಲ್ಲ.

352
00:25:47,000 --> 00:25:51,000
ನೀವು ಪ್ರತ್ಯೇಕವಾಗಿ memmove ಮಾಡಲಿಕ್ಕೆ ನೀವು ಅಲ್ಲಿ ಆ ಸ್

353
00:25:51,000 --> 00:26:01,000
ನಿಮ್ಮ ಕ್ಯೂ ನ ಸುತ್ತಿ-ಸುಮಾರು ಭಾಗ.

354
00:26:01,000 --> 00:26:04,000
ಚಿಂತಿಸ ಸಂಪೂರ್ಣವಾಗಿ ಮಾಡಲಾಗುತ್ತದೆ ವೇಳೆ ಅಲ್ಲ.

355
00:26:04,000 --> 00:26:10,000
ಈ ಸಂಗ್ರಹವು, ಪುಶ್, ಮತ್ತು ಪಾಪ್ ಹೆಚ್ಚು ಕಷ್ಟ.

356
00:26:10,000 --> 00:26:15,000
>> ಯಾರಾದರೂ ನಾವು ಕೆಲಸ ಮಾಡಬಹುದು ಯಾವುದೇ ಕೋಡ್ ಹೊಂದಿರುತ್ತವೆ?

357
00:26:15,000 --> 00:26:21,000
ಇನ್ನೂ ಸಂಪೂರ್ಣವಾಗಿ ಅಪೂರ್ಣ ವೇಳೆ?

358
00:26:21,000 --> 00:26:23,000
[ವಿದ್ಯಾರ್ಥಿ] ಹೌದು, ಇದು ಆದರೂ, ಸಂಪೂರ್ಣವಾಗಿ ಅಪೂರ್ಣ ಇಲ್ಲಿದೆ.

359
00:26:23,000 --> 00:26:27,000
ನಾವು ನೀವು ಪರಿಷ್ಕರಣೆ ಉಳಿಸಲು ಸಂಪೂರ್ಣವಾಗಿ ಅಪೂರ್ಣ ತನಕ ದಂಡವನ್ನು ಹೊಂದಿದೆ?

360
00:26:27,000 --> 00:26:32,000
ನಾನು ಪ್ರತಿಯೊಂದು ಸಮಯ ಮರೆಯಬೇಡಿ.

361
00:26:32,000 --> 00:26:39,000
ನಾವು ವಸ್ತುಗಳ ಮರುಗಾತ್ರಗೊಳಿಸಲು ಅಗತ್ಯವಿರುವಾಗ ಸರಿ, ಏನು ನಿರ್ಲಕ್ಷಿಸಿ ಸಂಭವಿಸುತ್ತದೆ.

362
00:26:39,000 --> 00:26:42,000
ಸಂಪೂರ್ಣವಾಗಿ ಗಣಕತೆರೆ ನಿರ್ಲಕ್ಷಿಸಿ.

363
00:26:42,000 --> 00:26:49,000
ಈ ಕೋಡ್ ವಿವರಿಸಿ.

364
00:26:49,000 --> 00:26:54,000
ಗಾತ್ರ ಎಲ್ಲಾ ಮೊದಲ ನಕಲನ್ನು ಕಡಿಮೆ ವೇಳೆ ನಾನು ಮೊದಲ ಎಲ್ಲಾ ತಪಾಸಣೆ ನಾನು

365
00:26:54,000 --> 00:27:01,000
ಮತ್ತು ಆ ನಂತರ, ನಾನು ಸೇರಿಸಲು-ನಾನು ತಲೆ + ಗಾತ್ರ, ತೆಗೆದುಕೊಳ್ಳಬಹುದು

366
00:27:01,000 --> 00:27:05,000
ಮತ್ತು ನಾನು, ಅದು ರಚನೆಯ ಸಾಮರ್ಥ್ಯವನ್ನು ಸುತ್ತಲೂ ಸುತ್ತಿ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ

367
00:27:05,000 --> 00:27:08,000
ಮತ್ತು ನಾನು ಸ್ಥಾನದಲ್ಲಿ ಹೊಸ ಸಾಲನ್ನು ಸೇರಿಸಲು.

368
00:27:08,000 --> 00:27:12,000
ನಂತರ ನಾನು ಗಾತ್ರ ಹೆಚ್ಚಿಸಲು ಮತ್ತು ನಿಜವಾದ ಹಿಂತಿರುಗಿ.

369
00:27:12,000 --> 00:27:22,000
>> [ರಾಬ್ ಬಿ] ಈ ಖಂಡಿತವಾಗಿಯೂ ನೀವು ಮೋಡ್ ಬಳಸಿ ಬೇಕಿರುವ ಎಂದು ನೀನು ಅಲ್ಲಿ ಆ ಸಂದರ್ಭಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ.

370
00:27:22,000 --> 00:27:25,000
ನೀವು ಸುತ್ತಲೂ ಸುತ್ತಿಕೊಳ್ಳುವ ಭಾವಿಸಿದರೆ ನೀವು,, ಸುತ್ತಲೂ ಸುತ್ತಿಕೊಳ್ಳುವ ಹೊಂದಿದ ಸಂದರ್ಭದಲ್ಲಿ ಯಾವುದೇ ರೀತಿಯ

371
00:27:25,000 --> 00:27:29,000
ತಕ್ಷಣದ ಚಿಂತನೆಯ ಮಾಡ್ ಆಗಿರಬೇಕು.

372
00:27:29,000 --> 00:27:36,000
ತ್ವರಿತ ಉತ್ತಮಗೊಳಿಸುವಿಕೆ /, ನಿಮ್ಮ ಕೋಡ್ ಒಂದು ಸಾಲು ಸೀಮಿತಗೊಳಿಸಬಹುದು

373
00:27:36,000 --> 00:27:42,000
ನೀವು ಲೈನ್ ತಕ್ಷಣ ಈ ಒಂದು ನಂತರ ಗಮನಿಸಿ

374
00:27:42,000 --> 00:27:53,000
ಕೇವಲ ಗಾತ್ರ + +, ಆದ್ದರಿಂದ ನೀವು ವಿಲೀನಗೊಳ್ಳಲು ಈ ಮಾರ್ಗ, ಗಾತ್ರ + +.

375
00:27:53,000 --> 00:27:58,000
ಕೆಳಗೆ ಇಲ್ಲಿ ಈಗ, ನಾವು ಸಂದರ್ಭದಲ್ಲಿ ಹೊಂದಿವೆ

376
00:27:58,000 --> 00:28:01,000
ಅಲ್ಲಿ ನಾವು, ಸಾಕಷ್ಟು ಮೆಮೊರಿ ಇಲ್ಲ

377
00:28:01,000 --> 00:28:05,000
ಆದ್ದರಿಂದ ನಾವು 2 ನಮ್ಮ ಸಾಮರ್ಥ್ಯ ಹೆಚ್ಚಾಗುತ್ತಿದೆ.

378
00:28:05,000 --> 00:28:09,000
, ನಾನು ಇಲ್ಲಿ ಅದೇ ಸಮಸ್ಯೆ ಎಂದು ಭಾವಿಸುತ್ತೇನೆ, ಆದರೆ ಈಗ ಅದನ್ನು ನಿರ್ಲಕ್ಷಿಸಬಹುದು

379
00:28:09,000 --> 00:28:13,000
ನಿಮ್ಮ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೆಚ್ಚಿಸಲು ವಿಫಲವಾಗಿದೆ ಅಲ್ಲಿ ವೇಳೆ,

380
00:28:13,000 --> 00:28:18,000
ನಂತರ ನೀವು ಮತ್ತೆ 2 ಮೂಲಕ ನಿಮ್ಮ ಸಾಮರ್ಥ್ಯವನ್ನು ಕಡಿಮೆ ಬಯಸುವ ಎಂದು ನೀನು.

381
00:28:18,000 --> 00:28:24,000
ಇನ್ನೊಂದು ಸಣ್ಣ ಟಿಪ್ಪಣಿಯನ್ನು ನೀವು ಮಾಡಬಹುದು ಕೇವಲ ಹಾಗೆ + =,

382
00:28:24,000 --> 00:28:30,000
ನೀವು << = ಮಾಡಬಹುದು.

383
00:28:30,000 --> 00:28:43,000
ಸಮನಾಗಿರುತ್ತದೆ ಮೊದಲು ಸುಮಾರು ಏನು ಹೋಗಬಹುದು, + =, | =, & =, << =.

384
00:28:43,000 --> 00:28:52,000
ಚಾರ್ * ಹೊಸ ಮೆಮೊರಿ ನಮ್ಮ ಹೊಸ ಬ್ಲಾಕ್ ಆಗಿದೆ.

385
00:28:52,000 --> 00:28:55,000
ಓಹ್, ಇಲ್ಲಿ ಹೆಚ್ಚು.

386
00:28:55,000 --> 00:29:02,000
>> ಜನರು ಮೆಮೊರಿ ನಮ್ಮ ಹೊಸ ಬ್ಲಾಕ್ ಮಾದರಿ ಬಗ್ಗೆ ಏನು ಆಲೋಚಿಸುತ್ತೀರಿ ಏನು?

387
00:29:02,000 --> 00:29:06,000
[ವಿದ್ಯಾರ್ಥಿ] ಇದು ಚಾರ್ ** ಆಗಿರಬೇಕು.

388
00:29:06,000 --> 00:29:12,000
ಅಪ್ ಇಲ್ಲಿ ನಮ್ಮ struct ಯೋಚಿಸುವಾಗ,

389
00:29:12,000 --> 00:29:14,000
ತಂತಿಗಳನ್ನು ನಾವು reallocating ಏನು ಆಗಿದೆ.

390
00:29:14,000 --> 00:29:21,000
ನಾವು ಸರದಿಯಲ್ಲಿ ಅಂಶಗಳನ್ನು ಒಂದು ಸಂಪೂರ್ಣ ಹೊಸ ಕ್ರಿಯಾತ್ಮಕ ಸಂಗ್ರಹಣೆ ಮಾಡುತ್ತಿದ್ದಾರೆ.

391
00:29:21,000 --> 00:29:25,000
ನಾವು ನಿಮ್ಮ ತಂತಿಗಳನ್ನು ಗೆ ನಿಯೋಜಿಸುವ ಎಂದು ನೀನು, ಇದೀಗ mallocing ಏನನ್ನು ಹೊಂದಿದೆ

392
00:29:25,000 --> 00:29:30,000
ಆದ್ದರಿಂದ ಹೊಸ ಒಂದು ಚಾರ್ ** ಎಂದು ಹೋಗುತ್ತದೆ.

393
00:29:30,000 --> 00:29:34,000
ಇದು ತಂತಿಗಳ ಸರಣಿಯಾಗಿರಬೇಕು ಹೋಗುವುದಿಲ್ಲ.

394
00:29:34,000 --> 00:29:38,000
ನಾವು ತಪ್ಪು ಮರಳಲು ನೀನು ಯಾವ ಸಂದರ್ಭದಲ್ಲಿ ಏನು?

395
00:29:38,000 --> 00:29:41,000
[ವಿದ್ಯಾರ್ಥಿ] ನಾವು ಚಾರ್ * ಮಾಡುವುದರಿಂದ ಹೋಗಬೇಕೇ?

396
00:29:41,000 --> 00:29:44,000
[ರಾಬ್ ಬಿ] ಹೌದು, ಒಳ್ಳೆಯ ಕರೆ.

397
00:29:44,000 --> 00:29:46,000
[ವಿದ್ಯಾರ್ಥಿ] ಏನು ಎಂಬುದು?

398
00:29:46,000 --> 00:29:49,000
[ರಾಬ್ ಬಿ] ನಾವು ಯಾವುದೇ ಏಕೆಂದರೆ ಚಾರ್ * ಗಾತ್ರವನ್ನು ಮಾಡಲು ಬಯಸಿದ್ದರು ಕಾಲ

399
00:29:49,000 --> 00:29:53,000
sizeof (ಚಾರ್) 1 ಏಕೆಂದರೆ ಈ ವಾಸ್ತವವಾಗಿ ಒಂದು ದೊಡ್ಡ ಸಮಸ್ಯೆ ಎಂದು.

400
00:29:53,000 --> 00:29:55,000
Sizeof ಚಾರ್ *, 4 ಏರಲಿದೆ

401
00:29:55,000 --> 00:29:58,000
ಆದ್ದರಿಂದ ನೀವು ints ವ್ಯವಹರಿಸುವಾಗ ಮಾಡಿದಾಗ ಬಾರಿ ಬಹಳಷ್ಟು,

402
00:29:58,000 --> 00:30:01,000
ನೀವು ಹೊರಗೆ ಪಡೆಯಲು ಯಾಕೇಂದರೆ ಇಂಟ್ * ನ ಇಂಟ್ ಮತ್ತು ಗಾತ್ರದ ಗಾತ್ರ

403
00:30:01,000 --> 00:30:04,000
ಒಂದು 32 ಬಿಟ್ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಒಂದೇ ಮುಂದುವರೆಸುತ್ತೇವೆ.

404
00:30:04,000 --> 00:30:09,000
ಆದರೆ ಇಲ್ಲಿ, sizeof (ಅಕ್ಷರ) ಮತ್ತು sizeof (ಚಾರ್ *) ಈಗ ಒಂದೇ ಮುಂದುವರೆಸುತ್ತೇವೆ.

405
00:30:09,000 --> 00:30:15,000
>> ನಾವು ತಪ್ಪು ಮರಳಿ ಅಲ್ಲಿ ಪರಿಸ್ಥಿತಿ ಏನು?

406
00:30:15,000 --> 00:30:17,000
[ವಿದ್ಯಾರ್ಥಿ] ನ್ಯೂ ಶೂನ್ಯ ಆಗಿದೆ.

407
00:30:17,000 --> 00:30:23,000
ಹೊಸ ಶೂನ್ಯ ವೇಳೆ ಹೌದು, ನಾವು ತಪ್ಪು ಹಿಂತಿರುಗಿ

408
00:30:23,000 --> 00:30:34,000
ನಾನು ಕೆಳಗೆ ಎಸೆಯಲು ಪಡೆಯಲಿದ್ದೇನೆ ಇಲ್ಲಿಗೆ

409
00:30:34,000 --> 00:30:37,000
[ವಿದ್ಯಾರ್ಥಿ] [ಕೇಳಿಸುವುದಿಲ್ಲ]

410
00:30:37,000 --> 00:30:39,000
[ರಾಬ್ ಬಿ] ಹೌದು, ಈ ದಂಡವನ್ನು ಹೊಂದಿದೆ.

411
00:30:39,000 --> 00:30:46,000
ನೀವು 2 ಪಟ್ಟು ಸಾಮರ್ಥ್ಯವನ್ನು ಅಥವಾ ಸಾಮರ್ಥ್ಯ ಶಿಫ್ಟ್ 1 ಮತ್ತು ನಂತರ ಕೇವಲ ಇಲ್ಲಿ ಅಥವಾ ಯಾವುದೇ ಅದನ್ನು ಸೆಟ್ ಇಲ್ಲ.

412
00:30:46,000 --> 00:30:52,000
ನಾವು ಹಾಗೆ ನಾವು ಅದನ್ನು ಮಾಡುತ್ತೇನೆ.

413
00:30:52,000 --> 00:30:56,000
ಸಾಮರ್ಥ್ಯ >> = 1.

414
00:30:56,000 --> 00:31:08,000
ಮತ್ತು 1 ಸ್ಥಾನವನ್ನು ಕಳೆದುಕೊಳ್ಳುವ ಬಗ್ಗೆ ಚಿಂತೆ ಮಾಡಲಿಕ್ಕೆ ಇಲ್ಲ ನೀವು

415
00:31:08,000 --> 00:31:12,000
ನೀವು 1 ವರ್ಗಾಯಿಸಲಾಯಿತು ತೊರೆದರು ಏಕೆಂದರೆ, ಆದ್ದರಿಂದ 1 ಸ್ಥಾನವನ್ನು, ಅತ್ಯವಶ್ಯವಾಗಿ 0

416
00:31:12,000 --> 00:31:16,000
ಆದ್ದರಿಂದ ಬಲ 1 ಬದಲಾಯಿಸುವ, ನೀವು ಇನ್ನೂ ಚೆನ್ನಾಗಿರುತ್ತದೆ ಎಂದು ನೀನು.

417
00:31:16,000 --> 00:31:19,000
[ವಿದ್ಯಾರ್ಥಿ] ನೀವು ರಿಟರ್ನ್ ಮೊದಲು ಮಾಡಲು ಬೇಕು?

418
00:31:19,000 --> 00:31:29,000
[ರಾಬ್ ಬಿ] ಹೌದು, ಈ ಸಂಪೂರ್ಣವಾಗಿ ಯಾವುದೇ ಅರ್ಥವಿಲ್ಲ.

419
00:31:29,000 --> 00:31:36,000
>> ನಾವು ಕೊನೆಗೆ ನಿಜವಾದ ಹಿಂದಿರುಗಿದ ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು ನೀನು ಈಗ ಊಹಿಸುತ್ತವೆ.

420
00:31:36,000 --> 00:31:39,000
ನಾವು ಈ memmoves ಮಾಡಲು ನೀನು ರೀತಿಯಲ್ಲಿ,

421
00:31:39,000 --> 00:31:45,000
ನಾವು ಅವುಗಳನ್ನು ಹೇಗೆ ಜಾಗರೂಕರಾಗಿರಿ ಎಂದು ಅಗತ್ಯವಿದೆ.

422
00:31:45,000 --> 00:31:50,000
ಯಾರಾದರೂ ನಾವು ಅವುಗಳನ್ನು ಹೇಗೆ ಯಾವುದೇ ಸಲಹೆಗಳನ್ನು ಹೊಂದಿದೆ?

423
00:32:17,000 --> 00:32:21,000
ಇಲ್ಲಿ ನಮ್ಮ ಆರಂಭಿಸೋಣ.

424
00:32:21,000 --> 00:32:28,000
ಅನಿವಾರ್ಯವಾಗಿ, ನಾವು ಮತ್ತೆ ಆರಂಭದಲ್ಲಿ ಆರಂಭಿಸಲು ಬಯಸುವ

425
00:32:28,000 --> 00:32:35,000
ಅಲ್ಲಿಂದ ಮತ್ತು ನಕಲು ವಸ್ತುಗಳು, 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
ನೀವು ಹೇಗೆ ಮಾಡಬೇಕು?

427
00:32:41,000 --> 00:32:52,000
ಮೊದಲ, ನಾನು ಮತ್ತೆ memmove ಮ್ಯಾನ್ ಪುಟವನ್ನು ನೋಡಲು ಹೊಂದಿವೆ.

428
00:32:52,000 --> 00:32:57,000
Memmove, ವಾದಗಳು ಕ್ರಮವನ್ನು ಮುಖ್ಯವಾದವರು.

429
00:32:57,000 --> 00:33:01,000
ನಾವು ಮೂಲ ಎರಡನೇ, ಮೂರನೇ ಗಾತ್ರ, ಮೊದಲ ನಮ್ಮ ಗಮ್ಯಸ್ಥಾನ ಬಯಸುವ.

430
00:33:01,000 --> 00:33:06,000
ಮೂಲ ಮತ್ತು ಗಮ್ಯಸ್ಥಾನ ರಿವರ್ಸ್ ಕಾರ್ಯಗಳನ್ನು ಸಾಕಷ್ಟು ಇವೆ.

431
00:33:06,000 --> 00:33:11,000
ಗಮ್ಯಸ್ಥಾನ, ಮೂಲ ರೀತಿಯಲ್ಲಿ ಸ್ಥಿರವಾದ ಕಾಣುತ್ತಾರೆ.

432
00:33:17,000 --> 00:33:21,000
ವರ್ಗಾಯಿಸುವುದು, ಇದು ಯಾವ ಹಿಂದಿರುಗಿದ ಇದೆ?

433
00:33:21,000 --> 00:33:27,000
ಇದು ನೀವು ಬಯಸಬಹುದು ಯಾವುದೇ ಕಾರಣದಿಂದಾಗಿ, ಗಮ್ಯಸ್ಥಾನ ಒಂದು ಪಾಯಿಂಟರ್ ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

434
00:33:27,000 --> 00:33:32,000
ನಾನು ಅದನ್ನು ಓದಬಹುದು ಚಿತ್ರ, ಆದರೆ ನಾವು ನಮ್ಮ ಗಮ್ಯಸ್ಥಾನ ತೊಡಗಿಸಿಕೊಳ್ಳಲು ಬಯಸುವ.

435
00:33:32,000 --> 00:33:35,000
>> ನಮ್ಮ ಗಮ್ಯಸ್ಥಾನ ಏನು ಏರಲಿದೆ?

436
00:33:35,000 --> 00:33:37,000
[ವಿದ್ಯಾರ್ಥಿ] ನ್ಯೂ.

437
00:33:37,000 --> 00:33:39,000
[ರಾಬ್ ಬಿ] ಹೌದು, ಮತ್ತು ಅಲ್ಲಿ ನಾವು ನಕಲು ಮಾಡಲಾಗುತ್ತದೆ?

438
00:33:39,000 --> 00:33:43,000
ನಾವು ನಕಲು ಮಾಡಲಾಗುತ್ತದೆ ಮೊದಲನೆಯದಾಗಿ ಈ 1, 3, 4.

439
00:33:43,000 --> 00:33:50,000
, 4 3 ಈ 1 ಏನು.

440
00:33:50,000 --> 00:33:55,000
ಈ 1 ವಿಳಾಸವನ್ನು ಎಂದರೇನು?

441
00:33:55,000 --> 00:33:58,000
ಆ 1 ವಿಳಾಸವನ್ನು ಎಂದರೇನು?

442
00:33:58,000 --> 00:34:01,000
[ವಿದ್ಯಾರ್ಥಿ] [ಕೇಳಿಸುವುದಿಲ್ಲ]

443
00:34:01,000 --> 00:34:03,000
[ರಾಬ್ ಬಿ] ಹೆಡ್ + ಮೊದಲ ಅಂಶ ವಿಳಾಸ.

444
00:34:03,000 --> 00:34:05,000
ಹೇಗೆ ನಾವು ರಚನೆಯ ಮೊದಲ ಅಂಶ ಸಿಗುತ್ತದೆ?

445
00:34:05,000 --> 00:34:10,000
[ವಿದ್ಯಾರ್ಥಿ] ಸರದಿಗೆ.

446
00:34:10,000 --> 00:34:15,000
[ರಾಬ್ ಬಿ] ಹೌದು, q.strings.

447
00:34:15,000 --> 00:34:20,000
ನೆನಪಿಡಿ, ಇಲ್ಲಿ, ನಮ್ಮ ತಲೆಯ 1.

448
00:34:20,000 --> 00:34:24,000
ಇದು ಡಾರ್ನ್. ನಾನು ಗಿಡ ಮದ್ದಲ್ಲ ಮಾಂತ್ರಿಕವಾಗಿ-

449
00:34:24,000 --> 00:34:29,000
ಇಲ್ಲಿ, ನಮ್ಮ ತಲೆಯ 1. ನಾನು ತುಂಬಾ ನನ್ನ ಬಣ್ಣ ಬದಲಾಯಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ.

450
00:34:29,000 --> 00:34:36,000
ಮತ್ತು ಇಲ್ಲಿ ತಂತಿ ಹೊಂದಿದೆ.

451
00:34:36,000 --> 00:34:41,000
ನಾವು ಇಲ್ಲಿ ಮೇಲೆ ಮಾಡಿದಂತೆ ಈ, ನಾವು ಅದನ್ನು ಬರೆಯಬಹುದು

452
00:34:41,000 --> 00:34:43,000
ತಲೆಗಳ + q.strings.

453
00:34:43,000 --> 00:34:51,000
ಬಹಳಷ್ಟು ಜನರು ಇದನ್ನು ಬರೆಯಲು ಮತ್ತು q.strings [ತಲೆ].

454
00:34:51,000 --> 00:34:55,000
ಈ ನಿಜವಾಗಿಯೂ ಯಾವುದೇ ಕಡಿಮೆ ಸಮರ್ಥವಾಗಿಲ್ಲ.

455
00:34:55,000 --> 00:34:58,000
ನೀವು dereferencing ತದನಂತರ ವಿಳಾಸವನ್ನು ಪಡೆಯುತ್ತಿದ್ದಾರೆ ಎಂದು ನೀವು, ಅದನ್ನು ನಗರದ ಇರಬಹುದು

456
00:34:58,000 --> 00:35:04,000
ಆದರೆ ಕಂಪೈಲರ್ q.strings + ತಲೆ, ಹೇಗಾದರೂ ನಾವು ಮೊದಲು ಹೊಂದಿದ್ದರು ಎಂಬುದನ್ನು ಇದು ಭಾಷಾಂತರಿಸಲು ಹೋಗುತ್ತದೆ.

457
00:35:04,000 --> 00:35:06,000
ನೀವು ನಗರದ ಬಯಸುವ ಯಾವುದೇ ರೀತಿ.

458
00:35:06,000 --> 00:35:11,000
>> ಮತ್ತು ಎಷ್ಟು ಬೈಟ್ಗಳು ನಾವು ನಕಲಿಸಿ ಬಯಸುತ್ತೀರಿ?

459
00:35:11,000 --> 00:35:15,000
[ವಿದ್ಯಾರ್ಥಿ] ಸಾಮರ್ಥ್ಯ - ತಲೆ.

460
00:35:15,000 --> 00:35:18,000
ಸಾಮರ್ಥ್ಯ - ತಲೆ.

461
00:35:18,000 --> 00:35:21,000
ತದನಂತರ ನೀವು ಯಾವಾಗಲೂ ಒಂದು ಉದಾಹರಣೆಯನ್ನು ಬರೆಯಬಹುದಾದರೆ

462
00:35:21,000 --> 00:35:23,000
ಆ ಸರಿ ವೇಳೆ ಔಟ್ ಲೆಕ್ಕಾಚಾರ.

463
00:35:23,000 --> 00:35:26,000
[ವಿದ್ಯಾರ್ಥಿ] ಇದು ನಂತರ 2 ಭಾಗಿಸಿ ಅಗತ್ಯವಿದೆ.

464
00:35:26,000 --> 00:35:30,000
ಹೌದು, ಆದ್ದರಿಂದ ನಾವು ಗಾತ್ರ ಬಳಸಬಹುದೆಂದು ಊಹೆ.

465
00:35:30,000 --> 00:35:35,000
ನಾವು ಇನ್ನೂ ಗಾತ್ರ ಹೊಂದಿವೆ-

466
00:35:35,000 --> 00:35:39,000
ಗಾತ್ರವನ್ನು ಬಳಸಿ, ನಾವು 4 ಸಮನಾದ ಗಾತ್ರವನ್ನು ಹೊಂದಿವೆ.

467
00:35:39,000 --> 00:35:42,000
ನಮ್ಮ ಗಾತ್ರ 4. ನಮ್ಮ ತಲೆಯ 1.

468
00:35:42,000 --> 00:35:46,000
ನಾವು ಈ 3 ಅಂಶಗಳು ನಕಲಿಸಲು ಬಯಸುವ.

469
00:35:46,000 --> 00:35:54,000
ಆ ವಿವೇಕದ ಎಂದು ಗಾತ್ರ ಪರೀಕ್ಷಿಸೋಣ - ತಲೆ ಸರಿಯಾಗಿ 3.

470
00:35:54,000 --> 00:35:58,000
ನಾವು ಮೊದಲೇ ಹೇಳಿದ ಹಾಗೆ ಮತ್ತು,, ಇಲ್ಲಿ ಮರಳಿ ಬರುವ

471
00:35:58,000 --> 00:36:00,000
ನಾವು ಸಾಮರ್ಥ್ಯ ಬಳಸಿದರೆ, ಆಗ 2 ಭಾಗಿಸಿದಾಗ ಮಾಡಿದೆವು

472
00:36:00,000 --> 00:36:04,000
ನಾವು ಈಗಾಗಲೇ ನಮ್ಮ ಸಾಮರ್ಥ್ಯ ಬೆಳೆದ ಮಾಡಿದ ಕಾರಣ, ಆದ್ದರಿಂದ ಬದಲಿಗೆ, ನಾವು ಗಾತ್ರ ಬಳಸಲು ನೀನು.

473
00:36:11,000 --> 00:36:13,000
ಆ ಪ್ರತಿಗಳನ್ನು ಭಾಗವು.

474
00:36:13,000 --> 00:36:18,000
ಈಗ, ನಾವು ಇತರ ಭಾಗದಲ್ಲಿ, ಆರಂಭ ಉಳಿದಿದ್ದು ಭಾಗವು ನಕಲು ಅಗತ್ಯವಿದೆ.

475
00:36:18,000 --> 00:36:28,000
>> ಎಂದು ಯಾವ ಸ್ಥಾನಕ್ಕೆ memmove ಗೆ ವಿಶೇಷವೇನು?

476
00:36:28,000 --> 00:36:32,000
[ವಿದ್ಯಾರ್ಥಿ] ಪ್ಲಸ್ ಗಾತ್ರ - ತಲೆ.

477
00:36:32,000 --> 00:36:38,000
ಹೌದು, ಆದ್ದರಿಂದ ನಾವು ಈಗಾಗಲೇ ಗಾತ್ರದಲ್ಲಿ ನಕಲಿಸಿದ - ತಲೆ ಬೈಟ್ಗಳು,

478
00:36:38,000 --> 00:36:43,000
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಉಳಿದ ಬೈಟ್ಗಳು ನಕಲಿಸಲು ಬಯಸುವ ಅಲ್ಲಿ ಹೊಸ

479
00:36:43,000 --> 00:36:48,000
ತದನಂತರ ಗಾತ್ರ ಮೈನಸ್ ಜೊತೆಗೆ, ಬೈಟ್ಗಳು ಸಂಖ್ಯೆಯನ್ನು ನಾವು ಈಗಾಗಲೇ ಸೈನ್ ನಕಲು ಮಾಡಿದ

480
00:36:48,000 --> 00:36:52,000
ನಂತರ ಅಲ್ಲಿ ನಾವು ನಕಲು ಮಾಡಲಾಗುತ್ತದೆ?

481
00:36:52,000 --> 00:36:54,000
[ವಿದ್ಯಾರ್ಥಿ] Q.strings [0].

482
00:36:54,000 --> 00:36:56,000
[ರಾಬ್ ಬಿ] ಹೌದು, q.strings.

483
00:36:56,000 --> 00:37:02,000
ನಾವು ಎರಡೂ ಏನು & q.strings [0]. ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

484
00:37:02,000 --> 00:37:05,000
ಇದು ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಸಾಮಾನ್ಯವಾಗಿದೆ.

485
00:37:05,000 --> 00:37:14,000
ಇದು ಕೇವಲ 0 ಎಂದು ವಿಶೇಷವೇನು ವೇಳೆ, ನಂತರ ನೀವು q.strings ನೋಡಿ ಒಲವು ಮಾಡುತ್ತೇವೆ.

486
00:37:14,000 --> 00:37:16,000
ನಾವು ನಕಲು ನೀವು ಅಲ್ಲೇ.

487
00:37:16,000 --> 00:37:18,000
ನಾವು ನಕಲಿಸಲು ಎಷ್ಟು ಬೈಟ್ಗಳು ಬಿಟ್ಟು ಇಲ್ಲ? >> [ವಿದ್ಯಾರ್ಥಿ] 10.

488
00:37:18,000 --> 00:37:20,000
ರೈಟ್.

489
00:37:20,000 --> 00:37:25,000
[ವಿದ್ಯಾರ್ಥಿ] ನಾವು 5 ಗುಣಿಸುವುದು ಹೊಂದಿದ್ದೀರಾ - 10 ಬಾರಿ ಬೈಟ್ಗಳು ಅಥವಾ ಏನಾದರೂ ಗಾತ್ರವನ್ನು?

490
00:37:25,000 --> 00:37:30,000
ಹೌದು, ಈ ಅಲ್ಲಿ-ಎಂಬುದನ್ನು ನಾವು ನಕಲು ಪಡೆಯುತ್ತವೆ?

491
00:37:30,000 --> 00:37:32,000
[ವಿದ್ಯಾರ್ಥಿ] [ಕೇಳಿಸುವುದಿಲ್ಲ]

492
00:37:32,000 --> 00:37:34,000
ನಾವು ನಕಲು ಮಾಡುತ್ತಿರುವ ವಿಷಯ ಪ್ರಕಾರ ಯಾವುದು?

493
00:37:34,000 --> 00:37:36,000
[ವಿದ್ಯಾರ್ಥಿ] [ಕೇಳಿಸುವುದಿಲ್ಲ]

494
00:37:36,000 --> 00:37:41,000
ಆ ಮೂಲವನ್ನೂ ಹೌದು, ಚಾರ್ * ರು ನಾವು ನಕಲು ನೀವು ಆದ್ದರಿಂದ, ನಾವು ಗೊತ್ತಿಲ್ಲ.

495
00:37:41,000 --> 00:37:47,000
ಅಲ್ಲದೆ, ಅವರು ಸೂಚಿಸುವ ನೀವು ಅಲ್ಲಿ, ತಂತಿಗಳನ್ನು ನಂತಹ, ನಾವು ಕ್ಯೂ ಮೇಲೆ ತಳ್ಳುವ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ

496
00:37:47,000 --> 00:37:49,000
ಅಥವಾ ಕ್ಯೂ ನಲ್ಲಿಗೆ enqueuing.

497
00:37:49,000 --> 00:37:51,000
ಆ ಮೂಲವನ್ನೂ, ನಾವು ಕಲ್ಪನೆ ಇರಲಿಲ್ಲ.

498
00:37:51,000 --> 00:37:56,000
ನಾವು ಚಾರ್ * ರು ತಮ್ಮ ಟ್ರ್ಯಾಕ್ ಅಗತ್ಯವಿದೆ.

499
00:37:56,000 --> 00:38:00,000
ತಲೆ ಬೈಟ್ಗಳು - ನಾವು ಗಾತ್ರ ನಕಲಿಸಿ ಬಯಸುವುದಿಲ್ಲ.

500
00:38:00,000 --> 00:38:03,000
ತಲೆ ಚಾರ್ * ಗಳು, - ನಾವು ಗಾತ್ರ ನಕಲಿಸಲು ಬಯಸುವ

501
00:38:03,000 --> 00:38:11,000
ಆದ್ದರಿಂದ ನಾವು sizeof (ಚಾರ್ *) ಈ ಗುಣಿಸುವುದು ನೀನು.

502
00:38:11,000 --> 00:38:17,000
ಅದೇ ಕೆಳಗೆ ಇಲ್ಲಿ, ತಲೆ * sizeof (ಚಾರ್ *).

503
00:38:17,000 --> 00:38:24,000
>> [ವಿದ್ಯಾರ್ಥಿ] ಯಾವುದರ ಬಗ್ಗೆ [ಕೇಳಿಸುವುದಿಲ್ಲ]?

504
00:38:24,000 --> 00:38:26,000
ಇಲ್ಲಿ ಈ ಬಲ?

505
00:38:26,000 --> 00:38:28,000
[ವಿದ್ಯಾರ್ಥಿ] ಇಲ್ಲ, ಕೆಳಗಿನ, ಗಾತ್ರ - ತಲೆ.

506
00:38:28,000 --> 00:38:30,000
[ರಾಬ್ ಬಿ] ಇಲ್ಲಿ ಈ ಬಲ?

507
00:38:30,000 --> 00:38:32,000
ಪಾಯಿಂಟರ್ ಅಂಕಗಣಿತದ.

508
00:38:32,000 --> 00:38:35,000
ಪಾಯಿಂಟರ್ ಅಂಕಗಣಿತದ ಕೆಲಸ ಹೋಗುತ್ತದೆ ಹೇಗೆ

509
00:38:35,000 --> 00:38:40,000
ಇದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಾವು ಮಾತಾಡುತ್ತಿದ್ದೀರಿ ಆ ರೀತಿಯ ಗಾತ್ರ ಗುಣಿಸಿದರೆ.

510
00:38:40,000 --> 00:38:46,000
ಕೇವಲ, ಇಲ್ಲಿ ಹೆಚ್ಚು ಇಷ್ಟ ಹೊಸ + (ಗಾತ್ರ - ತಲೆ)

511
00:38:46,000 --> 00:38:56,000
& ಹೊಸ [- ತಲೆಯ ಗಾತ್ರ] ತದ್ವತ್ ಸಮ

512
00:38:56,000 --> 00:39:00,000
ನಾವು, ಸರಿಯಾಗಿ ಕೆಲಸ ನಿರೀಕ್ಷೆ ರವರೆಗೆ

513
00:39:00,000 --> 00:39:04,000
ನಾವು ಒಂದು ಇಂಟ್ ರಚನೆಯ ಮಾತಾಡುತ್ತಿದ್ದೀರಿ ವೇಳೆ ಏಕೆಂದರೆ, ನಾವು ಅದಕ್ಕೆ ಇಂಟ್-ಸೂಚ್ಯಂಕ ಹಾಗೆ

514
00:39:04,000 --> 00:39:07,000
ಆಗಿ ಅಥವಾ 5 ಗಾತ್ರದ ಮತ್ತು ನೀವು 4 ಅಂಶ ಬಯಸಿದರೆ, ನಾವು ಇಂಡೆಕ್ಸ್

515
00:39:07,000 --> 00:39:10,000
ಇಂಟ್ ರಚನೆಯ [4].

516
00:39:10,000 --> 00:39:14,000
ನೀವು don't-[4] ಇಂಟ್ ನ * ಗಾತ್ರ.

517
00:39:14,000 --> 00:39:21,000
ಈ ಸಂದರ್ಭದಲ್ಲಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿಭಾಯಿಸುತ್ತದೆ, ಮತ್ತು

518
00:39:21,000 --> 00:39:29,000
ಅಕ್ಷರಶಃ ಸಮ, ಆದ್ದರಿಂದ ಬ್ರಾಕೆಟ್ ವಾಕ್ಯ

519
00:39:29,000 --> 00:39:34,000
ಕೇವಲ ತಕ್ಷಣ ನೀವು ಕಂಪೈಲ್ ಈ ಪರಿವರ್ತಿಸಬಹುದು ಹೋಗುವ ಇದೆ.

520
00:39:34,000 --> 00:39:38,000
ನೀವು ಆ ಕುರಿತು ಜಾಗರೂಕರಾಗಿರಿ ಅಗತ್ಯವಿದೆ ವಿಷಯ

521
00:39:38,000 --> 00:39:42,000
ನೀವು ಗಾತ್ರ ಸೇರಿಸುವ ಮಾಡಿದಾಗ - ತಲೆಗೆ

522
00:39:42,000 --> 00:39:45,000
ನೀವು ಒಂದು ಬೈಟ್ ಅಲ್ಲ ಸೇರಿಸಿದ್ದರೆ.

523
00:39:45,000 --> 00:39:53,000
ನೀವು ಒಂದು ಬೈಟ್ಗಳು ಅಥವಾ ಯಾವುದೇ ಆಗಿರಬಹುದು, ಒಂದು ಚಾರ್ * ಸೇರಿಸುವುದರಿಂದ ನೀವು.

524
00:39:53,000 --> 00:39:56,000
>> ಇತರ ಪ್ರಶ್ನೆಗಳು?

525
00:39:56,000 --> 00:40:04,000
ಸರಿ, dequeue ಸುಲಭ ಹೋಗುವ ಇದೆ.

526
00:40:04,000 --> 00:40:11,000
ನಾನು ನೀವು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಒಂದು ನಿಮಿಷದ ನೀಡುತ್ತೇನೆ.

527
00:40:11,000 --> 00:40:18,000
ಒಹ್, ನಾನು ಇದೇ ಪರಿಸ್ಥಿತಿಯನ್ನು ಊಹೆ ಅಲ್ಲಿ

528
00:40:18,000 --> 00:40:21,000
ಯಾವ ಎನ್ಕ್ಯೂ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಶೂನ್ಯ enqueuing ಬಳಸುತ್ತಿದ್ದರೆ,

529
00:40:21,000 --> 00:40:24,000
ಬಹುಶಃ ನಾವು ನಿರ್ವಹಿಸಲು ಬಯಸುವ, ಬಹುಶಃ ನಾವು ಮಾಡುವುದಿಲ್ಲ.

530
00:40:24,000 --> 00:40:27,000
ನಾವು ಇಲ್ಲಿ ಮತ್ತೆ ಅದನ್ನು, ಆದರೆ ನಮ್ಮ ಸ್ಟಾಕ್ ಸಂದರ್ಭದಲ್ಲಿ ಅದೇ ಮಾಡುವುದಿಲ್ಲ.

531
00:40:27,000 --> 00:40:34,000
ನಾವು ಶೂನ್ಯ ಎನ್ಕ್ಯೂ ವೇಳೆ, ನಾವು ಅದನ್ನು ನಿರ್ಲಕ್ಷಿಸಿ ಬಯಸಬಹುದು.

532
00:40:34,000 --> 00:40:40,000
ಯಾರಾದರೂ ನಾನು ಬರಬಹುದು ಕೆಲವು ಕೋಡ್ ಹೊಂದಿರುತ್ತವೆ?

533
00:40:40,000 --> 00:40:45,000
[ವಿದ್ಯಾರ್ಥಿ] ನಾನು dequeue ಹೊಂದಿರುತ್ತವೆ.

534
00:40:45,000 --> 00:40:56,000
ಆವೃತ್ತಿ 2 ಅಂದರೆ ತಪ್ಪಿಲ್ಲ.

535
00:40:56,000 --> 00:40:59,000
ನೀವು ವಿವರಿಸಲು ಬಯಸುತ್ತೇನೆ?

536
00:40:59,000 --> 00:41:01,000
[ವಿದ್ಯಾರ್ಥಿ] ಮೊದಲನೆಯದು, ಸರದಿಯಲ್ಲಿ ವಿಷಯವೆಂದರೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ

537
00:41:01,000 --> 00:41:07,000
ಮತ್ತು ಗಾತ್ರ 1 ಕೆಳಗೆ ಹೋಗುತ್ತದೆ ಎಂದು.

538
00:41:07,000 --> 00:41:11,000
ನೀವು ಹಾಗೆ ಮಾಡಬೇಕು, ಮತ್ತು ನಂತರ ನೀವು ತಲೆ ಹಿಂತಿರುಗಿ

539
00:41:11,000 --> 00:41:13,000
ನಂತರ 1 ಅಪ್ ತಲೆ ಸರಿಸಲು.

540
00:41:13,000 --> 00:41:19,000
ಸರಿ, ಆದ್ದರಿಂದ ನಾವು ಪರಿಗಣಿಸಬೇಕಾಗುತ್ತದೆ ಮೂಲೆಗೆ ಉದಾಹರಣೆ ಇಲ್ಲ. ಹೌದು.

541
00:41:19,000 --> 00:41:24,000
[ವಿದ್ಯಾರ್ಥಿ], ನಿಮ್ಮ ತಲೆ ಕೊನೆಯ ಅಂಶ ನಲ್ಲಿ ವೇಳೆ

542
00:41:24,000 --> 00:41:26,000
ನಂತರ ನೀವು ತಲೆ ರಚನೆಯ ಹೊರಗಿರುವ ತೋರಿಸಲು ಬಯಸುವುದಿಲ್ಲ.

543
00:41:26,000 --> 00:41:29,000
>> ಹೌದು, ಆದ್ದರಿಂದ ಬೇಗ ಮುಖ್ಯಸ್ಥ, ನಮ್ಮ ರಚನೆಯ ಕೊನೆಯ ಹಿಟ್ಸ್

544
00:41:29,000 --> 00:41:35,000
ನಾವು dequeue ಮಾಡಿದಾಗ, ನಮ್ಮ ತಲೆಯ 0 ಮರಳಿ ಮಾಡ್ ಮಾಡಿದ ಮಾಡಬೇಕು.

545
00:41:35,000 --> 00:41:40,000
ದುರದೃಷ್ಟವಶಾತ್, ಒಂದು ಹಂತದಲ್ಲಿ ಹಾಗೆ ಮಾಡಬಹುದು.

546
00:41:40,000 --> 00:41:44,000
ನಾನು ಬಹುಶಃ ಅದನ್ನು ಸರಿಪಡಿಸಿ ಬಯಸುವ ರೀತಿಯಲ್ಲಿ ಊಹೆ

547
00:41:44,000 --> 00:41:52,000
ಈ ನಾವು ಹಿಂದಿರುಗಿದ ಏನನ್ನು, ಒಂದು ಚಾರ್ * ಎಂದು ಹೋಗುತ್ತದೆ

548
00:41:52,000 --> 00:41:55,000
ನಿಮ್ಮ ವೇರಿಯಬಲ್ ಹೆಸರು ಬಯಸುತ್ತಾರೆ ಯಾವುದೇ.

549
00:41:55,000 --> 00:42:02,000
ನಾವು ನಮ್ಮ ಸಾಮರ್ಥ್ಯಕ್ಕೆ ತಲೆ ಮಾಡ್ ಬಯಸುವ

550
00:42:02,000 --> 00:42:10,000
ತದನಂತರ ನಿವೃತ್ತ ಹಿಂತಿರುಗಿ.

551
00:42:10,000 --> 00:42:14,000
ಇಲ್ಲಿ ಬಹಳಷ್ಟು ಜನರು ಅವರು ಏನು-ಇರಬಹುದು

552
00:42:14,000 --> 00:42:19,000
ಈ-you'll ಸಂದರ್ಭದಲ್ಲಿ ಆಗಿದೆ ಜನರು ಏನು ನೋಡಿ ವೇಳೆ ತಲೆ

553
00:42:19,000 --> 00:42:29,000
ಸಾಮರ್ಥ್ಯ ಹೆಚ್ಚಾಗಿದೆ, ತಲೆ ಹಾಗೆ - ಸಾಮರ್ಥ್ಯ.

554
00:42:29,000 --> 00:42:36,000
ಮತ್ತು ಕೇವಲ ಮಾಡ್ ಯಾವುದು ಸುತ್ತ ಕಾರ್ಯ.

555
00:42:36,000 --> 00:42:41,000
ಹೆಡ್ ಮಾಡ್ = ಸಾಮರ್ಥ್ಯ ಹೆಚ್ಚು ಸ್ವಚ್ಛವಾಗಿದೆ

556
00:42:41,000 --> 00:42:51,000
ಸಾಮರ್ಥ್ಯ -. ಸುಮಾರು ಸಾಮರ್ಥ್ಯ ತಲೆ ಹೆಚ್ಚು ತಲೆ ಹೆಚ್ಚಿನ ವೇಳೆ ಒಂದು ಜೋಡಣೆಯನ್ನು ಆಫ್

557
00:42:51,000 --> 00:42:56,000
>> ಪ್ರಶ್ನೆಗಳು?

558
00:42:56,000 --> 00:43:02,000
ಸರಿ, ನಾವು ಬಿಟ್ಟು ಕೊನೆಯಲ್ಲಿ ನಮ್ಮ ಲಿಂಕ್ ಪಟ್ಟಿ.

559
00:43:02,000 --> 00:43:07,000
ನೀವು ಮಾಡಿದರೆ ನೀವು ಲಿಂಕ್ ಪಟ್ಟಿ ನಡವಳಿಕೆ ಕೆಲವು ಬಳಸಬಹುದು

560
00:43:07,000 --> 00:43:11,000
ನೀವು ಒಂದು ಹ್ಯಾಶ್ ಕೋಷ್ಟಕದ ಮಾಡಿದರೆ, ನಿಮ್ಮ ಹ್ಯಾಶ್ ಕೋಷ್ಟಕಗಳು ಪಟ್ಟಿಯಲ್ಲಿ ಲಿಂಕ್.

561
00:43:11,000 --> 00:43:15,000
ನಾನು ಬಲವಾಗಿ ಒಂದು ಹ್ಯಾಶ್ ಕೋಷ್ಟಕದ ಮಾಡುವ ಶಿಫಾರಸು.

562
00:43:15,000 --> 00:43:17,000
ನೀವು ಈಗಾಗಲೆ ಒಂದು trie ಮಾಡಿದ ಇರಬಹುದು

563
00:43:17,000 --> 00:43:23,000
ಆದರೆ ಪ್ರಯತ್ನಿಸುತ್ತದೆ ಕಷ್ಟವಾಗುತ್ತದೆ.

564
00:43:23,000 --> 00:43:27,000
ಸಿದ್ಧಾಂತದಲ್ಲಿ, ಅವರು asymptotically ಉತ್ತಮ ಆರ್.

565
00:43:27,000 --> 00:43:30,000
ಆದರೆ, ದೊಡ್ಡ ಬೋರ್ಡ್ ನೋಡಲು

566
00:43:30,000 --> 00:43:35,000
ಮತ್ತು ಚೆನ್ನಾಗಿ ಎಂದಿಗೂ ಪ್ರಯತ್ನಿಸುತ್ತದೆ, ಮತ್ತು ಅವರು ಹೆಚ್ಚು ಮೆಮೊರಿ ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

567
00:43:35,000 --> 00:43:43,000
ಎಲ್ಲದರ ಬಗ್ಗೆ ಅಪ್ ಹೆಚ್ಚಿನ ಕೆಲಸ ಕಳಪೆ ಎಂದು ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಪ್ರಯತ್ನಿಸುತ್ತದೆ.

568
00:43:43,000 --> 00:43:49,000
ಇದು ಡೇವಿಡ್ Malan ಪರಿಹಾರವೆಂದರೆ ಯಾವಾಗಲೂ ಏನು ಇಲ್ಲಿದೆ

569
00:43:49,000 --> 00:43:56,000
ಅವರು ಯಾವಾಗಲೂ ಪೋಸ್ಟ್ಗಳನ್ನು ತನ್ನ trie ಪರಿಹಾರ, ಮತ್ತು ಅವರು ಪ್ರಸ್ತುತ ಅಲ್ಲಿ ನೋಡೋಣ.

570
00:43:56,000 --> 00:44:00,000
ಅವರು ಡೇವಿಡ್ ಜೆ, ಅಡಿಯಲ್ಲಿ ಯಾವುದು?

571
00:44:00,000 --> 00:44:06,000
ಆತ # 18 ನ, ಆ ಭಯಾನಕ ಕೆಟ್ಟ ಅಲ್ಲ ಆದ್ದರಿಂದ

572
00:44:06,000 --> 00:44:09,000
ಮತ್ತು ಉತ್ತಮ ಎಂದು ವಿಶೇಷವೇನು ನೀವು ನಗರದ ಪ್ರಯತ್ನಿಸುತ್ತದೆ

573
00:44:09,000 --> 00:44:17,000
ಅಥವಾ ಉತ್ತಮ ಒಂದು trie ಆಫ್ ಪ್ರಯತ್ನಿಸುತ್ತದೆ.

574
00:44:17,000 --> 00:44:23,000
ಅವರ ಮೂಲ ಪರಿಹಾರ ಕೂಡ ಅಲ್ಲ?

575
00:44:23,000 --> 00:44:29,000
Trie ಪರಿಹಾರಗಳನ್ನು RAM ಬಳಕೆಯ ಈ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಹೆಚ್ಚು ಒಲವು ಹಾಗೆ ನಾನು ಭಾವಿಸುತ್ತೇನೆ.

576
00:44:29,000 --> 00:44:33,000
>> ಬಹಳ ಮೇಲೆ ಕೆಳಗೆ ಹೋಗಿ, ಮತ್ತು RAM ಬಳಕೆಯ ಒಂದೇ ಅಂಕೆಗಳನ್ನು ಹೊಂದಿದೆ.

577
00:44:33,000 --> 00:44:36,000
ಕೆಳಗೆ ಕೆಳಭಾಗಕ್ಕೆ ಹೋಗಿ, ಮತ್ತು ನಂತರ ನೀವು ಪ್ರಯತ್ನಿಸುತ್ತದೆ ಗಮನಕ್ಕೆ

578
00:44:36,000 --> 00:44:41,000
ನೀವು ಸಂಪೂರ್ಣವಾಗಿ ಬೃಹತ್ RAM ಬಳಕೆಯ ಪಡೆಯಲು ಅಲ್ಲಿ,

579
00:44:41,000 --> 00:44:45,000
ಮತ್ತು ಪ್ರಯತ್ನಗಳ ಕಷ್ಟವಾಗುತ್ತದೆ.

580
00:44:45,000 --> 00:44:53,000
ಸಂಪೂರ್ಣವಾಗಿ ಇದನ್ನು ಆದರೆ ಶೈಕ್ಷಣಿಕ ಅನುಭವ ಮೌಲ್ಯದ ನೀವು ಮಾಡಿದರೆ.

581
00:44:53,000 --> 00:44:56,000
ಅಂತಿಮವಾಗಿ, ನಮ್ಮ ಲಿಂಕ್ ಪಟ್ಟಿ

582
00:44:56,000 --> 00:45:04,000
ಮತ್ತು ಈ ಮೂರು ವಿಷಯಗಳನ್ನು, ಸ್ಟ್ಯಾಕ್ಗಳನ್ನು ಸಾಲುಗಳನ್ನು, ಮತ್ತು ಸಂಬಂಧಿತ ಪಟ್ಟಿಗಳನ್ನು,

583
00:45:04,000 --> 00:45:09,000
ಎಂದಾದರೂ ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದಲ್ಲಿ ಯಾವುದೇ ಭವಿಷ್ಯದ ವಿಷಯ

584
00:45:09,000 --> 00:45:12,000
ನೀವು ಈ ವಿಷಯಗಳನ್ನು ಜನಪ್ರಿಯತೆ ಹೊಂದಿವೆ ಹೊಂದಲಿದೆ.

585
00:45:12,000 --> 00:45:19,000
ಅವರು ಎಲ್ಲವನ್ನೂ ಕೇವಲ ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿದೆ.

586
00:45:19,000 --> 00:45:25,000
>> ಪಟ್ಟಿಗಳನ್ನು ಲಿಂಕ್, ಮತ್ತು ಇಲ್ಲಿ ನಾವು ಏಕಸ್ವರೂಪದಲ್ಲಿ ಲಿಂಕ್ ಪಟ್ಟಿ ನಮ್ಮ ಅನುಷ್ಠಾನ ಎಂದು ಹೋಗುತ್ತದೆ ಎಂದು.

587
00:45:25,000 --> 00:45:34,000
ಒಬ್ಬಂಟಿಗನಾಗಿ ಏನು ಸಂಬಂಧ ಇಲ್ಲ ಎಂದು ದುಪ್ಪಟ್ಟು ಲಿಂಕ್ ವಿರುದ್ಧವಾಗಿ ಅರ್ಥ? ಹೌದು.

588
00:45:34,000 --> 00:45:37,000
[ವಿದ್ಯಾರ್ಥಿ] ಇದು ಮಾತ್ರ, ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಬದಲಾಗಿ ಪಾಯಿಂಟರ್ಸ್ ಸೂಚಿತವಾಗಿರುತ್ತದೆ

589
00:45:37,000 --> 00:45:39,000
ಇದು ನಂತರ ಒಂದು ಮುಂಚಿನ ರೀತಿಯಲ್ಲಿ.

590
00:45:39,000 --> 00:45:44,000
ಹೌದು, ಹಾಗೆ ಚಿತ್ರ ರೂಪದಲ್ಲಿ, ನಾನು ಏನು ಮಾಡಿದನು?

591
00:45:44,000 --> 00:45:48,000
ನಾನು ಎರಡು ವಿಷಯಗಳನ್ನು. ನಾನು ಚಿತ್ರವನ್ನು ಮತ್ತು ಚಿತ್ರವನ್ನು ಹೊಂದಿರುತ್ತವೆ.

592
00:45:48,000 --> 00:45:51,000
ಚಿತ್ರ ರೂಪದಲ್ಲಿ, ನಮ್ಮ ಏಕಸ್ವರೂಪದಲ್ಲಿ ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು,

593
00:45:51,000 --> 00:45:57,000
ಅನಿವಾರ್ಯವಾಗಿ, ನಾವು, ನಮ್ಮ ಪಟ್ಟಿಯ ತಲೆಗೆ ಪಾಯಿಂಟರ್ ಕೆಲವು ತರಹದ

594
00:45:57,000 --> 00:46:02,000
ತದನಂತರ ನಮ್ಮ ಪಟ್ಟಿಯಲ್ಲಿ ಒಳಗೆ, ನಾವು, ಪಾಯಿಂಟರ್ಸ್ ಹೊಂದಿವೆ

595
00:46:02,000 --> 00:46:05,000
ಮತ್ತು ಬಹುಶಃ ಈ ಅಂಕಗಳನ್ನು ಶೂನ್ಯ ಗೆ.

596
00:46:05,000 --> 00:46:08,000
ಇದು ಒಂದು ಏಕಸ್ವರೂಪದಲ್ಲಿ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ನಿಮ್ಮ ವಿಶಿಷ್ಟ ಚಿತ್ರ ಎಂದು ವಿಶೇಷವೇನು.

597
00:46:08,000 --> 00:46:14,000
ಎ ದುಪ್ಪಟ್ಟು ಲಿಂಕ್ ಪಟ್ಟಿ, ನೀವು ಹಿಂದಕ್ಕೆ ಹೋಗಿ.

598
00:46:14,000 --> 00:46:19,000
ನಾನು ಪಟ್ಟಿಯಲ್ಲಿ ಯಾವುದೇ ನೋಡ್ ಕೊಟ್ಟರೆ, ಆಗ ನೀವು ಅಗತ್ಯವಿರುವುದಿಲ್ಲ ಪಡೆಯುವುದು

599
00:46:19,000 --> 00:46:23,000
ಯಾವುದೇ ನೋಡ್ ಪಟ್ಟಿಯಲ್ಲಿ ಇದು ದುಪ್ಪಟ್ಟು ಲಿಂಕ್ ಪಟ್ಟಿ ವೇಳೆ.

600
00:46:23,000 --> 00:46:27,000
ಆದರೆ ನಾನು ಪಟ್ಟಿಯಲ್ಲಿ ಮೂರನೆಯ ನೋಡ್ ಪಡೆಯಲು ಮತ್ತು ಅದನ್ನು ಒಂದು ಏಕಸ್ವರೂಪದಲ್ಲಿ ಲಿಂಕ್ ಪಟ್ಟಿ ಇದ್ದರೆ,

601
00:46:27,000 --> 00:46:30,000
ನೀವು ಮೊದಲ ಮತ್ತು ಎರಡನೇ ಗ್ರಂಥಿಗಳು ಪಡೆಯಲು ನೀನು. ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ

602
00:46:30,000 --> 00:46:34,000
ಮತ್ತು ಪ್ರಯೋಜನಗಳನ್ನು ಮತ್ತು ತೊಂದರೆಗಳು, ಮತ್ತು ಒಂದು ಸ್ಪಷ್ಟವಾದ ಒಂದು ಇಲ್ಲ

603
00:46:34,000 --> 00:46:42,000
ನೀವು ಹೆಚ್ಚು ಗಾತ್ರ ತೆಗೆದುಕೊಳ್ಳಬಹುದು, ಮತ್ತು ನೀವು ಈ ವಿಷಯಗಳನ್ನು ಈಗ ತೋರುಗಡ್ಡಿ ಇಲ್ಲಿ ಕಾಪಾಡುವುದು ಹೊಂದಿರುತ್ತವೆ.

604
00:46:42,000 --> 00:46:49,000
ಆದರೆ ನಾವು ಮಾತ್ರ ಒಬ್ಬಂಟಿಗನಾಗಿ ಲಿಂಕ್ ಕೇರ್.

605
00:46:49,000 --> 00:46:53,000
>> ನಾವು ಜಾರಿಗೆ ಮಾಡಲಿಕ್ಕೆ ನೀವು ಕೆಲವು ವಿಷಯಗಳನ್ನು.

606
00:46:53,000 --> 00:47:00,000
ನಿಮ್ಮ typedef struct ನೋಡ್, ಇಂಟ್ ನಾನು: struct ನೋಡ್ * ಮುಂದಿನ; ನೋಡ್.

607
00:47:00,000 --> 00:47:09,000
ಆ typedef ನಿಮ್ಮ ಪ್ರತಿಭೆಯಾಗಿ ಸುಟ್ಟು ಹಾಕಬೇಕು.

608
00:47:09,000 --> 00:47:14,000
ರಸಪ್ರಶ್ನೆ 1, ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ನೋಡ್ ಒಂದು typedef ನೀಡಲು ಹೇಗಿರಬೇಕು

609
00:47:14,000 --> 00:47:18,000
ಮತ್ತು ನೀವು ತಕ್ಷಣ ಆ ಕೆಳಗೆ ಗೀಚುವ ಸಾಧ್ಯವಾಗುತ್ತದೆ

610
00:47:18,000 --> 00:47:22,000
ಸಹ ಭಾವಿಸಲು ಇಲ್ಲದೆ.

611
00:47:22,000 --> 00:47:27,000
ನಾನು ಒಂದೆರಡು ಪ್ರಶ್ನೆಗಳನ್ನು ಊಹೆ, ಏಕೆ ನಾವು ಇಲ್ಲಿ struct ಬೇಕು?

612
00:47:27,000 --> 00:47:32,000
ಏಕೆ ನಾವು ನೋಡ್ * ಹೇಳಲು ಸಾಧ್ಯವಿಲ್ಲ?

613
00:47:32,000 --> 00:47:35,000
[ವಿದ್ಯಾರ್ಥಿ] [ಕೇಳಿಸುವುದಿಲ್ಲ]

614
00:47:35,000 --> 00:47:38,000
ಹೌದು.

615
00:47:38,000 --> 00:47:44,000
ಒಂದು ವಸ್ತುವಿನ ಒಂದು ನೋಡ್ ವರ್ಣಿಸಬಹುದು ಮಾತ್ರ ವಿಷಯ

616
00:47:44,000 --> 00:47:47,000
ಸ್ವತಃ typedef ಹೊಂದಿದೆ.

617
00:47:47,000 --> 00:47:55,000
ಆದರೆ ಈ ಹಂತದಲ್ಲಿ, ನಾವು ಈ struct ನೋಡ್ ವ್ಯಾಖ್ಯಾನದ ಮೂಲಕ ಪಾರ್ಸಿಂಗ್ ರೀತಿಯ ಇರುವಾಗ,

618
00:47:55,000 --> 00:48:01,000
ನಾವು, typedef ಪರಿಪೂರ್ಣವಾಗಿರಲಿಲ್ಲವಾದ ಎಷ್ಟು ರಿಂದ, ಇನ್ನೂ ನಮ್ಮ typedef ಮುಗಿಸಿದರು ಮಾಡಿಲ್ಲ

619
00:48:01,000 --> 00:48:05,000
ನೋಡ್ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ.

620
00:48:05,000 --> 00:48:12,000
ಆದರೆ struct ನೋಡ್ ಮಾಡುತ್ತದೆ, ಮತ್ತು ಈ ನೋಡ್ ಇಲ್ಲಿ,

621
00:48:12,000 --> 00:48:14,000
ಇದು ಬೇರೆ ಏನು ಎಂದು ಕರೆಯಬಹುದು.

622
00:48:14,000 --> 00:48:16,000
ಈ N ಎಂದು ಕರೆಯಬಹುದು.

623
00:48:16,000 --> 00:48:19,000
ಇದು ಸಂಯೋಜಿತ ಪಟ್ಟಿ ನೋಡ್ ಎಂದು ಕರೆಯಬಹುದು.

624
00:48:19,000 --> 00:48:21,000
ಇದು ಏನು ಎಂದು ಕರೆಯಬಹುದು.

625
00:48:21,000 --> 00:48:26,000
ಆದರೆ ಈ struct ನೋಡ್ ಈ struct ನೋಡ್ ಅದೇ ವಿಷಯ ಎಂದು ಅಗತ್ಯವಿದೆ.

626
00:48:26,000 --> 00:48:29,000
ಈ ಸಹ ಇಲ್ಲಿ ಹೊಂದಿದೆ ಎಂದು ಕರೆಯುವ,

627
00:48:29,000 --> 00:48:32,000
ಮತ್ತು ಆದ್ದರಿಂದ ಕೂಡ ಪ್ರಶ್ನೆ ಎರಡನೇ ಹಂತದಲ್ಲಿ ಉತ್ತರಿಸಿದ

628
00:48:32,000 --> 00:48:37,000
ಏಕೆ ಒಂದು ನೀವು ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಮತ್ತು ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಆಫ್ typedefs ನೋಡಿದಾಗ ಬಾರಿ ಸಾಕಷ್ಟು, ಇದು

629
00:48:37,000 --> 00:48:42,000
ನೀವು typedef struct ನೋಡುತ್ತಾರೆ ಅಲ್ಲಿ ನೀವು, ಅನಾಮಧೇಯ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ನೋಡುತ್ತಾರೆ

630
00:48:42,000 --> 00:48:47,000
struct, ನಿಘಂಟು, ಅಥವಾ ಯಾವುದೇ ಅನುಷ್ಠಾನಕ್ಕೆ.

631
00:48:47,000 --> 00:48:51,000
>> ಏಕೆ ಇಲ್ಲಿ ನಾವು ನೋಡ್ ಹೇಳಲು ಬೇಕು?

632
00:48:51,000 --> 00:48:54,000
ಏಕೆ ಅನಾಮಿಕ struct ಸಾಧ್ಯವಿಲ್ಲ?

633
00:48:54,000 --> 00:48:56,000
ಸರಿಸುಮಾರು ಅದೇ ಉತ್ತರದ.

634
00:48:56,000 --> 00:48:58,000
[ವಿದ್ಯಾರ್ಥಿ] ನೀವು struct ಒಳಗೆ ನೋಡಿ ಅಗತ್ಯವಿದೆ.

635
00:48:58,000 --> 00:49:04,000
ಹೌದು, struct ಒಳಗೆ ನೀವು struct ಬಿಟ್ಟು ನೋಡಿ ಅಗತ್ಯವಿದೆ.

636
00:49:04,000 --> 00:49:10,000
ನೀವು struct ಹೆಸರನ್ನು ನೀಡದಿದ್ದಲ್ಲಿ ಇದು ಅನಾಮಧೇಯ struct ಇದ್ದರೆ, ನೀವು ಸೂಚಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

637
00:49:10,000 --> 00:49:17,000
ಮತ್ತು ಕೊನೆಯ ಆದರೆ ಕಡಿಮೆ ಈ ಎಲ್ಲಾ ಇರಬೇಕು ಸ್ವಲ್ಪ ಸರಳವಾಗಿ,

638
00:49:17,000 --> 00:49:20,000
ನೀವು ಈ ಕೆಳಗೆ ನಾವು ಬರೆಯುತ್ತಿದ್ದೇವೆ ವೇಳೆ ಅವರು ನೀವು ಅರ್ಥ ಸಹಾಯ

639
00:49:20,000 --> 00:49:24,000
ವಸ್ತುಗಳ ಈ ರೀತಿಯ ಅರ್ಥ ಇದ್ದರೆ ನೀವು ಏನೋ ಮಾಡುತ್ತಿರುವುದು.

640
00:49:24,000 --> 00:49:28,000
ಕಡೆಯದಾಗಿ, ಏಕೆ ಈ struct ನೋಡ್ * ಎಂದು ಹೊಂದಿದೆ?

641
00:49:28,000 --> 00:49:34,000
ಏಕೆ ಮುಂದಿನ ನೋಡ್ struct ಸಾಧ್ಯವಿಲ್ಲ?

642
00:49:34,000 --> 00:49:37,000
ಮುಂದಿನ struct ಗೆ [ವಿದ್ಯಾರ್ಥಿ] ಪಾಯಿಂಟರ್.

643
00:49:37,000 --> 00:49:39,000
ನಾವು ಯಾವ ಅನಿವಾರ್ಯವಾಗಿ ಇಲ್ಲಿದೆ.

644
00:49:39,000 --> 00:49:42,000
ಏಕೆ ಮುಂದಿನ struct ನೋಡ್ ಸಾಧ್ಯವಿಲ್ಲ?

645
00:49:42,000 --> 00:49:50,000
ಏಕೆ * ಮುಂದಿನ struct ನೋಡ್ ಎಂದು ಹೊಂದಿದೆ? ಹೌದು.

646
00:49:50,000 --> 00:49:53,000
[ವಿದ್ಯಾರ್ಥಿ] ಇದು ಅನಂತ ಆದೇಶಗಳ ಅನಿಸುತ್ತದೆ.

647
00:49:53,000 --> 00:49:55,000
ಹೌದು.

648
00:49:55,000 --> 00:49:57,000
[ವಿದ್ಯಾರ್ಥಿ] ಇದು ಒಂದು ಎಂದು.

649
00:49:57,000 --> 00:50:02,000
ಹೌದು, ನಾವು ಗಾತ್ರವನ್ನು ಅಥವಾ ಏನನ್ನಾದರೂ ಹೇಗೆ ಆಲೋಚಿಸಬೇಕು.

650
00:50:02,000 --> 00:50:08,000
ಒಂದು struct ಗಾತ್ರವು ಮೂಲತಃ + ಅಥವಾ - ಇಲ್ಲಿ ಅಥವಾ ಅಲ್ಲಿ ಕೆಲವು ಮಾದರಿ.

651
00:50:08,000 --> 00:50:15,000
ಇದು ಮೂಲತಃ struct ವಸ್ತುಗಳನ್ನು ಗಾತ್ರಗಳ ಮೊತ್ತವು ಎಂದು ವಿಶೇಷವೇನು.

652
00:50:15,000 --> 00:50:18,000
ಇಲ್ಲಿ ಈ ಹಕ್ಕನ್ನು, ಏನು ಬದಲಿಸದೇ, ಗಾತ್ರ ಸುಲಭ ಎಂದು ಹೋಗುತ್ತದೆ.

653
00:50:18,000 --> 00:50:24,000
Struct ನೋಡ್ನ ಗಾತ್ರವು ಮುಂದಿನ ನಾನು + ಗಾತ್ರದ ಗಾತ್ರ ಎಂದು ಹೋಗುತ್ತದೆ.

654
00:50:24,000 --> 00:50:27,000
ನಾನು ಗಾತ್ರವನ್ನು 4 ಏರಲಿದೆ. ಮುಂದಿನ ಗಾತ್ರ 4 ಏರಲಿದೆ.

655
00:50:27,000 --> 00:50:30,000
Struct ನೋಡ್ನ ಗಾತ್ರವು 8 ಏರಲಿದೆ.

656
00:50:30,000 --> 00:50:34,000
ನಾವು * ಹೊಂದಿಲ್ಲದಿದ್ದರೆ, sizeof ಆಲೋಚನೆಯನ್ನೇ

657
00:50:34,000 --> 00:50:37,000
ನಂತರ sizeof (I) 4 ಏರಲಿದೆ.

658
00:50:37,000 --> 00:50:43,000
Struct ನೋಡ್ನ ಗಾತ್ರವು ಮುಂದಿನ ಮುಂದಿನ struct ನೋಡ್ನ + ಗಾತ್ರ ನಾನು ಗಾತ್ರವನ್ನು ಏರಲಿದೆ

659
00:50:43,000 --> 00:50:46,000
ಮುಂದಿನ struct ನೋಡ್ನ ನಾನು + ಗಾತ್ರದ + ಗಾತ್ರ.

660
00:50:46,000 --> 00:50:55,000
ಇದು ನೋಡ್ಗಳ ಅನಂತ ರಿಕರ್ಶನ್ ಎಂದು.

661
00:50:55,000 --> 00:51:00,000
ಈ ವಿಷಯಗಳನ್ನು ಎಂದು ಹೇಗೆ ಏಕೆ ಇದು.

662
00:51:00,000 --> 00:51:03,000
>> ಮತ್ತೆ, ಖಂಡಿತವಾಗಿ, ಎಂದು ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವ

663
00:51:03,000 --> 00:51:06,000
ಅಥವಾ ಕನಿಷ್ಠ ನೀವು ಸಾಧ್ಯವಾಯಿತು ಎಂದು ಸಾಕಷ್ಟು ಇದು ಅರ್ಥ

664
00:51:06,000 --> 00:51:12,000
ಅದು ಹೇಗಿರಬೇಕೆಂಬ ಮೂಲಕ ಕಾರಣ.

665
00:51:12,000 --> 00:51:14,000
ನಾವು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಯಸುತ್ತೀರಿ ಎಂದು ನೀನು ವಿಷಯಗಳು.

666
00:51:14,000 --> 00:51:18,000
ವೇಳೆ ಉದ್ದ ಪಟ್ಟಿ-

667
00:51:18,000 --> 00:51:21,000
ನೀವು ಮೋಸ ಮತ್ತು ಸುಮಾರು ಇಟ್ಟುಕೊಳ್ಳಬಹುದಾಗಿತ್ತು

668
00:51:21,000 --> 00:51:24,000
ಜಾಗತಿಕ ಉದ್ದ ಅಥವಾ ಏನೋ, ಆದರೆ ನಾವು ಮಾಡಲು ಹೋಗುತ್ತಿಲ್ಲ.

669
00:51:24,000 --> 00:51:28,000
ನಾವು ಪಟ್ಟಿಯ ಉದ್ದವನ್ನು ಲೆಕ್ಕ ನೀನು.

670
00:51:28,000 --> 00:51:34,000
ನಾವು ಹೊಂದಿದೆ ಎಂದು,, ಎಂದು ಮೂಲತಃ ಒಂದು ಹುಡುಕಾಟ ರೀತಿಯಲ್ಲಿ ಹಾಗೆ

671
00:51:34,000 --> 00:51:41,000
ಆದ್ದರಿಂದ ನಾವು ಈ ಪೂರ್ಣಾಂಕ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ವೇಳೆ ನೋಡಲು ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿದ್ದಾರೆ.

672
00:51:41,000 --> 00:51:44,000
ಸೇರಿಸಿ ಪಟ್ಟಿ ಆರಂಭದಲ್ಲಿ ಸೇರಿಸಲು ಹೋಗುತ್ತದೆ.

673
00:51:44,000 --> 00:51:46,000
ಸೇರ್ಪಡಿಸಲಾದ ಕೊನೆಯಲ್ಲಿ ಸೇರಿಸಲು ಹೋಗುತ್ತದೆ.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted ಪಟ್ಟಿಯಲ್ಲಿ ವಿಂಗಡಿಸಲಾದ ಸ್ಥಾನಕ್ಕೆ ಸೇರಿಸಲು ಹೋಗುತ್ತದೆ.

675
00:51:53,000 --> 00:52:01,000
ಆಫ್ Insert_sorted ರೀತಿಯ ನೀವು ಸೇರಿಸಿ ಬಳಸಲಾಗುತ್ತದೆ ಅಥವಾ ಕೆಟ್ಟ ರೀತಿಯಲ್ಲಿ ಸೇರಿಸಲು ಎಂದಿಗೂ ಊಹಿಸುತ್ತದೆ.

676
00:52:01,000 --> 00:52:09,000
>> ನೀವು ಅನುಷ್ಠಾನಕ್ಕೆ ಮಾಡಿದಾಗ insert_sorted-Insert_sorted

677
00:52:09,000 --> 00:52:13,000
ನಮಗೆ ನಮ್ಮ ಲಿಂಕ್ ಪಟ್ಟಿ ಹೊಂದಿವೆ ಸೇ.

678
00:52:13,000 --> 00:52:18,000
ಇದು ಪ್ರಸ್ತುತ 5, 4, 2, ಕಾಣುತ್ತದೆ ಏನು.

679
00:52:18,000 --> 00:52:24,000
ನಾನು, ಆದ್ದರಿಂದ ಎಲ್ಲಿಯವರೆಗೆ ಪಟ್ಟಿಯನ್ನು ಸ್ವತಃ ಈಗಾಗಲೇ ಪ್ರತ್ಯೇಕಿಸಲ್ಪಡುತ್ತವೆ ಎಂದು, 3 ಸೇರಿಸಲು ಬಯಸುವ

680
00:52:24,000 --> 00:52:27,000
ಇದು 3 ಸೇರಿದವನು ಪಡೆಯುವುದು ಸುಲಭ.

681
00:52:27,000 --> 00:52:29,000
ನಾನು 2 ಆರಂಭವಾಗುವುದು.

682
00:52:29,000 --> 00:52:32,000
ಸರಿ, 3 2 ಹೆಚ್ಚಾಗಿದೆ, ಆದ್ದರಿಂದ ನಾನು ಹೋಗುವ ಇರಿಸಿಕೊಳ್ಳಲು ಬಯಸುತ್ತೀರಿ.

683
00:52:32,000 --> 00:52:35,000
ಓಹ್,, 4 ತುಂಬಾ ದೊಡ್ಡದಾಗಿದೆ, ಆದ್ದರಿಂದ ನಾನು 3 2 ಮತ್ತು 4 ನಡುವೆ ಹೋಗುತ್ತಿದ್ದೇವೆ ತಿಳಿದಿದೆ

684
00:52:35,000 --> 00:52:39,000
ಮತ್ತು ನಾನು ಪಾಯಿಂಟರ್ಸ್ ಮತ್ತು ಎಲ್ಲಾ ಸಂಗತಿಗಳನ್ನು ಸರಿಪಡಿಸಲು ಹೊಂದಿರುತ್ತವೆ.

685
00:52:39,000 --> 00:52:43,000
ಆದರೆ ನಾವು ಕಟ್ಟುನಿಟ್ಟಾಗಿ, insert_sorted ಬಳಸಲು ಮಾಡದಿದ್ದಲ್ಲಿ

686
00:52:43,000 --> 00:52:50,000
ಇಷ್ಟ ಈಗ ಕೇವಲ, ನಾನು 6 ಮೊದಲೇ ಉದ್ದೇಶಿಸಬೇಕು ಹೇಳುತ್ತಾರೆ

687
00:52:50,000 --> 00:52:55,000
ನಂತರ ನನ್ನ ಲಿಂಕ್ ಪಟ್ಟಿ ಈ ಆಗಲು ಹೋಗುತ್ತದೆ.

688
00:52:55,000 --> 00:53:01,000
ಈಗ insert_sorted, ನೀವು ಕೇವಲ ಪಡೆದುಕೊಳ್ಳಬಹುದು ಆದ್ದರಿಂದ, ಯಾವುದೇ ಅರ್ಥವಿಲ್ಲ

689
00:53:01,000 --> 00:53:04,000
ಕಾರ್ಯಾಚರಣೆಗಳ ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ ಸಹ ಪಟ್ಟಿಯಲ್ಲಿ ಪ್ರತಿಗಳ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ

690
00:53:04,000 --> 00:53:09,000
ಇದು ಪ್ರತ್ಯೇಕಿಸಬಹುದು ಅಲ್ಲ ಕಾರಣವಾಗಬಹುದು, ಮತ್ತು ಅಷ್ಟೇ.

691
00:53:09,000 --> 00:53:20,000
ಆ ನೀವು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಹೊಂದಿರುವ ನೀನು ಮುಖ್ಯ ವಸ್ತುಗಳು ಅನುಕೂಲಕರ ಇನ್ಸರ್ಟ್-ಆದ್ದರಿಂದ ಕ್ಲಿಕ್.

692
00:53:20,000 --> 00:53:24,000
>> ಇದೀಗ, ಉದ್ದ ಮಾಡಲು ಸಮಯ ಮತ್ತು ಒಳಗೊಂಡಿದೆ

693
00:53:24,000 --> 00:53:30,000
ಮತ್ತು ಆ ತಕ್ಷಣದ ತುಲನಾತ್ಮಕ ಆಗಿರಬೇಕು.

694
00:53:41,000 --> 00:53:48,000
ಮುಕ್ತಾಯದ ಸಮಯವು ಸಮೀಪಿಸುತ್ತಿದೆ, ಆದ್ದರಿಂದ ಯಾರಾದರೂ ಉದ್ದವನ್ನು ಏನೂ ಅಥವಾ ಒಳಗೊಂಡಿದೆ?

695
00:53:48,000 --> 00:53:50,000
ಅವರು ಹೆಚ್ಚುಕಡಿಮೆ ಒಂದೇ ಎಂದು ನೀನು.

696
00:53:50,000 --> 00:53:57,000
[ವಿದ್ಯಾರ್ಥಿ] ಉದ್ದ.

697
00:53:57,000 --> 00:54:01,000
, ನ ನೋಡಿ ಪರಿಷ್ಕರಣೆ ಲೆಟ್.

698
00:54:01,000 --> 00:54:04,000
ಸರಿ.

699
00:54:12,000 --> 00:54:15,000
ನೀವು ವಿವರಿಸಲು ಬಯಸುತ್ತೇನೆ?

700
00:54:15,000 --> 00:54:21,000
[ವಿದ್ಯಾರ್ಥಿ] ನಾನು ಕೇವಲ ಪಾಯಿಂಟರ್ ನೋಡ್ ರಚಿಸಲು ಮತ್ತು ನಮ್ಮ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಇದು ಮೊದಲ, ಇದನ್ನು ಆರಂಭಿಸಲು,

701
00:54:21,000 --> 00:54:27,000
ಮತ್ತು ನಂತರ ನಾನು ಒಂದು seg ತಪ್ಪು ಪಡೆಯಲು ಮತ್ತು ಕೇಸ್ ವೇಳೆ 0 ಹಿಂತಿರುಗಿ ಆದ್ದರಿಂದ ಇದು ಶೂನ್ಯ ಇಲ್ಲಿದೆ ನೀವು ಪರೀಕ್ಷಿಸಿ.

702
00:54:27,000 --> 00:54:34,000
ಇಲ್ಲವಾದರೆ, ನಾನು ಮೂಲಕ ಲೂಪ್, ಪೂರ್ಣಾಂಕ ಒಳಗೆ ಗಮನವಿಡುತ್ತಾ

703
00:54:34,000 --> 00:54:38,000
ನಾನು ಪಟ್ಟಿಯ ಮುಂದಿನ ಅಂಶ ಪ್ರವೇಶಿಸಲು ನೀವು ಎಷ್ಟು ಬಾರಿ

704
00:54:38,000 --> 00:54:43,000
ಮತ್ತು ಅದೇ ಇನ್ಕ್ರಿಮೆಂಟ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಸಹ, ವಾಸ್ತವಿಕ ಅಂಶ ಪ್ರವೇಶಿಸಲು

705
00:54:43,000 --> 00:54:47,000
ತದನಂತರ ನಾನು ನಿರಂತರವಾಗಿ, ಇದು ಶೂನ್ಯ ಇದ್ದರೆ ಚೆಕ್ ನೋಡಿ ಮಾಡಲು

706
00:54:47,000 --> 00:54:56,000
ಇದು ಶೂನ್ಯ ಇದ್ದರೆ ಮತ್ತು ಅದು ಸ್ಥಗಿತಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ನಾನು ಪ್ರವೇಶಿಸಲು ನೀವು ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

707
00:54:56,000 --> 00:55:01,000
>> [ರಾಬ್ ಬಿ] ಯಾರಾದರೂ ಏನು ಯಾವುದೇ ಕಾಮೆಂಟ್ಗಳನ್ನು ಹೊಂದಿದೆಯೇ?

708
00:55:01,000 --> 00:55:06,000
ಈ ದಂಡ ಸರಿಯಾಗಿವೆ ಬುದ್ಧಿವಂತರು ಕಾಣುತ್ತದೆ.

709
00:55:06,000 --> 00:55:10,000
[ವಿದ್ಯಾರ್ಥಿ] ನಾನು ನೀವು ನೋಡ್ == ಶೂನ್ಯ ಅಗತ್ಯವಿದೆ ಯೋಚಿಸುವುದಿಲ್ಲ.

710
00:55:10,000 --> 00:55:13,000
ಹೌದು, ಆದ್ದರಿಂದ ನೋಡ್ ವೇಳೆ == ಶೂನ್ಯ ರಿಟರ್ನ್ 0.

711
00:55:13,000 --> 00:55:18,000
ಆದರೆ ನೋಡ್ == ಶೂನ್ಯ ಈ-OH, ಒಂದು ಸರಿಯಾಗಿವೆ ಸಮಸ್ಯೆ ಇದ್ದರೆ.

712
00:55:18,000 --> 00:55:23,000
ಇದು ಕೇವಲ ನೀವು ನಾನು ಹಿಂದಿರುಗಿದ ಮಾಡುತ್ತಿರುವ, ಆದರೆ ಅದು ಈಗ ವ್ಯಾಪ್ತಿ ಅಲ್ಲ.

713
00:55:23,000 --> 00:55:30,000
ನೀವು ಇಂಟ್ ನಾನು ಅಗತ್ಯವಿದೆ, ಆದ್ದರಿಂದ ನಾನು = 0.

714
00:55:30,000 --> 00:55:34,000
ನೋಡ್ ಶೂನ್ಯ ವೇಳೆ ಆದರೆ, ನಂತರ ನಾನು ಈಗಲೂ 0 ಏರಲಿದೆ

715
00:55:34,000 --> 00:55:39,000
ಮತ್ತು ನಾವು 0 ಮರಳಲು ನೀನು, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಒಂದೇ ಆದ್ದರಿಂದ.

716
00:55:39,000 --> 00:55:48,000
ಮತ್ತೊಂದು ಸಾಮಾನ್ಯ ವಿಷಯವಾಗಿ ಘೋಷಣೆ ಇರಿಸಿಕೊಳ್ಳುವುದೇ

717
00:55:48,000 --> 00:55:51,000
ಲೂಪ್ ದ ನೋಡ್ ಒಳಗೆ.

718
00:55:51,000 --> 00:55:54,000
ನೀವು ಹೇಳುವ-OH ಸಾಧ್ಯವಾಗಲಿಲ್ಲ ಯಾವುದೇ.

719
00:55:54,000 --> 00:55:56,000
ಈ ಮಾಹಿತಿ ಇರಿಸಿಕೊಳ್ಳಲು ನೋಡೋಣ.

720
00:55:56,000 --> 00:55:59,000
ನಾನು ಬಹುಶಃ, ಇಂಟ್ ನಾನು = 0 ಇಲ್ಲಿ ಹಾಕುತ್ತಾನೆ

721
00:55:59,000 --> 00:56:05,000
ನಂತರ ನೋಡ್ * ನೋಡ್ = ಇಲ್ಲಿ ಮೊದಲ.

722
00:56:05,000 --> 00:56:11,000
ಮತ್ತು ಈಗ ಈ ಬಿಡುಗಡೆ ಪಡೆಯುವ ಹೇಗೆ ಬಹುಶಃ.

723
00:56:11,000 --> 00:56:14,000
ಈ ನಾನು ಬರೆದಿದ್ದೇನೆ ಎಂಬುದನ್ನು ಬಹುಶಃ.

724
00:56:14,000 --> 00:56:21,000
ನೀವು ಈ ರೀತಿ ಕೂಡ ಕಾಣುವ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.

725
00:56:21,000 --> 00:56:25,000
ಇಲ್ಲಿಯೇ ಕುಣಿಕೆಯ ರಚನೆಯಲ್ಲಿ ಈ

726
00:56:25,000 --> 00:56:30,000
ಇಂಟ್ ನಾನು = 0 ನಿಮಗೆ ಸುಮಾರು ನೈಸರ್ಗಿಕ ಆಗಿರಬೇಕು

727
00:56:30,000 --> 00:56:33,000
ನಾನು ರಚನೆಯ ಉದ್ದವನ್ನು ಕಡಿಮೆ ನಾನು + +.

728
00:56:33,000 --> 00:56:38,000
ನೀವು ಒಂದು ರಚನೆಯ ಮೇಲೆ ತಿರುಗಿ ಹೇಗೆ, ಈ ನೀವು ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ಮೇಲೆ ತಿರುಗಿ ಹೇಗೆ.

729
00:56:38,000 --> 00:56:45,000
>> ಈ ಹಂತದಲ್ಲಿ ಎರಡನೇ ಪ್ರಕೃತಿ ಇರಬೇಕು.

730
00:56:45,000 --> 00:56:50,000
ಮನಸ್ಸಿನಲ್ಲಿ ಆ ಈ ಬಹುತೇಕ ಒಂದೇ ಎಂದು ಹೋಗುತ್ತದೆ.

731
00:56:50,000 --> 00:56:57,000
ನೀವು ಸಂಬಂಧಿಸಿದ ಪಟ್ಟಿಯ ಮೇಲೆ ಮರಳಿ ಬಯಸುವ ಎಂದು ನೀನು.

732
00:56:57,000 --> 00:57:02,000
ವೇಳೆ ನೋಡ್-ನಾನು ಮೌಲ್ಯ ಎಂದು ಕರೆಯಲ್ಪಡುವ ಕಲ್ಪನೆಯೂ ಇಲ್ಲ.

733
00:57:02,000 --> 00:57:04,000
ನೋಡ್ ನಾನು.

734
00:57:04,000 --> 00:57:15,000
ಆ ನೋಡ್ನಲ್ಲಿ ಮೌಲ್ಯ = ನಾನು ನಿಜವಾದ ಹಿಂದಿರುಗಿ, ಮತ್ತು ಅಷ್ಟೇ ವೇಳೆ.

735
00:57:15,000 --> 00:57:18,000
ಗಮನಿಸಿ ನಾವು ಎಂದಾದರೂ ಸುಳ್ಳು ಮರಳಲು ಕೇವಲ ದಾರಿ

736
00:57:18,000 --> 00:57:23,000
ನಾವು ಇಡೀ ಲಿಂಕ್ ಪಟ್ಟಿ ಮೇಲೆ ಮರಳಿ ಮತ್ತು ನಿಜವಾದ ಮರಳುವುದಿಲ್ಲ ವೇಳೆ ಹೊಂದಿದೆ,

737
00:57:23,000 --> 00:57:29,000
ಆದ್ದರಿಂದ ಅವರ ಈ ಏನು.

738
00:57:29,000 --> 00:57:36,000
ಒಂದು ಅಡ್ಡ ನೋಟ್ ನಾವು ಬಹುಶಃ ಸೇರಿಸಲು ಅಥವಾ ಮೊದಲೇ ಉದ್ದೇಶಿಸಬೇಕು ಗೆ ಸಿಗುವುದಿಲ್ಲ.

739
00:57:36,000 --> 00:57:39,000
>> ತ್ವರಿತ ಕೊನೆಯಾಗಿ ಗಮನಿಸಿ.

740
00:57:39,000 --> 00:57:52,000
ನೀವು ಸ್ಥಬ್ಧ ಕೀವರ್ಡ್ ನೋಡಿ ವೇಳೆ, ಆದ್ದರಿಂದ ಅವರ ಸ್ಥಿರ ಇಂಟ್ ಎಣಿಕೆ = 0 ಹೇಳಲು ಅವಕಾಶ

741
00:57:52,000 --> 00:57:56,000
ನಂತರ ನಾವು ಎಣಿಕೆ ಮಾಡಲು + + ನೀವು ಮೂಲತಃ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಎಂದು ನಗರದ,

742
00:57:56,000 --> 00:58:00,000
ನಾನು ಈ ನಾವು ಉದ್ದ ಕಾರ್ಯಗತಗೊಳಿಸಲು ನೀನು ಹೇಗೆ ಹೇಳಿದ್ದಾರೆ ಕೂಡ.

743
00:58:00,000 --> 00:58:06,000
ನಾನು ಇಲ್ಲಿ ಈ ರೀತಿ, ಮತ್ತು ನಂತರ + + ಎಣಿಕೆ ನುಡಿದರು.

744
00:58:06,000 --> 00:58:11,000
ನಾವು ನಮ್ಮ ಎಣಿಕೆ ಏರಿಕೆಯ ಮಾಡಲಾಗುತ್ತದೆ ನಮ್ಮ ಲಿಂಕ್ ಪಟ್ಟಿ ಒಂದು ನೋಡ್ ನಮೂದಿಸಬಹುದು ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ.

745
00:58:11,000 --> 00:58:15,000
ಈ ಕೇಂದ್ರದಲ್ಲಿ ಸ್ಥಿರ ಕೀವರ್ಡ್ ಅರ್ಥ ಏನು.

746
00:58:15,000 --> 00:58:20,000
ನಾನು ಇಂಟ್ ಎಣಿಕೆ ವೇಳೆ = ನಿಯಮಿತ ಹಳೆಯ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಎಂದು 0.

747
00:58:20,000 --> 00:58:25,000
ಯಾವ ಸ್ಥಿರ ಇಂಟ್ ಎಣಿಕೆ ಎಂದರೆ ಈ ಫೈಲ್ ಒಂದು ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಎಂದು.

748
00:58:25,000 --> 00:58:28,000
ಇದು, ಕೆಲವು ಇತರ ಕಡತ ಅಸಾಧ್ಯ

749
00:58:28,000 --> 00:58:34,000
ನೀವು ಪ್ರಾರಂಭಿಸಿದ ವೇಳೆ, pset 5 ನಗರದ ಇಷ್ಟ.

750
00:58:34,000 --> 00:58:39,000
, ನೀವು ಎರಡೂ speller.c ಹೊಂದಿವೆ, ಮತ್ತು ನೀವು dictionary.c ಹೊಂದಿವೆ

751
00:58:39,000 --> 00:58:42,000
ಮತ್ತು ನೀವು speller.c ನಂತರ, ಏನು ಜಾಗತಿಕ ಒಂದು ವಿಷಯ ಘೋಷಿಸಿದ ವೇಳೆ

752
00:58:42,000 --> 00:58:45,000
dictionary.c ಮತ್ತು ಪ್ರತಿಕ್ರಮದಲ್ಲಿ ಪ್ರವೇಶಿಸಬಹುದು.

753
00:58:45,000 --> 00:58:48,000
ಜಾಗತಿಕ ಚರಾಂಕಗಳ ಯಾವುದೇ. ಸಿ ಫೈಲ್ ಪ್ರವೇಶಿಸಬಹುದು

754
00:58:48,000 --> 00:58:54,000
ಆದರೆ ಸ್ಥಿರ ಚರಾಂಕಗಳ ಕಡತ ಒಳಗೇ ಮಾತ್ರ ಪ್ರವೇಶಿಸಬಹುದು

755
00:58:54,000 --> 00:59:01,000
ಆದ್ದರಿಂದ ಒಳಗೆ dictionary.c ಆಫ್ ಪದಪರೀಕ್ಷಕ ಅಥವಾ ಒಳಗೆ,

756
00:59:01,000 --> 00:59:06,000
ಈ ನನ್ನ ರಚನೆಯ ಗಾತ್ರ ನನ್ನ ವೇರಿಯಬಲ್ ಘೋಷಿಸಲು ಹೇಗೆ ರೀತಿಯ

757
00:59:06,000 --> 00:59:10,000
ಅಥವಾ ನಿಘಂಟು ಪದಗಳ ನನ್ನ ಸಂಖ್ಯೆಯ ಗಾತ್ರ.

758
00:59:10,000 --> 00:59:15,000
ನಾನು ಯಾರಿಗೂ ಪ್ರವೇಶ ಎಂದು ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಘೋಷಿಸಲು ಬಯಸುವುದಿಲ್ಲ ರಿಂದ

759
00:59:15,000 --> 00:59:18,000
ನಾನು ಮಾತ್ರ ನನ್ನ ಸ್ವಂತ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಅದನ್ನು ಕಾಳಜಿ.

760
00:59:18,000 --> 00:59:21,000
>> ಈ ಬಗ್ಗೆ ಒಳ್ಳೆಯದು ಸಂಪೂರ್ಣ ಹೆಸರು ಡಿಕ್ಕಿಯಿಂದ ವಿಷಯವನ್ನು ಹೊಂದಿದೆ.

761
00:59:21,000 --> 00:59:27,000
ಕೆಲವು ಫೈಲ್ ಎಣಿಕೆ ಎಂಬ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಬಳಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ, ವಿಷಯಗಳನ್ನು ತುಂಬಾ ತಪ್ಪು ಹೋಗಿ,

762
00:59:27,000 --> 00:59:33,000
ಆದ್ದರಿಂದ ಈ ಚೆನ್ನಾಗಿ ವಸ್ತುಗಳ ಸುರಕ್ಷಿತ ದೂರವಿಟ್ಟಿದೆ, ಮತ್ತು ಕೇವಲ ನೀವು ಪ್ರವೇಶಿಸಬಹುದು

763
00:59:33,000 --> 00:59:38,000
ಮತ್ತು ಬೇರೆಯವರು ಮಾಡಬಹುದು, ಮತ್ತು ಬೇರೆಯವರು ಎಣಿಕೆ ಎಂಬ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಘೋಷಿಸುತ್ತದೆ ವೇಳೆ,

764
00:59:38,000 --> 00:59:43,000
ನಂತರ ಎಣಿಕೆ ಎಂಬ ನಿಮ್ಮ ಸ್ಥಿರ ವೇರಿಯಬಲ್ ಹಸ್ತಕ್ಷೇಪ ಮಾಡುವುದಿಲ್ಲ.

765
00:59:43,000 --> 00:59:47,000
ಅದು ಸ್ಥಿರವಾಗಿರುತ್ತದೆ ಇಲ್ಲಿದೆ. ಇದು ಒಂದು ಕಡತ ಜಾಗತಿಕ ಅಸ್ಥಿರವಾಗಿದೆ.

766
00:59:47,000 --> 00:59:52,000
>> ಏನು ರಂದು ಪ್ರಶ್ನೆಗಳು?

767
00:59:52,000 --> 00:59:59,000
ಎಲ್ಲಾ ಸೆಟ್. ಬೈ.

768
00:59:59,000 --> 01:00:03,000
[CS50.TV]