1
00:00:07,720 --> 00:00:10,950
[Powered by Google Translate] బహుశా మీరు ప్రజలు వేగంగా లేదా సమర్థవంతమైన అల్గోరిథం గురించి మాట్లాడేందుకు విన్న చేసిన

2
00:00:10,950 --> 00:00:13,090
మీ పని అమలు,

3
00:00:13,090 --> 00:00:16,110
కానీ ఫాస్ట్ లేదా సమర్ధంగా ఒక అల్గోరిథం కోసం ఖచ్చితంగా అర్థం ఏమిటి?

4
00:00:16,110 --> 00:00:18,580
సరే,, నిజ సమయంలో ఒక కొలత గురించి మాట్లాడటం లేదు

5
00:00:18,580 --> 00:00:20,500
సెకన్లు లేదా నిమిషాలు ఇష్టపడుతున్నారు.

6
00:00:20,500 --> 00:00:22,220
ఇది కంప్యూటర్ హార్డ్వేర్

7
00:00:22,220 --> 00:00:24,260
మరియు సాఫ్ట్వేర్ పూర్తిగా మారుతుంది.

8
00:00:24,260 --> 00:00:26,020
నా కార్యక్రమం, మీదే కంటే నెమ్మదిగా అమలు కావచ్చు

9
00:00:26,020 --> 00:00:28,000
నేను, ఒక పాత కంప్యూటర్ మీద నడుస్తున్న నేను ఎందుకంటే

10
00:00:28,000 --> 00:00:30,110
లేదా నేను ఒక ఆన్లైన్ వీడియో గేమ్ ప్లే కావడం ఎందుకంటే

11
00:00:30,110 --> 00:00:32,670
అదే సమయంలో, ఇది నా మెమరీ hogging ఉంది

12
00:00:32,670 --> 00:00:35,400
లేదా నేను వివిధ సాఫ్ట్వేర్ ద్వారా నా ప్రోగ్రామ్ అమలు చేస్తూ ఉండవచ్చు

13
00:00:35,400 --> 00:00:37,550
ఇది తక్కువ స్థాయిలో భిన్నంగా యంత్రం కమ్యూనికేట్.

14
00:00:37,550 --> 00:00:39,650
ఇది యాపిల్స్ అండ్ ఆరెంజ్స్ పోల్చడం వంటిది.

15
00:00:39,650 --> 00:00:41,940
నా నెమ్మదిగా కంప్యూటర్ సమయం పడుతుంది కనుక

16
00:00:41,940 --> 00:00:43,410
మీది ఒక సమాధానం తిరిగి ఇవ్వాలని కంటే

17
00:00:43,410 --> 00:00:45,510
మీరు మరింత సమర్థవంతంగా అల్గోరిథం కలిగి కాదు.

18
00:00:45,510 --> 00:00:48,830
>> కాబట్టి, మేము నేరుగా కార్యక్రమాలను runtimes పోల్చి కాదు నుండి

19
00:00:48,830 --> 00:00:50,140
సెకన్లు లేదా నిమిషాలు లో,

20
00:00:50,140 --> 00:00:52,310
ఎలా మేము 2 వివిధ అల్గోరిథంలు పోల్చి లేదు

21
00:00:52,310 --> 00:00:55,030
సంబంధం లేకుండా వారి హార్డ్వేర్ లేదా సాఫ్ట్వేర్ పర్యావరణం యొక్క?

22
00:00:55,030 --> 00:00:58,000
క్రమసూత్ర సామర్థ్యం కొలిచే ఒక ఏకరీతిగా మార్గం సృష్టించడానికి,

23
00:00:58,000 --> 00:01:00,360
కంప్యూటర్ శాస్త్రవేత్తలు మరియు గణిత రూపొందించారు

24
00:01:00,360 --> 00:01:03,830
ఒక ప్రోగ్రామ్ యొక్క asymptotic సంక్లిష్టత కొలిచే భావనలు

25
00:01:03,830 --> 00:01:06,110
మరియు టిప్పణి 'బిగ్ Ohnotation' అని

26
00:01:06,110 --> 00:01:08,320
ఈ వివరించేందుకు.

