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
औपचारिक परिभाषा यह है कि एक समारोह च (x)

28
00:01:10,820 --> 00:01:13,390
(x) जी के आदेश पर चलाता है

29
00:01:13,390 --> 00:01:15,140
अगर वहाँ कुछ मूल्य (x) मौजूद है, x ₀ और

30
00:01:15,140 --> 00:01:17,630
कुछ स्थिर, सी, जिसके लिए

31
00:01:17,630 --> 00:01:19,340
च (x) कम से कम या बराबर है

32
00:01:19,340 --> 00:01:21,230
कि लगातार कई बार जी (x)

33
00:01:21,230 --> 00:01:23,190
सभी 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
खैर, यह मूल रूप से विश्लेषण का एक तरीका है

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
'एन' स्ट्रिंग में.

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
खैर, इस दृष्टिकोण का उपयोग, समय की आवश्यकता

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
क्रम linearly इनपुट लंबाई के साथ वृद्धि होगी.

60
00:02:30,950 --> 00:02:33,500
>> अब, कल्पना अगर आपको लगता है कि रैखिक समय तय है,

61
00:02:33,500 --> 00:02:36,390
हे (एन), बस तेजी से आप के लिए पर्याप्त नहीं था?

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
या हे (1).

76
00:03:13,070 --> 00:03:17,110
ऐसा क्यों है? अच्छी तरह याद है, asymptotic जटिलता का मतलब क्या है.

77
00:03:17,110 --> 00:03:19,100
आकार के रूप में क्रम परिवर्तन कैसे करता है

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
यह अभी भी asymptotically निरंतर है जो हम हे (1) के रूप में प्रतिनिधित्व है.

105
00:04:23,420 --> 00:04:25,120
>> जैसा कि आप शायद अनुमान कर सकते हैं,

106
00:04:25,120 --> 00:04:27,940
वहाँ कई अलग अलग बड़ी हे साथ एल्गोरिदम को मापने runtimes हैं.

107
00:04:27,940 --> 00:04:32,980
हे (एन) ² एल्गोरिदम asymptotically हे एल्गोरिदम (एन) की तुलना में धीमी है.

108
00:04:32,980 --> 00:04:35,910
यही कारण है, के रूप में तत्वों की संख्या (n) बढ़ता है,

109
00:04:35,910 --> 00:04:39,280
अंततः हे (एन) ² एल्गोरिदम अधिक समय लगेगा

110
00:04:39,280 --> 00:04:41,000
हे एल्गोरिदम (एन) से चलाने के लिए.

111
00:04:41,000 --> 00:04:43,960
इसका मतलब यह नहीं है कि हे एल्गोरिदम (n) हमेशा तेजी से चलाने

112
00:04:43,960 --> 00:04:46,410
हे (एन) ² एल्गोरिदम से, यहां तक ​​कि एक ही वातावरण में,

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
 हे (एन) ² एल्गोरिथ्म वास्तव में तेजी से काम कर सकते हैं,

116
00:04:52,900 --> 00:04:55,450
लेकिन, अंत में, इनपुट आकार के रूप में बढ़ जाती है

117
00:04:55,450 --> 00:04:58,760
अनंत की ओर, हे (एन) ² एल्गोरिथ्म क्रम

118
00:04:58,760 --> 00:05:02,000
अंततः हे एल्गोरिथ्म (एन) के क्रम ग्रहण करेंगे.

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
एल्गोरिदम कि हे में चलाने (एन) ² समय वास्तव में अंत में अपने कार्यक्रम धीमा कर सकते हैं,

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
लघुगणक समय, हे (लॉग एन).

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 हिस्सा द्वारा क्रम बढ़ जाती है.

154
00:06:35,160 --> 00:06:37,770
फिर, सूची के बीच तत्व की जाँच, तो बंटवारे.

155
00:06:37,770 --> 00:06:40,440
इसलिए, यह logarithmic समय में काम करने के लिए कहा गया है,

156
00:06:40,440 --> 00:06:42,440
हे (लॉग एन).

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
क्रम पर.

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
यह (लॉग एन) विभाजन की जांच करने के

177
00:07:28,690 --> 00:07:31,030
सरणी के सही तत्व को खोजने के लिए.

178
00:07:31,030 --> 00:07:34,270
सबसे ज्यादा मामले ऊपरी सीमा को बड़ा "ओ" है कि आप पहले से ही पता है के साथ भेजा जाता है.

179
00:07:34,270 --> 00:07:38,080
इसलिए, यह हे (लॉग एन), लेकिन Ω (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
फिर, 1 तत्व आप चाहते हैं.

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
इसलिए, यह हे समय (एन) में चलाता

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
>> यदि आप हे (एन) एल्गोरिथ्म ² में चल रहे हैं,

215
00:09:12,490 --> 00:09:15,240
या बुरा, एक हे (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 जटिलता है. धन्यवाद.