1
00:00:07,260 --> 00:00:10,050
[Powered by Google Translate] ಪ್ರೋಗ್ರಾಮಿಂಗ್, ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಅಗತ್ಯವಿದೆ

2
00:00:10,050 --> 00:00:12,840
ಅಂತಹ ಒಂದು ವಿಭಾಗದಲ್ಲಿ ವಿದ್ಯಾರ್ಥಿಗಳು ಹೆಸರುಗಳು

3
00:00:12,840 --> 00:00:15,100
ಇತ್ತೀಚಿನ ರಸಪ್ರಶ್ನೆ ಅಥವಾ ಅವರ ಅಂಕಗಳು.

4
00:00:15,100 --> 00:00:17,430
>> ಸಿ ಭಾಷೆಯಲ್ಲಿ, ಸಾಲುಗಳು ಬಳಸಬಹುದು ಡಿಕ್ಲೇರ್ಡ್

5
00:00:17,430 --> 00:00:19,160
ಪಟ್ಟಿಗಳನ್ನು ಶೇಖರಿಸಿಡಲು.

6
00:00:19,160 --> 00:00:21,200
ಇದು ಪಟ್ಟಿಯ ಅಂಶಗಳನ್ನು ಪಟ್ಟಿ ಸುಲಭ

7
00:00:21,200 --> 00:00:23,390
ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಶೇಖರಿಸಿಡಲಾಗುತ್ತಿತ್ತು, ಮತ್ತು ನೀವು ಪ್ರವೇಶಿಸಲು ಅಗತ್ಯವಿದ್ದರೆ

8
00:00:23,390 --> 00:00:25,050
ಅಥವಾ ಇತ್ ಪಟ್ಟಿ ಅಂಶ ಮಾರ್ಪಡಿಸಿ

9
00:00:25,050 --> 00:00:27,570
ಕೆಲವು ನಿರಂಕುಶ ಸೂಚ್ಯಂಕ ನಾನು,

10
00:00:27,570 --> 00:00:29,910
ಎಂದು, ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಮಾಡಬಹುದು

11
00:00:29,910 --> 00:00:31,660
ಆದರೆ ಸರಣಿಗಳ ತುಂಬಾ, ಅನನುಕೂಲತೆಯನ್ನು ಹೊಂದಿದೆ.

12
00:00:31,660 --> 00:00:33,850
>> ನಾವು ಅವರನ್ನು ಘೋಷಿಸಿದ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಬೇಕಾದ ನೀವು

13
00:00:33,850 --> 00:00:35,900
ಅವರು ಎಷ್ಟು ದೊಡ್ಡ ಮುಂದೆ ಅಪ್,

14
00:00:35,900 --> 00:00:38,160
ಎಂದು ಅವರು ಸಂಗ್ರಹಿಸಬಹುದು ಎಷ್ಟು ಅಂಶಗಳನ್ನು ಹೊಂದಿದೆ

15
00:00:38,160 --> 00:00:40,780
ಮತ್ತು ಹೇಗೆ ದೊಡ್ಡ ಈ ಅಂಶಗಳು, ಅವರ ಪ್ರಕಾರ ನಿರ್ಧರಿಸಲ್ಪಡುತ್ತದೆ ಇದು.

16
00:00:40,780 --> 00:00:45,450
ಉದಾಹರಣೆಗೆ, ಇಂಟ್ ಆಗ (10)

17
00:00:45,450 --> 00:00:48,220
10 ಐಟಂಗಳನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು

18
00:00:48,220 --> 00:00:50,200
ಒಂದು ಇಂಟ್ ಗಾತ್ರವನ್ನು ಹೊಂದಿವೆ.

19
00:00:50,200 --> 00:00:52,590
>> ನಾವು ಘೋಷಣೆ ನಂತರ ಒಂದು ರಚನೆಯ ಗಾತ್ರ ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

20
00:00:52,590 --> 00:00:55,290
ನಾವು ಹೆಚ್ಚು ಅಂಶಗಳನ್ನು ಶೇಖರಿಸಿಡಲು ಬಯಸುವ ನಾವು ಒಂದು ಹೊಸ ಸರಣಿ ಮಾಡಬೇಕು.

21
00:00:55,290 --> 00:00:57,410
ಈ ಮಿತಿಯ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಕಾರಣವೆಂದರೆ ನಮ್ಮ

22
00:00:57,410 --> 00:00:59,040
ಕಾರ್ಯಕ್ರಮದ ಸಂಪೂರ್ಣ ರಚನೆಯ ಸಂಗ್ರಹಿಸುತ್ತದೆ

23
00:00:59,040 --> 00:01:02,310
ಮೆಮೊರಿ ಹೊಂದಿಕೊಂಡಿರುವ ಚಂಕ್ ಮಾಹಿತಿ.

24
00:01:02,310 --> 00:01:04,500
ಈ ನಮ್ಮ ವ್ಯೂಹವನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಅಲ್ಲಿ ಬಫರ್ ಎಂದು ಹೇಳುತ್ತಾರೆ.

25
00:01:04,500 --> 00:01:06,910
ಇತರೆ ಅಂಶಗಳನ್ನು ಉಂಟಾಗಬಹುದು

26
00:01:06,910 --> 00:01:08,310
ರಚನೆಯ ಹಕ್ಕನ್ನು ಮುಂದಿನ ಇದೆ

27
00:01:08,310 --> 00:01:10,060
ಮೆಮೊರಿ ರಲ್ಲಿ, ಆದ್ದರಿಂದ ನಾವು

28
00:01:10,060 --> 00:01:12,060
ಕೇವಲ ಶ್ರೇಣಿಯನ್ನು ದೊಡ್ಡ ಮಾಡಿ.

29
00:01:12,060 --> 00:01:15,700
>> ಕೆಲವೊಮ್ಮೆ ನಾವು ಶ್ರೇಣಿಯನ್ನು ನ ವೇಗದ ಡೇಟಾ ಪ್ರವೇಶ ವೇಗ ವ್ಯಾಪಾರ ಬಯಸುವ

30
00:01:15,700 --> 00:01:17,650
ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸ್ಥಿತಿಸ್ಥಾಪಕತ್ವ.

31
00:01:17,650 --> 00:01:20,380
ಲಿಂಕ್ ಪಟ್ಟಿ, ಇನ್ನೊಂದು ಮೂಲ ಅಕ್ಷಾಂಶ ರಚನೆ ನಮೂದಿಸಿ

32
00:01:20,380 --> 00:01:22,360
ನೀವು ಪರಿಚಿತವಾಗಿಲ್ಲದಿರಬಹುದು ಇರಬಹುದು.

33
00:01:22,360 --> 00:01:24,200
ಒಂದು ಉನ್ನತ ಮಟ್ಟದಲ್ಲಿ,

34
00:01:24,200 --> 00:01:26,840
ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ನೋಡ್ ಅನುಕ್ರಮದಲ್ಲಿನ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ

35
00:01:26,840 --> 00:01:29,280
ಎಂದು, ಕೊಂಡಿಗಳೊಂದಿಗೆ ಪರಸ್ಪರ ಸಂಪರ್ಕ

36
00:01:29,280 --> 00:01:31,760
ಆದ್ದರಿಂದ ಹೆಸರು 'ಲಿಂಕ್ ಪಟ್ಟಿ.'

37
00:01:31,760 --> 00:01:33,840
ವಿನ್ಯಾಸದಲ್ಲಿ ನಾವು ನೋಡುತ್ತಾರೆ ಎಂದು, ಈ ವ್ಯತ್ಯಾಸವನ್ನು