27
00:01:08,320 --> 00:01:10,820
లాంఛనప్రాయమైన నిర్వచనం అని ఒక ఫంక్షన్ f (x)

28
00:01:10,820 --> 00:01:13,390
g క్రమాన్ని (x) అమలు

29
00:01:13,390 --> 00:01:15,140
కొన్ని (x) విలువ ఉంది ఉంటే, x ₀ మరియు

30
00:01:15,140 --> 00:01:17,630
కొన్ని స్థిరమైన, C, ఇది కోసం

31
00:01:17,630 --> 00:01:19,340
f (x) కంటే తక్కువ లేదా సమానం

32
00:01:19,340 --> 00:01:21,230
స్థిరమైన సార్లు g (x)

33
00:01:21,230 --> 00:01:23,190
x ₀ కంటే ఎక్కువ అన్ని x కోసం.

34
00:01:23,190 --> 00:01:25,290
>> కానీ అధికారిక నిర్వచనం ద్వారా దూరంగా భయపడ్డాను డోంట్.

35
00:01:25,290 --> 00:01:28,020
ఈ నిజానికి సైద్ధాంతిక నిబంధనలు తక్కువ శతకము

36
00:01:28,020 --> 00:01:30,580
Well, ఇది ప్రాథమికంగా విశ్లేషించడం ఒక మార్గం

37
00:01:30,580 --> 00:01:33,580
ఒక ప్రోగ్రామ్ యొక్క రన్టైమ్ asymptotically పెరుగుతుంది ఎంత వేగంగా.

38
00:01:33,580 --> 00:01:37,170
మీ ఇన్పుట్లను పరిమాణం అనంతం వైపు వల్ల ఆ, ఉంది

39
00:01:37,170 --> 00:01:41,390
సే, మీరు పరిమాణం 10 యొక్క వ్యూహం పోలిస్తే పరిమాణం 1000 యొక్క వ్యూహం క్రమబద్ధీకరించేందుకు చేస్తున్నారు.

40
00:01:41,390 --> 00:01:44,950
మీ ప్రోగ్రామ్ యొక్క రన్టైమ్ ఎలా పెరుగుతాయి లేదు?

41
00:01:44,950 --> 00:01:47,390
ఉదాహరణకు, అక్షరాలు సంఖ్యపై ఊహించుకోండి

42
00:01:47,390 --> 00:01:49,350
ఒక స్ట్రింగ్ లో సరళమైన మార్గం

43
00:01:49,350 --> 00:01:51,620
 మొత్తం స్ట్రింగ్ ద్వారా వాకింగ్ ద్వారా

44
00:01:51,620 --> 00:01:54,790
లెటర్ ద్వారా లేఖ మరియు ప్రతి పాత్ర కోసం ఒక కౌంటర్ 1 జోడించడం.

45
00:01:55,700 --> 00:01:58,420
ఈ అల్గోరిథం సరళ సమయంలో అమలు చెబుతారు

46
00:01:58,420 --> 00:02:00,460
అక్షరాల సంఖ్య సంబంధించి,

47
00:02:00,460 --> 00:02:02,670
స్ట్రింగ్ లో 'n'.

48
00:02:02,670 --> 00:02:04,910
చిన్న లో, O (n) లో నడుస్తుంది.

49
00:02:05,570 --> 00:02:07,290
ఎందుకు ఉంది?

50
00:02:07,290 --> 00:02:09,539
Well, ఈ విధానాన్ని ఉపయోగించి, సమయం అవసరం

51
00:02:09,539 --> 00:02:11,300
మొత్తం స్ట్రింగ్ ప్రయాణించేందుకు

52
00:02:11,300 --> 00:02:13,920
అక్షరాల సంఖ్య నిష్పత్తిలో ఉంటుంది.

53
00:02:13,920 --> 00:02:16,480
20 పాత్ర స్ట్రింగ్ లో అక్షరాలు సంఖ్యపై

54
00:02:16,480 --> 00:02:18,580
అది పడుతుంది రెండుసార్లు కాలం పడుతుంది అన్నారు

55
00:02:18,580 --> 00:02:20,330
ఒక 10-పాత్ర స్ట్రింగ్ లో అక్షరాలు లెక్కించడానికి,

56
00:02:20,330 --> 00:02:23,000
మీరు అన్ని అక్షరాలు కు ఎందుకంటే

57
00:02:23,000 --> 00:02:25,740
మరియు ప్రతి పాత్ర కు సమయంలో అదే మొత్తం పడుతుంది.

58
00:02:25,740 --> 00:02:28,050
మీరు అక్షరాలు సంఖ్య పెంచడానికి, వంటి

59
00:02:28,050 --> 00:02:30,950
runtime ఇన్పుట్ పొడవు సరళంగా పెరుగుతుంది.

60
00:02:30,950 --> 00:02:33,500
>> మీరు ఆ సరళ సమయం నిర్ణయించుకుంటే ఇప్పుడు, ఊహించుకోండి

61
00:02:33,500 --> 00:02:36,390
O (n), కేవలం తగినంత వేగం మీరు కాదు?

62
00:02:36,390 --> 00:02:38,750
బహుశా మీరు, భారీ తీగలను నిల్వ చేసిన

63
00:02:38,750 --> 00:02:40,450
మరియు మీరు పడుతుంది అదనపు సమయంలో భరించలేని

64
00:02:40,450 --> 00:02:44,000
ఒకటి తరువాత ఒకటి లెక్కింపు వారి అక్షరాలు అన్ని దాటటానికి.

65
00:02:44,000 --> 00:02:46,650
కాబట్టి, మీరు ప్రయత్నించాలనుకుంటే నిర్ణయించుకుంటారు.

66
00:02:46,650 --> 00:02:49,270
మీరు ఇప్పటికే అక్షరాలు సంఖ్య నిల్వ జరుగుతుంది ఉంటే

67
00:02:49,270 --> 00:02:52,690
స్ట్రింగ్ లో, ', లెన్' అనే వేరియబుల్ సే,

68
00:02:52,690 --> 00:02:54,210
ప్రారంభ కార్యక్రమం లో,

69
00:02:54,210 --> 00:02:57,800
మీరు కూడా మీ స్ట్రింగ్ లో మొట్టమొదటి పాత్ర నిల్వ ముందు?

70
00:02:57,800 --> 00:02:59,980
అప్పుడు, అన్ని మీరు, స్ట్రింగ్ పొడవు కనుగొనేందుకు ఇప్పుడు లేదు భావిస్తున్న

71
00:02:59,980 --> 00:03:02,570
వేరియబుల్ యొక్క విలువ ఏమిటి తనిఖీ ఉంది.

72
00:03:02,570 --> 00:03:05,530
మీరు అన్ని వద్ద స్ట్రింగ్ కూడా చూడండి ఉండదనే

73
00:03:05,530 --> 00:03:08,160
మరియు లెన్ వంటి వేరియబుల్ విలువ యాక్సెస్ భావిస్తారు

74
00:03:08,160 --> 00:03:11,100
ఒక asymptotically స్థిరంగా సమయం ఆపరేషన్,

75
00:03:11,100 --> 00:03:13,070
లేదా O (1).

76
00:03:13,070 --> 00:03:17,110
ఎందుకు ఉంది? Well, asymptotic సంక్లిష్టత అర్థం గుర్తు.

77
00:03:17,110 --> 00:03:19,100
ఎలా పరిమాణం runtime మార్పు చేస్తుంది

78
00:03:19,100 --> 00:03:21,400
మీ ఇన్పుట్లను పెరుగుతుంది?

79
00:03:21,400 --> 00:03:24,630
>> మీరు ఒక పెద్ద స్ట్రింగ్ లో అక్షరాలు సంఖ్యను పొందడం ప్రయత్నిస్తున్న సే.

80
00:03:24,630 --> 00:03:26,960
సరే,, మీరు తీగ ఎలా పెద్ద పట్టింపు లేదు

81
00:03:26,960 --> 00:03:28,690
ఒక మిలియన్ అక్షరాల పొడవు,