38
00:01:33,840 --> 00:01:35,500
ವಿವಿಧ ಪ್ರಯೋಜನಗಳು ಮತ್ತು ದುಷ್ಪರಿಣಾಮಗಳು ಕಾರಣವಾಗುತ್ತದೆ

39
00:01:35,500 --> 00:01:37,000
ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೆಚ್ಚು.

40
00:01:37,000 --> 00:01:39,840
>> ಇಲ್ಲಿ ಪೂರ್ಣಾಂಕಗಳ ಸರಳ ಲಿಂಕ್ ಪಟ್ಟಿ ಕೆಲವು ಸಿ ಕೋಡ್ ಇಲ್ಲಿದೆ.

41
00:01:39,840 --> 00:01:42,190
ನಾವು ಪ್ರತಿ ನೋಡ್ ನಿರೂಪಿಸಲಾಗಿದೆ ಎಂದು ನೋಡಬಹುದು

42
00:01:42,190 --> 00:01:45,520
2 ವಿಷಯಗಳನ್ನು ಒಳಗೊಂಡಿರುವ struct ಮಾಹಿತಿ ಪಟ್ಟಿಯಲ್ಲಿ,

43
00:01:45,520 --> 00:01:47,280
'ವಾಲ್' ಎಂಬ ಶೇಖರಿಸಿಡಲು ಒಂದು ಪೂರ್ಣಾಂಕ

44
00:01:47,280 --> 00:01:50,460
ಪಟ್ಟಿಯಲ್ಲಿ ಮುಂದಿನ ನೋಡ್ ಮತ್ತು ಲಿಂಕ್

45
00:01:50,460 --> 00:01:52,990
ನಾವು ಎಂಬ ಪಾಯಿಂಟರ್ ಪ್ರತಿನಿಧಿಸುವಂತೆ ಇದು 'ಮುಂದಿನ.'

46
00:01:54,120 --> 00:01:56,780
ಈ ರೀತಿಯಲ್ಲಿ, ನಾವು ಸಂಪೂರ್ಣ ಪಟ್ಟಿ ಟ್ರ್ಯಾಕ್ ಮಾಡಬಹುದು

47
00:01:56,780 --> 00:01:58,790
1 ನೋಡ್ ಕೇವಲ ಒಂದು ಪಾಯಿಂಟರ್,

48
00:01:58,790 --> 00:02:01,270
ನಂತರ ನಾವು ಮುಂದಿನ ಪಾಯಿಂಟರ್ಸ್ ಅನುಸರಿಸಬಹುದು

49
00:02:01,270 --> 00:02:03,130
2 ನೋಡ್ ಗೆ,

50
00:02:03,130 --> 00:02:05,280
3 ನೋಡ್ಗೆ,

51
00:02:05,280 --> 00:02:07,000
4 ನೋಡ್ಗೆ,

52
00:02:07,000 --> 00:02:09,889
ಹೀಗೆ, ನಾವು ಪಟ್ಟಿಯ ಕೊನೆಯಲ್ಲಿ ಪಡೆಯಲು ತನಕ.

53
00:02:10,520 --> 00:02:12,210
>> ಈ ಹೊಂದಿದೆ 1 ಪ್ರಯೋಜನವನ್ನು ನೋಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ

54
00:02:12,210 --> 00:02:14,490
ಸ್ಥಿರ ವ್ಯೂಹ ರಚನೆಯ ಮೇಲೆ - ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿಯನ್ನು,

55
00:02:14,490 --> 00:02:16,450
ನಾವು ಒಟ್ಟಾರೆಯಾಗಿ ಮೆಮೊರಿಯ ಒಂದು ದೊಡ್ಡ ಪಡೆ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ.

56
00:02:17,400 --> 00:02:20,530
ಪಟ್ಟಿಯ 1 ನೋಡ್, ಮೆಮೊರಿ ಈ ಸ್ಥಳದಲ್ಲಿ ವಾಸಿಸುತ್ತಾರೆ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

57
00:02:20,530 --> 00:02:23,160
ಮತ್ತು 2 ನೋಡ್ ಇಲ್ಲಿ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಮಾಡಬಹುದು.

58
00:02:23,160 --> 00:02:25,780
ನೆನಪಿಗಾಗಿ ಅವರು ಅಲ್ಲಿ ನಾವು, ಎಲ್ಲಾ ಘಟಕಗಳು ಯಾವುದೇ ಪಡೆಯುವುದು

59
00:02:25,780 --> 00:02:28,890
ಏಕೆಂದರೆ ಪ್ರತಿ ನೋಡ್ ಮುಂದಿನ ಪಾಯಿಂಟರ್, 1 ನೋಡ್ ಪ್ರಾರಂಭವಾಗುವ

60
00:02:28,890 --> 00:02:31,700
ನಿಖರವಾಗಿ ಅಲ್ಲಿ ಮುಂದಿನ ಹೋಗಲು ನಮಗೆ ಹೇಳುತ್ತದೆ.

61
00:02:31,700 --> 00:02:33,670
>> ಹೆಚ್ಚುವರಿಯಾಗಿ, ನಾವು ಮುಂದೆ ಅಪ್ ಹೇಳಲು ಇಲ್ಲ

62
00:02:33,670 --> 00:02:36,740
ಹೇಗೆ ದೊಡ್ಡ ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ, ನಾವು ಸ್ಥಿರ ಸರಣಿಗಳ ಜೊತೆಗೆ ಮಾರ್ಗವಾಗಿದೆ

63
00:02:36,740 --> 00:02:39,060
ನಾವು ಒಂದು ಪಟ್ಟಿಗೆ ಗ್ರಂಥಿಗಳು ಸೇರಿಸುತ್ತಲೇ ಏಕೆಂದರೆ

64
00:02:39,060 --> 00:02:42,600
ಎಲ್ಲಿಯವರೆಗೆ ಜಾಗವನ್ನು ಹೊಸ ನೋಡ್ಗಳ ಮೆಮೊರಿ ಎಲ್ಲೋ ಇಲ್ಲ ಎಂದು.

65
00:02:42,600 --> 00:02:45,370
ಆದ್ದರಿಂದ, ಸಂಬಂಧಿತ ಪಟ್ಟಿಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಮರುಗಾತ್ರಗೊಳಿಸಲು ಸುಲಭ.

66
00:02:45,370 --> 00:02:47,950
ನಂತರ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ನಾವು ಹೆಚ್ಚು ಗ್ರಂಥಿಗಳು ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ, ಸೇ

67
00:02:47,950 --> 00:02:49,350
ನಮ್ಮ ಪಟ್ಟಿ.

68
00:02:49,350 --> 00:02:51,480
ನೊಣ ನಮ್ಮ ಪಟ್ಟಿಯಲ್ಲಿ ಒಂದು ಹೊಸ ನೋಡ್ ಸೇರಿಸಲು,

69
00:02:51,480 --> 00:02:53,740
ನಾವು ಎಲ್ಲ ಆ ನೋಡ್ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸಲು ಆಗಿದೆ

70
00:02:53,740 --> 00:02:55,630
ಮಾಹಿತಿ ಮೌಲ್ಯ ಸಣ್ಣ ವಸ್ತು ನೇರವಾಗಿ ನೀರಿಗೆ ಬೀಳುವಾಗಿನ ಸಪ್ಪಳ,

71
00:02:55,630 --> 00:02:59,070
ನಾವು ಸೂಕ್ತ ಪಾಯಿಂಟರ್ಸ್ ಸರಿಹೊಂದಿಸಿ ಎಲ್ಲಿ ಮತ್ತು ನಂತರ ಅದನ್ನು.

72
00:02:59,070 --> 00:03:02,310
>> ಉದಾಹರಣೆಗೆ, ನಾವು ನಡುವೆ ಒಂದು ನೋಡ್ ಇರಿಸಲು ಬಯಸಿದರೆ