82
00:03:28,690 --> 00:03:31,150
అన్ని మీరు, ఈ పద్ధతిలో ఉన్న స్ట్రింగ్ యొక్క పొడవు కనుగొనేందుకు చేయడానికి భావిస్తాను

83
00:03:31,150 --> 00:03:33,790
, వేరియబుల్ లెన్ యొక్క విలువ చదివి ఉంది

84
00:03:33,790 --> 00:03:35,440
మీరు ఇప్పటికే చేసింది.

85
00:03:35,440 --> 00:03:38,200
అని ఇన్పుట్ పొడవు, మీరు కనుగొనేందుకు ప్రయత్నిస్తున్న స్ట్రింగ్ యొక్క పొడవు,

86
00:03:38,200 --> 00:03:41,510
మీ కార్యక్రమం నడుపుతుంది ఎంత వేగంగా అన్ని వద్ద ప్రభావితం చేయదు.

87
00:03:41,510 --> 00:03:44,550
మీ ప్రోగ్రామ్ యొక్క ఈ భాగం ఒక పాత్ర స్ట్రింగ్ న సమానంగా ఫాస్ట్ అమలు

88
00:03:44,550 --> 00:03:46,170
మరియు ఒక వేయి పాత్ర స్ట్రింగ్,

89
00:03:46,170 --> 00:03:49,140
ఈ కార్యక్రమం నిరంతరం సమయంలో అమలు సూచిస్తారు ఎందుకు మరియు ఆ

90
00:03:49,140 --> 00:03:51,520
ఇన్పుట్ పరిమాణం సంబంధించి.

91
00:03:51,520 --> 00:03:53,920
>> అయితే, ఒక ప్రతికూలతగా లేదు.

92
00:03:53,920 --> 00:03:55,710
మీరు మీ కంప్యూటర్ లో అదనపు మెమరీని ఖర్చు

93
00:03:55,710 --> 00:03:57,380
వేరియబుల్ నిల్వ

94
00:03:57,380 --> 00:03:59,270
మరియు మీరు పడుతుంది అదనపు సమయం

95
00:03:59,270 --> 00:04:01,490
వేరియబుల్ యొక్క నిజమైన నిల్వ చేయడానికి,

96
00:04:01,490 --> 00:04:03,390
కానీ పాయింట్ ఇప్పటికీ నిలిచి,

97
00:04:03,390 --> 00:04:05,060
మీ స్ట్రింగ్ ఉంది ఎంత కాలం కనుగొనడంలో

98
00:04:05,060 --> 00:04:07,600
అన్ని వద్ద స్ట్రింగ్ యొక్క పొడవు మీద ఆధారపడి ఉండదు.

99
00:04:07,600 --> 00:04:10,720
కాబట్టి, అది ఓ (1) లేదా స్థిరమైన సమయంలో నడుస్తుంది.

100
00:04:10,720 --> 00:04:13,070
ఈ ఖచ్చితంగా అర్థం లేదు

101
00:04:13,070 --> 00:04:15,610
మీ కోడ్, 1 స్టెప్ లో నడిపే

102
00:04:15,610 --> 00:04:17,470
కానీ ఎంత అనేక దశలు ఇది,

103
00:04:17,470 --> 00:04:20,019
అది ఇన్పుట్లను పరిమాణం తో మారకపోతే,

104
00:04:20,019 --> 00:04:23,420
అది ఇప్పటికీ మేము O (1) వంటి ఇది asymptotically స్థిరంగా ఉంది.

105
00:04:23,420 --> 00:04:25,120
>> మీరు బహుశా అంచనా వంటి,

106
00:04:25,120 --> 00:04:27,940
క్రమసూత్ర పద్ధతులు కొలిచేందుకు అనేక పెద్ద O runtimes ఉన్నాయి.

107
00:04:27,940 --> 00:04:32,980
O (n) ² అల్గోరిథంలు O (n) అల్గోరిథంలు కంటే asymptotically నెమ్మదిగా ఉంటాయి.

108
00:04:32,980 --> 00:04:35,910
మూలకాల సంఖ్య (n) వృధ్ధి ఆ, ఉంది