73
00:03:02,310 --> 00:03:04,020
ಪಟ್ಟಿಯಲ್ಲಿ 2 ನೇ ಮತ್ತು 3 ನೇ ಘಟಕಗಳು,

74
00:03:04,020 --> 00:03:06,800
 ನಾವು 2 ನೇ ಅಥವಾ 3 ನೇ ಗ್ರಂಥಿಗಳು ಸರಿಸಲು ಅಗತ್ಯವಿಲ್ಲ.

75
00:03:06,800 --> 00:03:09,190
ಈ ಕೆಂಪು ನೋಡ್ ತೂರಿಸುವ ನೀವು ಸೇ.

76
00:03:09,190 --> 00:03:12,890
ನಾವು ಬಯಸುವ ಎಲ್ಲಾ ಹೊಸ ನೋಡ್ ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಹೊಂದಿಸಲಾಗಿದೆ

77
00:03:12,890 --> 00:03:14,870
3 ನೋಡ್ ತೋರಿಸಲು

78
00:03:14,870 --> 00:03:18,580
ನಂತರ 2 ನೋಡ್ ಮುಂದಿನ ಪಾಯಿಂಟರ್ rewire

79
00:03:18,580 --> 00:03:20,980
ನಮ್ಮ ಹೊಸ ನೋಡ್ ತೋರಿಸಲು.

80
00:03:22,340 --> 00:03:24,370
ಆದ್ದರಿಂದ, ನಾವು ನೊಣ ನಮ್ಮ ಪಟ್ಟಿಗಳನ್ನು ಮರುಗಾತ್ರಗೊಳಿಸಬಹುದು

81
00:03:24,370 --> 00:03:26,090
ನಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಅನುಕ್ರಮಣಿಕೆ ಅವಲಂಬಿಸದ ಕಾರಣ,

82
00:03:26,090 --> 00:03:28,990
ಆದರೆ ಅವುಗಳನ್ನು ಶೇಖರಿಸಿಡಲು ಪಾಯಿಂಟರ್ಗಳನ್ನು ಲಿಂಕ್ ಮೇಲೆ.

83
00:03:29,120 --> 00:03:31,600
>> ಆದಾಗ್ಯೂ, ಒಂದು ಅನನುಕೂಲವೆಂದರೆ ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು

84
00:03:31,600 --> 00:03:33,370
ಎಂದು, ಒಂದು ಸ್ಥಿರ ಶ್ರೇಣಿಯನ್ನು ಭಿನ್ನವಾಗಿ,

85
00:03:33,370 --> 00:03:36,690
ಕಂಪ್ಯೂಟರ್ ಕೇವಲ ಪಟ್ಟಿಯ ಮಧ್ಯಮ ನೆಗೆಯುವುದನ್ನು ಸಾಧ್ಯವಿಲ್ಲ.

86
00:03:38,040 --> 00:03:40,780
ಕಂಪ್ಯೂಟರ್ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಪ್ರತಿ ನೋಡ್ ಭೇಟಿ ಹೊಂದಿರುವುದರಿಂದ

87
00:03:40,780 --> 00:03:42,330
ಮುಂದಿನ ಒಂದು ಪಡೆಯಲು,

88
00:03:42,330 --> 00:03:44,770
ಇದು ಒಂದು ನಿರ್ದಿಷ್ಟ ನೋಡ್ ಹುಡುಕಲು ಮುಂದೆ ತೆಗೆದುಕೊಳ್ಳುವುದು

89
00:03:44,770 --> 00:03:46,400
ಇದು ಒಂದು ವ್ಯೂಹದಲ್ಲಿ ಹೆಚ್ಚಾಗಿ.

90
00:03:46,400 --> 00:03:48,660
ಸಂಪೂರ್ಣ ಪಟ್ಟಿಯ ಅನುಪಾತ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಹಾದುಹೋಗಬೇಕಾದರೆ

91
00:03:48,660 --> 00:03:50,580
ಪಟ್ಟಿಯ ಉದ್ದ,

92
00:03:50,580 --> 00:03:54,630
ಅಥವಾ O (N) ಅಸಂಪಾತ ಸಂಕೇತಗಳಲ್ಲಿ.

93
00:03:54,630 --> 00:03:56,510
ಸರಾಸರಿ, ಯಾವುದೇ ನೋಡ್ ತಲುಪುವ

94
00:03:56,510 --> 00:03:58,800
ಸಮಯ N ಅನುಪಾತದಲ್ಲಿರುತ್ತದೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

95
00:03:58,800 --> 00:04:00,700
>> ಈಗ ಕೆಲವು ಕೋಡ್ ಬರೆಯೋಣ

96
00:04:00,700 --> 00:04:02,000
ಆ ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

97
00:04:02,000 --> 00:04:04,220
ನಮಗೆ ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ಬಯಸುವ ಹೇಳುತ್ತಾರೆ.

98
00:04:04,220 --> 00:04:06,140
ನಾವು ಮತ್ತೆ ನಮ್ಮ ಪಟ್ಟಿಯಲ್ಲಿ ಒಂದು ನೋಡ್ ಪ್ರತಿನಿಧಿಸಬಹುದು

99
00:04:06,140 --> 00:04:08,340
2 ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ಒಂದು struct ಮಾಹಿತಿ,

100
00:04:08,340 --> 00:04:10,750
'ವಾಲ್' ಎಂಬ ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯ

101
00:04:10,750 --> 00:04:13,490
ಮತ್ತು ಪಟ್ಟಿಯ ಮುಂದಿನ ನೋಡ್ಗೆ ಒಂದು ಪಾಯಿಂಟರ್ ಮುಂದಿನ.

102
00:04:13,490 --> 00:04:15,660
ಅಲ್ಲದೆ, ಸಾಕಷ್ಟು ಸರಳ ತೋರುತ್ತದೆ.

103
00:04:15,660 --> 00:04:17,220
>> ನಮಗೆ ಒಂದು ಫಂಕ್ಷನ್ ಬರೆಯಲು ಬಯಸುವ ಹೇಳುತ್ತಾರೆ

104
00:04:17,220 --> 00:04:19,329
ಅಡ್ಡಹಾಯುವ ಔಟ್ ಪಟ್ಟಿ ಮತ್ತು ಮುದ್ರಿತ

105
00:04:19,329 --> 00:04:22,150
ಮೌಲ್ಯ ಪಟ್ಟಿಯಲ್ಲಿ ಕೊನೆಯ ನೋಡ್ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ.

106
00:04:22,150 --> 00:04:24,850
ಹಾಗೆಯೇ, ನಾವು ಪಟ್ಟಿಯಲ್ಲಿ ಎಲ್ಲಾ ನೋಡ್ಗಳು ಹಾದುಹೋಗಬೇಕಾದರೆ ಅಗತ್ಯವಿದೆ ಅರ್ಥ

107
00:04:24,850 --> 00:04:27,310
ಕಳೆದ ಒಂದು ಹುಡುಕಲು, ಆದರೆ ನಾವು ಸೇರಿಸುವ ಇಲ್ಲ ರಿಂದ

108
00:04:27,310 --> 00:04:29,250
ಅಥವಾ ಏನು ಅಳಿಸುವುದು, ನಾವು ಬದಲಾಯಿಸಲು ಬಯಸುವುದಿಲ್ಲ

109
00:04:29,250 --> 00:04:32,210
ಪಟ್ಟಿಯಲ್ಲಿ ಮುಂದಿನ ಪಾಯಿಂಟರ್ಸ್ ಆಂತರಿಕ ರಚನೆ.

110
00:04:32,210 --> 00:04:34,790
>> ಆದ್ದರಿಂದ, ನಾವು ಅಡ್ಡಹಾಯುವುದನ್ನು ನಿರ್ದಿಷ್ಟವಾಗಿ ಒಂದು ಪಾಯಿಂಟರ್ ಅಗತ್ಯವಿದೆ

111
00:04:34,790 --> 00:04:36,940
ಇದು ನಾವು 'ಸಂಚಾರಿ.' ಕರೆ ಮಾಡುತ್ತೇವೆ

112
00:04:36,940 --> 00:04:38,870
ಪಟ್ಟಿಯಲ್ಲಿ ಎಲ್ಲಾ ಅಂಶಗಳ ಮೂಲಕ ಕ್ರಾಲ್ ಮಾಡುತ್ತದೆ

113
00:04:38,870 --> 00:04:41,190
ಮುಂದಿನ ಪಾಯಿಂಟರ್ಗಳ ಸರಣಿ ಅನುಸರಿಸಿ.

114
00:04:41,190 --> 00:04:43,750
ನಾವು ಸಂಗ್ರಹಿಸಿದ ಎಲ್ಲಾ, 1st ನೋಡ್ಗೆ ಒಂದು ಪಾಯಿಂಟರ್ ಆಗಿದೆ

115
00:04:43,750 --> 00:04:45,730
ಪಟ್ಟಿ ಅಥವಾ 'ತಲೆ'.

116
00:04:45,730 --> 00:04:47,370
1st ನೋಡ್ಗೆ ಹೆಡ್ ಅಂಕಗಳನ್ನು.

117
00:04:47,370 --> 00:04:49,120
ಇದು ರೀತಿಯ ಪಾಯಿಂಟರ್ ಟು ನೋಡ್ನ ಇಲ್ಲಿದೆ.

118
00:04:49,120 --> 00:04:51,280
>> ಪಟ್ಟಿಯಲ್ಲಿ ನಿಜವಾದ 1 ನೋಡ್ ಪಡೆಯಲು,

119
00:04:51,280 --> 00:04:53,250
ನಾವು, dereference ಈ ಪಾಯಿಂಟರ್ ಹೊಂದಿವೆ

120
00:04:53,250 --> 00:04:55,100
ನಾವು dereference ಮೊದಲು ಆದರೆ, ನಾವು ಪರಿಶೀಲಿಸಬೇಕು

121
00:04:55,100 --> 00:04:57,180
ಪಾಯಿಂಟರ್ ಮೊದಲ ಶೂನ್ಯ ವೇಳೆ.

122
00:04:57,180 --> 00:04:59,190
ಇದು ಶೂನ್ಯ ನ ವೇಳೆ, ಪಟ್ಟಿಯನ್ನು ಖಾಲಿಯಾಗಿದೆ

123
00:04:59,190 --> 00:05:01,320
ಮತ್ತು ನಾವು, ಪಟ್ಟಿ ಖಾಲಿಯಾಗಿದೆ ಏಕೆಂದರೆ, ಒಂದು ಸಂದೇಶವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ ಮಾಡಬೇಕು

124
00:05:01,320 --> 00:05:03,250
ಕೊನೆಯ ನೋಡ್ ಇರುವುದಿಲ್ಲ.

125
00:05:03,250 --> 00:05:05,190
ಆದರೆ, ಅವಕಾಶ ಪಟ್ಟಿಯಲ್ಲಿ ಖಾಲಿ ಎಂದು ಹೇಳುತ್ತಾರೆ.

126
00:05:05,190 --> 00:05:08,340
ಇದು ಅಲ್ಲ, ಆಗ ನಾವು ಸಂಪೂರ್ಣ ಪಟ್ಟಿ ಮೂಲಕ ಕ್ರಾಲ್ ಮಾಡಬೇಕೆಂದು

127
00:05:08,340 --> 00:05:10,440
ನಾವು ಪಟ್ಟಿಯಲ್ಲಿ ಕೊನೆಯ ನೋಡ್ ಪಡೆಯಲು ತನಕ,

128
00:05:10,440 --> 00:05:13,030
ಮತ್ತು ನಾವು ಪಟ್ಟಿಯಲ್ಲಿ ಕೊನೆಯ ನೋಡ್ ನಲ್ಲಿ ಹುಡುಕುತ್ತಿರುವ ವೇಳೆ ಹೇಗೆ ನಮಗೆ?

129
00:05:13,670 --> 00:05:16,660
>> ಅಲ್ಲದೆ, ಒಂದು ನೋಡ್ ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಶೂನ್ಯ ವೇಳೆ,

130
00:05:16,660 --> 00:05:18,320
ನಾವು ಕೊನೆಯಲ್ಲಿ ನಾವು ತಿಳಿಯುವ

131
00:05:18,320 --> 00:05:22,390
ಕೊನೆಯ ಮುಂದಿನ ಪಾಯಿಂಟರ್ ತೋರಿಸಲು ಪಟ್ಟಿಯಲ್ಲಿ ಯಾವುದೇ ಮುಂದಿನ ನೋಡ್ ಹೊಂದಿರುತ್ತವೆ ಏಕೆಂದರೆ.

132
00:05:22,390 --> 00:05:26,590
ಯಾವಾಗಲೂ ಶೂನ್ಯವಾಗಿ ಆರಂಭಿಸಲಾಗಿಲ್ಲ ಕೊನೆಯ ನೋಡ್ ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಇರಿಸಿಕೊಳ್ಳಲು ಉತ್ತಮ ಇಲ್ಲಿದೆ

133
00:05:26,590 --> 00:05:30,800
ನಾವು ಪಟ್ಟಿಯ ಕೊನೆಯಲ್ಲಿ ತಲುಪಿದ್ದೀರಿ ಯಾವಾಗ ನಮ್ಮನ್ನು ಎಚ್ಚರಿಸುತ್ತದೆ ಒಂದು ಪ್ರಮಾಣಕವಾಗಿಸಿದ ಗುಣವನ್ನು ಹೊಂದಿರುವುದು.

134
00:05:30,800 --> 00:05:33,510
>> ಆದ್ದರಿಂದ, ಸಂಚಾರಿ → ಮುಂದಿನ ಶೂನ್ಯ ವೇಳೆ,

135
00:05:34,120 --> 00:05:38,270
ಬಾಣದ ವಾಕ್ಯ dereferencing ಒಂದು ಶಾರ್ಟ್ಕಟ್ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ

136
00:05:38,270 --> 00:05:40,010
ಒಂದು struct ಒಂದು ಪಾಯಿಂಟರ್, ನಂತರ ಪ್ರವೇಶಿಸುವ

137
00:05:40,010 --> 00:05:42,510
ಎಡವಟ್ಟಾದ ಸಮಾನವಾದ ಅದರ ಮುಂದಿನ ಕ್ಷೇತ್ರ:

138
00:05:42,510 --> 00:05:48,750
(* ಸಂಚಾರಿ). ಮುಂದಿನ.

139
00:05:49,820 --> 00:05:51,260
ಒಮ್ಮೆ ನಾವು, ಕೊನೆಯ ನೋಡ್ ಕಂಡುಬಂದರೆ

140
00:05:51,260 --> 00:05:53,830
ನಾವು, ಸಂಚಾರಿ → Val ಮುದ್ರಿಸಲು ಬಯಸುವ

141
00:05:53,830 --> 00:05:55,000
ಪ್ರಸ್ತುತ ನೋಡ್ನಲ್ಲಿ ಮೌಲ್ಯ

142
00:05:55,000 --> 00:05:57,130
ಇದು ನಾವು ತಿಳಿದಿರುವ ಕೊನೆಯಾಗಿ ಒಂದಾಗಿದೆ.