109
00:04:35,910 --> 00:04:39,280
చివరికి ఓ (n) ² అల్గోరిథంలు ఎక్కువ సమయం పడుతుంది

110
00:04:39,280 --> 00:04:41,000
O (n) అల్గోరిథంలు అమలు కంటే.

111
00:04:41,000 --> 00:04:43,960
ఈ O (n) అల్గోరిథంలు ఎల్లప్పుడూ వేగంగా అమలు కాదు

112
00:04:43,960 --> 00:04:46,410
O (n) ² అల్గోరిథంలు కంటే, ఒకే వాతావరణంలో,

113
00:04:46,410 --> 00:04:48,080
అదే హార్డువేరు మీద.

114
00:04:48,080 --> 00:04:50,180
బహుశా చిన్న ఇన్పుట్ పరిమాణాల్లో,

115
00:04:50,180 --> 00:04:52,900
 O (n) ² క్రమసూత్ర పద్ధతి నిజానికి, వేగంగా పని ఉండవచ్చు

116
00:04:52,900 --> 00:04:55,450
కానీ, చివరికి, ఇన్పుట్ పరిమాణం పెరుగుతుంది

117
00:04:55,450 --> 00:04:58,760
అనంతం వైపు, O (n) ² అల్గోరిథం యొక్క రన్టైమ్

118
00:04:58,760 --> 00:05:02,000
చివరికి ఓ (n) అల్గోరిథం యొక్క రన్టైమ్ మరుగు చేసినా కనిపిస్తుంది.

119
00:05:02,000 --> 00:05:04,230
ఏ వర్గ గణిత ఫంక్షన్ వంటి

120
00:05:04,230 --> 00:05:06,510
 చివరికి ఏ సరళ ఫంక్షన్ అధిగమిస్తుందనే కనిపిస్తుంది,

121
00:05:06,510 --> 00:05:09,200
ఎంత తల యొక్క సరళ ఫంక్షన్ మొదలు ఉన్నా తో మొదలవుతుంది.

122
00:05:10,010 --> 00:05:12,000
మీరు డేటా పెద్ద మొత్తంలో పని చేస్తే

123
00:05:12,000 --> 00:05:15,510
O అమలు ఆ అల్గోరిథంలు (n) ² సమయం నిజంగా, మీ ప్రోగ్రామ్ నెమ్మదిగా పని అవుతుంది

124
00:05:15,510 --> 00:05:17,770
కానీ చిన్న ఇన్పుట్ పరిమాణాల్లో,

125
00:05:17,770 --> 00:05:19,420
మీరు బహుశా గమనించి కూడా లేదు.

126
00:05:19,420 --> 00:05:21,280
>> మరో asymptotic సంక్లిష్టత ఉంటుంది

127
00:05:21,280 --> 00:05:24,420
సంవర్గమాన సమయం, O (n లాగ్).

128
00:05:24,420 --> 00:05:26,340
త్వరగా ఈ నడిపే ఒక అల్గోరిథం యొక్క ఒక ఉదాహరణ

129
00:05:26,340 --> 00:05:29,060
, క్లాసిక్ బైనరీ శోధన అల్గోరిథం

130
00:05:29,060 --> 00:05:31,850
అంశాల ఇప్పటికే క్రమబద్ధీకరించబడతాయి జాబితాలో ఒక మూలకం కనుగొనడానికి.

131
00:05:31,850 --> 00:05:33,400
>> మీరు బైనరీ శోధన ఏమి తెలియకపోతే,

132
00:05:33,400 --> 00:05:35,170
నేను నిజంగా త్వరగా మీ కోసం వివరించడానికి చేస్తాము.

133
00:05:35,170 --> 00:05:37,020
మీరు సంఖ్య 3 చూస్తున్న సే

134
00:05:37,020 --> 00:05:40,200
పూర్ణాంకాల ఈ శ్రేణి లో.

135
00:05:40,200 --> 00:05:42,140
ఇది అర్రే మధ్య మూలకం వద్ద ఉంది

136
00:05:42,140 --> 00:05:46,830
మరియు "నేను కంటే ఎక్కువ కావలసిన ఎలిమెంట్ సమానంగా లేదా ఈ కంటే తక్కువ?" అని అడుగుతాడు

137
00:05:46,830 --> 00:05:49,150
అది గొప్ప, సమాన అయితే. మీరు మూలకం కనుగొనబడింది, మరియు మీరు పూర్తి చేసిన.

138
00:05:49,150 --> 00:05:51,300
ఇది అధిక అది మీరు మూలకం తెలుసు

139
00:05:51,300 --> 00:05:53,440
, అర్రే యొక్క కుడివైపు ఉండాలి

140
00:05:53,440 --> 00:05:55,200
మరియు మీరు మాత్రమే, భవిష్యత్తులో ఆ చూడవచ్చు

141
00:05:55,200 --> 00:05:57,690
చిన్న అయితే మరియు, అప్పుడు మీరు ఎడమ వైపు ఉండాలి తెలుసు.

142
00:05:57,690 --> 00:06:00,980
ఈ ప్రక్రియ తర్వాత చిన్న పరిమాణ శ్రేణి తిరిగి చేయబడుతుంది

143
00:06:00,980 --> 00:06:02,870
సరైన మూలకం కనిపించే వరకు.

144
00:06:08,080 --> 00:06:11,670
>> ఈ శక్తివంతమైన అల్గోరిథం ప్రతి చర్య సగానికి అర్రే పరిమాణం తగ్గిస్తుంది.

145
00:06:11,670 --> 00:06:14,080
కాబట్టి, పరిమాణం 8 ఒక క్రమబద్ధీకరించబడతాయి శ్రేణి ఒక మూలకం కనుగొనేందుకు,

146
00:06:14,080 --> 00:06:16,170
అత్యంత వద్ద (₂ 8 లాగిన్),

147
00:06:16,170 --> 00:06:18,450
ఈ ఆపరేషన్లలో లేదా 3,

148
00:06:18,450 --> 00:06:22,260
మధ్య మూలకం తనిఖీ, అప్పుడు సగం లో అర్రే కత్తిరించి, అవసరం

149
00:06:22,260 --> 00:06:25,670
పరిమాణం 16 యొక్క వ్యూహం, (₂ 16 లాగ్) చేపట్టింది

150
00:06:25,670 --> 00:06:27,480
లేదా 4 కార్యకలాపాలు.

151
00:06:27,480 --> 00:06:30,570
మాత్రమే ఒక రెట్టింపు పరిమాణంలో శ్రేణి కోసం 1 మరింత ఆపరేషన్ ఉంది.

152
00:06:30,570 --> 00:06:32,220
అర్రే పరిమాణం రెట్టింపు

153
00:06:32,220 --> 00:06:35,160
ఈ కోడ్ యొక్క మాత్రమే 1 భాగం ద్వారా runtime పెంచుతుంది.

154
00:06:35,160 --> 00:06:37,770
మళ్లీ, అప్పుడు విభజన, జాబితా మధ్య మూలకం తనిఖీ.

155
00:06:37,770 --> 00:06:40,440
కాబట్టి, అది, సంవర్గమాన సమయంలో ఆపరేట్ చెప్పబడింది

156
00:06:40,440 --> 00:06:42,440
O (n లాగ్).

157
00:06:42,440 --> 00:06:44,270
కానీ, మీరు చెప్పిన వేచి

158
00:06:44,270 --> 00:06:47,510
జాబితాలో మీరు చూస్తున్న మూలకం ఉన్న ఈ ఆధారపడి ఉండదు?

159
00:06:47,510 --> 00:06:50,090
ఏం మీరు చూడండి మొదటి మూలకం కుడి ఒకటిగా జరుగుతుంది?

160
00:06:50,090 --> 00:06:52,040
అప్పుడు మాత్రమే, 1 ఆపరేషన్ పడుతుంది

161
00:06:52,040 --> 00:06:54,310
జాబితా ఎంత పెద్ద ఉన్నా.

162
00:06:54,310 --> 00:06:56,310
>> కంప్యూటర్ శాస్త్రవేత్తలు మరింత నిబంధనలు ఎందుకు సరే, ఆ