143
00:05:57,130 --> 00:05:59,740
ಇಲ್ಲವಾದರೆ, ನಾವು ಪಟ್ಟಿಯಲ್ಲಿ ಕೊನೆಯ ನೋಡ್ ಇನ್ನೂ ಇಂತಹ,

144
00:05:59,740 --> 00:06:02,340
ನಾವು ಪಟ್ಟಿಯಲ್ಲಿ ಮುಂದಿನ ನೋಡ್ ಗೆ ಸ್ಥಳಾಂತರಿಸಲು

145
00:06:02,340 --> 00:06:04,750
ಕಳೆದ ಒಂದಾಗಿದೆ ವೇಳೆ ಮತ್ತು ಪರಿಶೀಲಿಸಿ.

146
00:06:04,750 --> 00:06:07,010
ಇದನ್ನು ಮಾಡಲು, ನಾವು ನಮ್ಮ ಕ್ರಾಲರ್ ಪಾಯಿಂಟರ್ ಸೆಟ್

147
00:06:07,010 --> 00:06:09,840
ಪ್ರಸ್ತುತ ನೋಡ್ ಮುಂದಿನ ಮೌಲ್ಯಕ್ಕೆ ತೋರಿಸಲು,

148
00:06:09,840 --> 00:06:11,680
ಎಂದು, ಪಟ್ಟಿಯಲ್ಲಿ ಮುಂದಿನ ನೋಡ್.

149
00:06:11,680 --> 00:06:13,030
ಈ ಸೆಟ್ಟಿಂಗ್ ಮಾಡಲಾಗುತ್ತದೆ

150
00:06:13,030 --> 00:06:15,280
ಸಂಚಾರಿ = ಕ್ರಾಲರ್ → ಮುಂದಿನ.

151
00:06:16,050 --> 00:06:18,960
ನಂತರ ನಾವು, ಉದಾಹರಣೆಗೆ ಒಂದು ಲೂಪ್ ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪುನರಾವರ್ತಿಸುವಂತೆ

152
00:06:18,960 --> 00:06:20,960
ನಾವು ಕೊನೆಯ ನೋಡ್ ಹೇಗೆ ರವರೆಗೆ.

153
00:06:20,960 --> 00:06:23,150
ಆದ್ದರಿಂದ, ಉದಾಹರಣೆಗೆ, ಸಂಚಾರಿ ತಲೆಗೆ ತೋರುಗಡ್ಡಿ ಎಂದು,

154
00:06:24,050 --> 00:06:27,710
ನಾವು, ಸಂಚಾರಿ → ಮುಂದಿನ ತೋರಿಸಲು ಕ್ರಾಲರ್ ಸೆಟ್

155
00:06:27,710 --> 00:06:30,960
ಇದು 1 ನೋಡ್ ಮುಂದಿನ ಕ್ಷೇತ್ರ ಅದೇ ಆಗಿದೆ.

156
00:06:30,960 --> 00:06:33,620
ಆದ್ದರಿಂದ, ಈಗ ನಮ್ಮ ಕ್ರಾಲರ್, 2 ನೋಡ್ ತೋರುತ್ತಿರುವಂತೆ ಇದೆ

157
00:06:33,620 --> 00:06:35,480
ಮತ್ತು, ಮತ್ತೆ, ನಾವು, ಲೂಪ್ ಈ ಪುನರಾವರ್ತಿಸಲು

158
00:06:37,220 --> 00:06:40,610
ನಾವು ಕೊನೆಯ ನೋಡ್ ಕಂಡುಬಂದರೆ ತನಕ, ಅಂದರೆ,

159
00:06:40,610 --> 00:06:43,640
ಅಲ್ಲಿ ನೋಡ್ ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಶೂನ್ಯ ತೋರುತ್ತಿರುವಂತೆ ಇದೆ.

160
00:06:43,640 --> 00:06:45,070
ಮತ್ತು ನಾವು, ಅದರ

161
00:06:45,070 --> 00:06:47,620
ನಾವು ಪಟ್ಟಿಯಲ್ಲಿ ಕೊನೆಯ ನೋಡ್ ಕಂಡುಬಂದರೆ, ಮತ್ತು ಅದರ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸಲು,

162
00:06:47,620 --> 00:06:50,800
ನಾವು ಕ್ರಾಲರ್ → Val ಬಳಸಿ.

163
00:06:50,800 --> 00:06:53,130
>> ಗ್ಯಾಲರಿ ಆದ್ದರಿಂದ ಕೆಟ್ಟ, ಆದರೆ ಏನು ಅಳವಡಿಸುವುದರ ಬಗ್ಗೆ?

164
00:06:53,130 --> 00:06:56,290
ಅನುಮತಿಸುತ್ತದೆ ನಾವು 4 ನೇ ಸ್ಥಾನಕ್ಕೆ ಒಂದು ಪೂರ್ಣಾಂಕ ಸೇರಿಸಲು ಬಯಸುವ ಹೇಳುತ್ತಾರೆ

165
00:06:56,290 --> 00:06:58,040
ಒಂದು ಪೂರ್ಣಾಂಕ ಪಟ್ಟಿಯಲ್ಲಿ.

166
00:06:58,040 --> 00:07:01,280
ಪ್ರಸ್ತುತ 3 ನೇ ಮತ್ತು 4 ನೇ ಘಟಕಗಳು ನಡುವೆ.

167
00:07:01,280 --> 00:07:03,760
ಮತ್ತೆ, ನಾವು ಪಟ್ಟಿಯನ್ನು ಹಾದುಹೋಗಬೇಕಾದರೆ ಹೊಂದಿವೆ

168
00:07:03,760 --> 00:07:06,520
3 ಅಂಶ, ನಾವು ನಂತರ ತೂರಿಸುವ ನೀವು ಒಂದು ಪಡೆಯಲು.

169
00:07:06,520 --> 00:07:09,300
ಆದ್ದರಿಂದ, ನಾವು, ಪಟ್ಟಿ ಹಾದುಹೋಗಬೇಕಾದರೆ ಮತ್ತೆ ಕ್ರಾಲರ್ ಪಾಯಿಂಟರ್ ರಚಿಸಲು

170
00:07:09,300 --> 00:07:11,400
ನಮ್ಮ ತಲೆಯ ಪಾಯಿಂಟರ್ ಶೂನ್ಯ ವೇಳೆ, ಪರಿಶೀಲಿಸಿ

171
00:07:11,400 --> 00:07:14,810
ಇದು ಅಲ್ಲ ವೇಳೆ ಮತ್ತು, ತಲೆ ನೋಡ್ ನಮ್ಮ ಕ್ರಾಲರ್ ಪಾಯಿಂಟರ್ ಸೂಚಿಸುತ್ತಾರೆ.

172
00:07:16,880 --> 00:07:18,060
ಆದ್ದರಿಂದ, ನಾವು 1 ಅಂಶ ನಲ್ಲಿ ಆರ್.

173
00:07:18,060 --> 00:07:21,020
ನಾವು ಸೇರಿಸಲು ಮೊದಲು 2 ಹೆಚ್ಚು ಅಂಶಗಳನ್ನು ಮುಂದೆ ಹೋಗಬೇಕಾಗುತ್ತದೆ

174
00:07:21,020 --> 00:07:23,390
ಆದ್ದರಿಂದ ನಾವು ಲೂಪ್ ಒಂದು ಬಳಸಬಹುದು

175
00:07:23,390 --> 00:07:26,430
ಇಂಟ್ I = 1; ನಾನು <3; ನಾನು + +