163
00:06:56,310 --> 00:06:58,770
ఉత్తమ కేసు ప్రతిబింబించే asymptotic క్లిష్టతకు

164
00:06:58,770 --> 00:07:01,050
మరియు అతి దారుణమైన విషయం ఒక అల్గోరిథం యొక్క ప్రదర్శనలు.

165
00:07:01,050 --> 00:07:03,320
సరిగా ఎగువ మరియు దిగువ హద్దులు

166
00:07:03,320 --> 00:07:05,090
runtime లో.

167
00:07:05,090 --> 00:07:07,660
బైనరీ శోధన ఉత్తమ సందర్భంలో, మా అంశం

168
00:07:07,660 --> 00:07:09,330
అక్కడే మధ్యలో,

169
00:07:09,330 --> 00:07:11,770
మరియు మీరు, స్థిరమైన సమయంలో అది పొందండి

170
00:07:11,770 --> 00:07:14,240
అర్రే మిగిలిన ఎలా పెద్దది ఉన్నా.

171
00:07:15,360 --> 00:07:17,650
ఈ కోసం ఉపయోగిస్తారు Ω ఉంది.

172
00:07:17,650 --> 00:07:19,930
కాబట్టి, ఈ అల్గోరిథం Ω (1) అమలు చెబుతారు.

173
00:07:19,930 --> 00:07:21,990
ఉత్తమ సందర్భంలో, ఇది త్వరగా మూలకం తెలుసుకుంటాడు

174
00:07:21,990 --> 00:07:24,200
శ్రేణి ఎంత పెద్ద ఉన్నా,

175
00:07:24,200 --> 00:07:26,050
కానీ విషయంలో లో,

176
00:07:26,050 --> 00:07:28,690
అది (లాగ్ n) స్ప్లిట్ తనిఖీలను ఉంటుంది

177
00:07:28,690 --> 00:07:31,030
యెరే యొక్క కుడి మూలకం కనుగొనేందుకు.

178
00:07:31,030 --> 00:07:34,270
చెత్త-సందర్భంలో ఎగువ హద్దులు మీరు ఇప్పటికే తెలిసిన పెద్ద "O" తో సూచిస్తారు.

179
00:07:34,270 --> 00:07:38,080
కాబట్టి, అది O (n లాగ్), కానీ Ω (1) ఉంది.

180
00:07:38,080 --> 00:07:40,680
>> ఒక సరళ శోధన దీనికి విరుద్ధంగా,

181
00:07:40,680 --> 00:07:43,220
మీరు శ్రేణి యొక్క ప్రతి మూలకం నడవడానికి దీనిలో

182
00:07:43,220 --> 00:07:45,170
మీకు కావలసిన ఒక కనుగొనడానికి,

183
00:07:45,170 --> 00:07:47,420
ఉత్తమ Ω (1) ఉంది.

184
00:07:47,420 --> 00:07:49,430
మళ్లీ, మొదటి మూలకం మీరు.

185
00:07:49,430 --> 00:07:51,930
కాబట్టి, అది యెరే ఎంత పెద్ద పట్టింపు లేదు.

186
00:07:51,930 --> 00:07:54,840
చెత్త సందర్భంలో, అది యెరే నందలి చివరి ఎలిమెంట్.

187
00:07:54,840 --> 00:07:58,560
కాబట్టి, మీరు, దానిని కనుగొనేందుకు శ్రేణి అన్ని n మూలకాలు నడవడానికి కలిగి

188
00:07:58,560 --> 00:08:02,170
మీరు ఒక 3 వెతుకుతున్న ఉంటే ఇష్టం.

189
00:08:04,320 --> 00:08:06,030
కాబట్టి, అది O (n) సమయంలో నడుస్తుంది

190
00:08:06,030 --> 00:08:09,330
అది యెరే నందలి మూలకాల సంఖ్య నిష్పత్తిలో ఎందుకంటే.

191
00:08:10,800 --> 00:08:12,830
>> ఉపయోగించే ఒక మరింత గుర్తు Θ ఉంది.

192
00:08:12,830 --> 00:08:15,820
ఈ పేరు ఉత్తమ మరియు చెత్త కేసులు అల్గోరిథంలు వివరించడానికి ఉపయోగిస్తారు

193
00:08:15,820 --> 00:08:17,440
ఒకే విధంగా ఉంటాయి.

194
00:08:17,440 --> 00:08:20,390
ఈ మేము ముందుగా గురించి మాట్లాడారు స్ట్రింగ్ నిడివి అల్గోరిథంలు వర్తిస్తుంది.

195
00:08:20,390 --> 00:08:22,780
మేము ముందు ఒక వేరియబుల్ నిల్వ ఉంటే అంటే,

196
00:08:22,780 --> 00:08:25,160
మేము స్ట్రింగ్ నిల్వ మరియు తరువాత స్థిరంగా సమయంలో అది యాక్సెస్.

197
00:08:25,160 --> 00:08:27,920
ఏ సంఖ్య ఉన్నా

198
00:08:27,920 --> 00:08:30,130
మేము ఆ వేరియబుల్ నిల్వ చేస్తున్నాము, మేము ఇది చూడండి ఉంటుంది.

199
00:08:33,110 --> 00:08:35,110
ఉత్తమ సందర్భంలో, మేము ఇది చూడండి

200
00:08:35,110 --> 00:08:37,120
మరియు స్ట్రింగ్ యొక్క పొడవు కనుగొనండి.

201
00:08:37,120 --> 00:08:39,799
Ω (1) లేదా ఉత్తమ కేసు స్థిరంగా సమయంలో.

202
00:08:39,799 --> 00:08:41,059
విషయంలో, ఉంది

203
00:08:41,059 --> 00:08:43,400
మేము దాన్ని చూసి స్ట్రింగ్ యొక్క పొడవు కనుగొనండి.

204
00:08:43,400 --> 00:08:47,300
కాబట్టి, ఓ (1) లేదా విషయంలో నిరంతరం సమయం.

205
00:08:47,300 --> 00:08:49,180
కాబట్టి, ఉత్తమ కేసు మరియు చెత్త కేసులు నుండి ఒకటే

206
00:08:49,180 --> 00:08:52,520
ఈ Θ (1) సమయంలో అమలు చెప్పవచ్చు.

207
00:08:54,550 --> 00:08:57,010
>> సారాంశంలో, మేము సంకేతాలు సామర్ధ్యాన్ని కారణం మంచి మార్గాలు ఉన్నాయి

208
00:08:57,010 --> 00:09:00,110
వారు అమలు చేయడానికి తీసుకుని వాస్తవ ప్రపంచ సమయం గురించి ఏదైనా తెలియకుండా,

209
00:09:00,110 --> 00:09:02,270
ఇది బయట కారకాలు మా ప్రభావితమవుతుంది

210
00:09:02,270 --> 00:09:04,190
వేర్వేరు హార్డ్వేర్, సాఫ్ట్వేర్, సహా

211
00:09:04,190 --> 00:09:06,040
లేదా మీ కోడ్ ప్రత్యేకతలు.

212
00:09:06,040 --> 00:09:08,380
అలాగే, ఇది మాకు ఏం జరుగుతుందో గురించి బాగా కారణం అనుమతిస్తుంది

213
00:09:08,380 --> 00:09:10,180
ఉన్నప్పుడు ఇన్పుట్లను పెరుగుతుంది పరిమాణం.

214
00:09:10,180 --> 00:09:12,490
>> మీరు O (n) ² అల్గోరిథం, అమలు చేస్తే

215
00:09:12,490 --> 00:09:15,240
లేదా మరింత, ఒక O (2 ⁿ) అల్గోరిథం,

216
00:09:15,240 --> 00:09:17,170
వేగంగా పెరుగుతున్న రకాల్లో ఒకటి

217
00:09:17,170 --> 00:09:19,140
మీరు నిజంగా మందగింపు గమనించి ప్రారంభించగలరు

218
00:09:19,140 --> 00:09:21,220
మీరు డేటా పెద్ద మొత్తంలో పని ప్రారంభించండి.

219
00:09:21,220 --> 00:09:23,590
>> ఆ asymptotic సంక్లిష్టత ఉంటుంది. ధన్యవాదాలు.