176
00:07:26,430 --> 00:07:28,590
ಮತ್ತು ಲೂಪ್ ಪ್ರತಿಯೊಂದು ಪುನರಾವರ್ತನೆ ರಲ್ಲಿ,

177
00:07:28,590 --> 00:07:31,540
1 ನೋಡ್ ಮುಂದಕ್ಕೆ ನಮ್ಮ ಕ್ರಾಲರ್ ಪಾಯಿಂಟರ್ ಮುನ್ನಡೆ

178
00:07:31,540 --> 00:07:34,570
ಪ್ರಸ್ತುತ ನೋಡ್ ಮುಂದಿನ ಕ್ಷೇತ್ರ ಶೂನ್ಯ ವೇಳೆ ಪರಿಶೀಲಿಸುವ ಮೂಲಕ,

179
00:07:34,570 --> 00:07:37,550
ಇದು ಅಲ್ಲ ವೇಳೆ ಮತ್ತು ಮುಂದಿನ ನೋಡ್ ನಮ್ಮ ಕ್ರಾಲರ್ ಪಾಯಿಂಟರ್ ಸರಿಸಲು

180
00:07:37,550 --> 00:07:41,810
ಪ್ರಸ್ತುತ ನೋಡ್ ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಇದು ಸಮಾನ ಹೊಂದಿಸುವ ಮೂಲಕ.

181
00:07:41,810 --> 00:07:45,210
ಆದ್ದರಿಂದ, ನಮ್ಮ ಕಾಲ ಲೂಪ್ ಮಾಡಲು ಹೇಳುತ್ತಾರೆ ರಿಂದ

182
00:07:45,210 --> 00:07:47,550
ಎರಡು ಬಾರಿ,

183
00:07:49,610 --> 00:07:51,190
ನಾವು, 3 ನೋಡ್ ತಲುಪಿದ್ದೀರಿ

184
00:07:51,190 --> 00:07:53,110
ಮತ್ತು ಒಮ್ಮೆ ನಮ್ಮ ಕ್ರಾಲರ್ ಪಾಯಿಂಟರ್ ನಂತರ ನೋಡ್ ತಲುಪಿದೆ

185
00:07:53,110 --> 00:07:55,270
ಇದು ನಾವು, ನಮ್ಮ ಹೊಸ ಪೂರ್ಣಾಂಕ ಸೇರಿಸಲು ಬಯಸುವ

186
00:07:55,270 --> 00:07:57,050
ಹೇಗೆ ನಾವು ವಾಸ್ತವವಾಗಿ ತೂರಿಸುವ ಮಾಡುತ್ತೀರಾ?

187
00:07:57,050 --> 00:07:59,440
>> ಅಲ್ಲದೆ, ನಮ್ಮ ಹೊಸ ಪೂರ್ಣಾಂಕ ಪಟ್ಟಿಯಲ್ಲಿ ಸೇರಿಸಿದ ಮಾಡಬೇಕು

188
00:07:59,440 --> 00:08:01,250
ತನ್ನದೇ ನೋಡ್ struct ಭಾಗವಾಗಿ,

189
00:08:01,250 --> 00:08:03,140
ಈ ನಿಜವಾಗಿಯೂ ನೋಡ್ ಅನುಕ್ರಮ ಕಾರಣ.

190
00:08:03,140 --> 00:08:05,690
ಆದ್ದರಿಂದ, ನ ನೋಡ್ಗೆ ಹೊಸ ಪಾಯಿಂಟರ್ ಮಾಡೋಣ

191
00:08:05,690 --> 00:08:08,910
'new_node,' ಎಂದು

192
00:08:08,910 --> 00:08:11,800
ಮತ್ತು ಸೆಟ್ ನಾವು ಈಗ ನಿಯೋಜಿಸಿ ಎಂದು ಮೆಮೊರಿ ತೋರಿಸಲು

193
00:08:11,800 --> 00:08:14,270
ನೋಡ್ ಸ್ವತಃ ರಾಶಿ ಮೇಲೆ,

194
00:08:14,270 --> 00:08:16,000
ಮತ್ತು ನಾವು ನಿಗದಿಪಡಿಸಬೇಕಾಗುತ್ತದೆ ಎಷ್ಟು ಮೆಮೊರಿ ಬೇಕು?

195
00:08:16,000 --> 00:08:18,250
ಅಲ್ಲದೆ, ಒಂದು ನೋಡ್ ಗಾತ್ರವನ್ನು,

196
00:08:20,450 --> 00:08:23,410
ಮತ್ತು ನಾವು ಸೇರಿಸಲು ಬಯಸುವ ಪೂರ್ಣಾಂಕ ತನ್ನ Val ಕ್ಷೇತ್ರದಲ್ಲಿ ಹೊಂದಿಸಲು ಬಯಸುವ.

197
00:08:23,410 --> 00:08:25,590
ಲೆಟ್ಸ್ 6, ಹೇಳುತ್ತಾರೆ.

198
00:08:25,590 --> 00:08:27,710
ಈಗ, ನೋಡ್ ನಮ್ಮ ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯ ಹೊಂದಿದೆ.

199
00:08:27,710 --> 00:08:30,650
ಹೊಸ ನೋಡ್ ಮುಂದಿನ ಕ್ಷೇತ್ರ ಆರಂಭಿಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸ ಇಲ್ಲಿದೆ

200
00:08:30,650 --> 00:08:33,690
ಶೂನ್ಯ ತೋರಿಸಲು,

201
00:08:33,690 --> 00:08:35,080
ಆದರೆ ಈಗ?

202
00:08:35,080 --> 00:08:37,179
>> ನಾವು ಪಟ್ಟಿ ಆಂತರಿಕ ರಚನೆಯನ್ನು ಬದಲಾಯಿಸಲು ಹೊಂದಿವೆ

203
00:08:37,179 --> 00:08:40,409
ಮತ್ತು ಮುಂದಿನ ಸೂಚಿಗಳ ಪಟ್ಟಿ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಒಳಗೊಂಡಿರುವ

204
00:08:40,409 --> 00:08:42,950
3 ನೇ ಮತ್ತು 4 ನೇ ಘಟಕಗಳು.

205
00:08:42,950 --> 00:08:46,560
ಮುಂದಿನ ಸೂಚಿಗಳ ಪಟ್ಟಿ ಕ್ರಮವನ್ನು ನಿರ್ಧರಿಸಲು, ಏಕೆಂದರೆ

206
00:08:46,560 --> 00:08:48,650
ಮತ್ತು ನಾವು ನಮ್ಮ ಹೊಸ ನೋಡ್ ತೂರಿಸುವ ಕಾರಣ

207
00:08:48,650 --> 00:08:50,510
ಬಲ ಪಟ್ಟಿಯ ಮಧ್ಯಮ ಆಗಿ,

208
00:08:50,510 --> 00:08:52,010
ಇದು ಸ್ವಲ್ಪ ಟ್ರಿಕಿ ಮಾಡಬಹುದು.

209
00:08:52,010 --> 00:08:54,250
ನೆನಪಿಡಿ, ಈ ನಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಆಗಿದೆ

210
00:08:54,250 --> 00:08:56,250
ಮಾತ್ರ ಪಟ್ಟಿಯಲ್ಲಿ ನೋಡ್ಗಳ ಸ್ಥಳ ತಿಳಿದಿರುವ

211
00:08:56,250 --> 00:09:00,400
ಹಿಂದಿನ ಗ್ರಂಥಿಗಳು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಮುಂದಿನ ಪಾಯಿಂಟರ್ಗಳ ಕಾರಣ.

212
00:09:00,400 --> 00:09:03,940
ಆದ್ದರಿಂದ, ನಾವು, ಈ ಸ್ಥಳಗಳಲ್ಲಿ ಯಾವುದೇ ಟ್ರ್ಯಾಕ್ ಸೋತರೆ

213
00:09:03,940 --> 00:09:06,860
ನಮ್ಮ ಪಟ್ಟಿಯಲ್ಲಿ ಮುಂದಿನ ಪಾಯಿಂಟರ್ಗಳ ಒಂದು ಬದಲಿಸುವ ಮೂಲಕ ಹೇಳುತ್ತಾರೆ,

214
00:09:06,860 --> 00:09:09,880
ಉದಾಹರಣೆಗೆ, ನಾವು ಬದಲಾವಣೆ ಹೇಳುತ್ತಾರೆ

215
00:09:09,880 --> 00:09:12,920
3 ನೋಡ್ ಮುಂದಿನ ಕ್ಷೇತ್ರ

216
00:09:12,920 --> 00:09:15,610
ಇಲ್ಲಿ ಬಗ್ಗೆ ನೋಡ್ ತೋರಿಸಲು.

217
00:09:15,610 --> 00:09:17,920
ನಾವು ಏಕೆಂದರೆ ನಾವು ಔಟ್ ಅದೃಷ್ಟದ ಪಡುತ್ತೇವೆ

218
00:09:17,920 --> 00:09:20,940
, ಅಲ್ಲಿ ಪಟ್ಟಿಯಲ್ಲಿ ಉಳಿದ ಹುಡುಕಲು ಯಾವುದೇ ಆಲೋಚಿಸಿದ್ದರೆ

219
00:09:20,940 --> 00:09:23,070
ಮತ್ತು ನಿಸ್ಸಂಶಯವಾಗಿ ನಿಜವಾಗಿಯೂ ಹಾನಿಕಾರಕ.

220
00:09:23,070 --> 00:09:25,080
ಆದ್ದರಿಂದ, ನಾವು ಕ್ರಮದ ಬಗ್ಗೆ ನಿಜವಾಗಿಯೂ ಎಚ್ಚರಿಕೆಯಿಂದ ಇರಬೇಕು

221
00:09:25,080 --> 00:09:28,360
ನಾವು ಅಳವಡಿಕೆಯ ಸಮಯದಲ್ಲಿ ನಮ್ಮ ಮುಂದಿನ ಪಾಯಿಂಟರ್ಸ್ ಕುಶಲತೆಯಿಂದ ಇದರಲ್ಲಿ.

222
00:09:28,360 --> 00:09:30,540
>> ಆದ್ದರಿಂದ, ಈ ಸರಳಗೊಳಿಸುವ, ಸೇ 'ಮಾಡುವಂತಹ

223
00:09:30,540 --> 00:09:32,220
ನಮ್ಮ ಮೊದಲ 4 ಗ್ರಂಥಿಗಳು

224
00:09:32,220 --> 00:09:36,200
ಪಾಯಿಂಟರ್ಸ್ ಸರಪಣಿಯನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಬಾಣಗಳು, ಎ, ಬಿ, ಸಿ, ಡಿ ಮತ್ತು ಕರೆಯಲಾಗುತ್ತದೆ

225
00:09:36,200 --> 00:09:38,070
ಗ್ರಂಥಿಗಳು ಸಂಪರ್ಕಿಸುತ್ತವೆ.

226
00:09:38,070 --> 00:09:40,050
ಆದ್ದರಿಂದ, ನಾವು ನಮ್ಮ ಹೊಸ ನೋಡ್ ಸೇರಿಸಲು ಅಗತ್ಯ

227
00:09:40,050 --> 00:09:42,070
ಗ್ರಂಥಿಗಳು ಸಿ ಮತ್ತು ಡಿ ನಡುವೆ

228
00:09:42,070 --> 00:09:45,060
ಅದನ್ನು ಸರಿಯಾದ ರೀತಿಯಲ್ಲಿ ಅದನ್ನು ಮಾಡಲು ವಿಮರ್ಶಾತ್ಮಕ, ಮತ್ತು ಏಕೆ ನೀವು ತೋರುವಿರಿ.

229
00:09:45,060 --> 00:09:47,500
>> ಮೊದಲ ಮಾಡುವುದು ತಪ್ಪು ದಾರಿ ನೋಡೋಣ.

230
00:09:47,500 --> 00:09:49,490
ಹೇ, ನಾವು ಹೊಸ ನೋಡ್ ಸಿ ನಂತರ ಬಲ ಬರಲು ಹೊಂದಿದೆ ತಿಳಿಯಲು,

231
00:09:49,490 --> 00:09:51,910
ಆದ್ದರಿಂದ ನ ಸಿ ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಸೆಟ್ ಅವಕಾಶ

232
00:09:51,910 --> 00:09:54,700
new_node ತೋರಿಸಲು.

233
00:09:56,530 --> 00:09:59,180
ಸರಿ, ಸರಿ ಕಾಣುತ್ತದೆ, ನಾವು ಅದಕ್ಕೆ ಈಗ ಮುಗಿಸಲು ಹೊಂದಿವೆ

234
00:09:59,180 --> 00:10:01,580
ಡಿ ಹೊಸ ನೋಡ್ ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಪಾಯಿಂಟ್ ಮಾಡುವ,

235
00:10:01,580 --> 00:10:03,250
ಆದರೆ ನಿರೀಕ್ಷಿಸಿ, ಹೇಗೆ ನಾವು ಏನು ಮಾಡಬಹುದು?

236
00:10:03,250 --> 00:10:05,170
ಡಿ, ಅಲ್ಲಿ ನಮಗೆ ಎಂದು ಕೇವಲ ವಸ್ತು,

237
00:10:05,170 --> 00:10:07,630
ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಹಿಂದೆ, ಸಿ ಶೇಖರಿಸಿಡಲಾಗುತ್ತಿತ್ತು

238
00:10:07,630 --> 00:10:09,870
ಆದರೆ ನಾವು ಆ ಪಾಯಿಂಟರ್ ಪುನಃಬರೆದರು

239
00:10:09,870 --> 00:10:11,170
ಹೊಸ ನೋಡ್ ತೋರಿಸಲು,

240
00:10:11,170 --> 00:10:14,230
ಆದ್ದರಿಂದ ನಾವು ಇನ್ನು ಮುಂದೆ, ಡಿ ನೆನಪಿಗಾಗಿ ಅಲ್ಲಿ ಯಾವುದೇ ಸುಳಿವು ಹೊಂದಿವೆ

241
00:10:14,230 --> 00:10:17,020
ಮತ್ತು ನಾವು ಪಟ್ಟಿ ಉಳಿದ ಕಳೆದುಕೊಂಡ ಮಾಡಿದ.

242
00:10:17,020 --> 00:10:19,000
ಎಲ್ಲ ಉತ್ತಮ.

243
00:10:19,000 --> 00:10:21,090
>> ಆದ್ದರಿಂದ, ನಾವು ಈ ಹಕ್ಕನ್ನು ಹೇಗೆ ಮಾಡಬೇಕು?

244
00:10:22,360 --> 00:10:25,090
ಮೊದಲ, ಡಿ ಹೊಸ ನೋಡ್ ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಬೆರಳು

245
00:10:26,170 --> 00:10:28,990
ಈಗ ಎರಡೂ ಹೊಸ ನೋಡ್ ಮತ್ತು ಸಿ ಮುಂದಿನ ಪಾಯಿಂಟರ್ಸ್

246
00:10:28,990 --> 00:10:30,660
ಅದೇ ನೋಡ್, ಡಿ ತೋರುತ್ತಿರುವಂತೆ ಮಾಡಲಾಗುತ್ತದೆ,

247
00:10:30,660 --> 00:10:32,290
ಆದರೆ ಉತ್ತಮ ಇಲ್ಲಿದೆ.

248
00:10:32,290 --> 00:10:35,680
ಈಗ ನಾವು ಹೊಸ ನೋಡ್ನಲ್ಲಿ ಸಿ ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಬೆಟ್ಟು ಮಾಡಬಹುದು.

249
00:10:37,450 --> 00:10:39,670
ಆದ್ದರಿಂದ, ನಾವು ಯಾವುದೇ ಡೇಟಾವನ್ನು ಕಳೆದುಕೊಳ್ಳದೇ ಮಾಡಿದ್ದೇನೆ.

250
00:10:39,670 --> 00:10:42,280
ಕೋಡ್, C ಪ್ರಸ್ತುತ ನೋಡ್

251
00:10:42,280 --> 00:10:45,540
ಅಡ್ಡಹಾಯುವುದನ್ನು ಪಾಯಿಂಟರ್ ಕ್ರಾಲರ್, ತೋರುತ್ತಿರುವಂತೆ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ

252
00:10:45,540 --> 00:10:50,400
ಮತ್ತು ಡಿ, ಪ್ರಸ್ತುತ ನೋಡ್ ಮುಂದಿನ ಕ್ಷೇತ್ರವು ತೋರಿಸಿದರು ನೋಡ್ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ

253
00:10:50,400 --> 00:10:52,600
ಅಥವಾ ಸಂಚಾರಿ → ಮುಂದಿನ.

254
00:10:52,600 --> 00:10:55,460
ಆದ್ದರಿಂದ, ನಾವು ಮೊದಲ ಹೊಸ ನೋಡ್ ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಸೆಟ್

255
00:10:55,460 --> 00:10:57,370
ಸಂಚಾರಿ → ಮುಂದಿನ ತೋರಿಸಲು,

256
00:10:57,370 --> 00:11:00,880
ನಾವು new_node ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಹೇಳುತ್ತಾರೆ ರೀತಿಯಲ್ಲಿ

257
00:11:00,880 --> 00:11:02,780
ಸಚಿತ್ರ ಡಿ ಸೂಚಿಸಿದವು.

258
00:11:02,780 --> 00:11:04,540
ನಂತರ, ನಾವು ಪ್ರಸ್ತುತ ನೋಡ್ ಮುಂದಿನ ಪಾಯಿಂಟರ್ ಹೊಂದಿಸಬಹುದು

259
00:11:04,540 --> 00:11:06,330
ನಮ್ಮ ಹೊಸ ನೋಡ್ ಗೆ,

260
00:11:06,330 --> 00:11:10,980
ನಾವು ಚಿತ್ರ ರಲ್ಲಿ new_node ಗೆ ಸಿ ತೋರಿಸಲು ಕಾಯಬೇಕಾಯಿತು ಕೇವಲ ಮಾಹಿತಿ.

261
00:11:10,980 --> 00:11:12,250
ಈಗ ಎಲ್ಲವನ್ನೂ ಸಲುವಾಗಿ, ಮತ್ತು ನಾವು ಸೋಲಲಿಲ್ಲ

262
00:11:12,250 --> 00:11:14,490
ಯಾವುದೇ ಡೇಟಾವನ್ನು ಟ್ರ್ಯಾಕ್, ಮತ್ತು ನಾವು ಸಮರ್ಥರಾದರು

263
00:11:14,490 --> 00:11:16,200
ಪಟ್ಟಿಯ ಮಧ್ಯದಲ್ಲಿ ನಮ್ಮ ಹೊಸ ನೋಡ್ ಅಂಟಿಕೊಳ್ಳುವುದಿಲ್ಲ

264
00:11:16,200 --> 00:11:19,330
ಇಡೀ ವಿಷಯ ಮರುನಿರ್ಮಾಣ ಅಥವಾ ಯಾವುದೇ ಅಂಶಗಳು ಬದಲಾಯಿಸುವ ಯಾವುದೇ

265
00:11:19,330 --> 00:11:22,490
ನಾವು ಒಂದು ನಿಶ್ಚಿತ ಪ್ರಮಾಣದ ಸಹಿತ ಮಾಡಲು ಹೊಂದಿತ್ತು.

266
00:11:22,490 --> 00:11:26,020
>> ಆದ್ದರಿಂದ, ಸಂಬಂಧಿತ ಪಟ್ಟಿಗಳನ್ನು ಒಂದು ಮೂಲ, ಆದರೆ ಪ್ರಮುಖ, ಕ್ರಿಯಾತ್ಮಕ ದತ್ತಾಂಶ ರಚನೆಯ ಗಳು

267
00:11:26,020 --> 00:11:29,080
ಇದು ಅನುಕೂಲ ಮತ್ತು ಅನಾನುಕೂಲ ಎರಡೂ ಹೊಂದಿವೆ

268
00:11:29,080 --> 00:11:31,260
ಸಾಲುಗಳು ಮತ್ತು ಇತರ ಡೇಟಾವನ್ನು ವಿನ್ಯಾಸಗಳಿಗೆ ಹೋಲಿಸಿದರೆ,

269
00:11:31,260 --> 00:11:33,350
ಮತ್ತು, ಸಾಮಾನ್ಯವಾಗಿ ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದಲ್ಲಿ ಸಂದರ್ಭದಲ್ಲಿ

270
00:11:33,350 --> 00:11:35,640
ಇದು, ಪ್ರತಿ ಉಪಕರಣವನ್ನು ಬಳಸಲು ತಿಳಿದುಕೊಳ್ಳಲು ಪ್ರಮುಖ

271
00:11:35,640 --> 00:11:37,960
ನೀವು ಸರಿಯಾದ ಕೆಲಸವನ್ನು ಸರಿಯಾದ ಸಾಧನ ಆಯ್ಕೆ ಮಾಡಬಹುದು.

272
00:11:37,960 --> 00:11:40,060
>> ಹೆಚ್ಚಿನ ಅಭ್ಯಾಸಕ್ಕೆ, ಗೆ ಕಾರ್ಯಗಳನ್ನು ಬರೆಯಲು ಪ್ರಯತ್ನಿಸಿ

273
00:11:40,060 --> 00:11:42,080
ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿಯಿಂದ ಗ್ರಂಥಿಗಳು ಅಳಿಸಿ -

274
00:11:42,080 --> 00:11:44,050
ನೀವು ಜೋಡಣೆಯನ್ನು ಕ್ರಮದಲ್ಲಿ ಎಚ್ಚರದಿಂದ ಮರೆಯದಿರಿ

275
00:11:44,050 --> 00:11:47,430
ನಿಮ್ಮ ಪಟ್ಟಿಯಲ್ಲಿ ಒಂದು ಚಂಕ್ ಕಳೆದುಕೊಳ್ಳುವುದಿಲ್ಲ ಖಚಿತಪಡಿಸಲು ನಿಮ್ಮ ಮುಂದಿನ ಪಾಯಿಂಟರ್ಸ್ -

276
00:11:47,430 --> 00:11:50,200
ಅಥವಾ ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ನೋಡ್ ಎಣಿಸಲು ಒಂದು ಕ್ರಿಯೆ,

277
00:11:50,200 --> 00:11:53,280
ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ನೋಡ್ಗಳ ಎಲ್ಲಾ ಕ್ರಮವನ್ನು ಬದಲಾಯಿಸುವ ಅಥವಾ ಒಂದು ಮೋಜಿನ ಒಂದು.

278
00:11:53,280 --> 00:11:56,090
>> ನನ್ನ ಹೆಸರು ಜಾಕ್ಸನ್ STEINKAMP ಹೊಂದಿದೆ, ಈ CS50 ಹೊಂದಿದೆ.