1 00:00:00,000 --> 00:00:02,570 [Powered by Google Translate] [धारा 3 - अधिक आरामदायक] 2 00:00:02,570 --> 00:00:05,070 [रोब Bowden - हार्वर्ड विश्वविद्यालय] 3 00:00:05,070 --> 00:00:07,310 >> [यह CS50 है. - CS50.TV] 4 00:00:07,310 --> 00:00:12,700 >> तो पहला सवाल अजीब शब्दों है. 5 00:00:12,700 --> 00:00:17,480 GDB की मदद से आप "डिबग" एक कार्यक्रम है, लेकिन, और अधिक विशेष रूप से, यह क्या आप करते हैं? 6 00:00:17,480 --> 00:00:22,590 मैं एक जवाब है कि, और मैं नहीं जानता कि वास्तव में क्या उम्मीद है, 7 00:00:22,590 --> 00:00:27,910 इसलिए मैं यह की तर्ज साथ यह कुछ लग रहा है की मदद से आप कदम से कदम 8 00:00:27,910 --> 00:00:31,540 कार्यक्रम के माध्यम से चलते हैं, इसके साथ बातचीत करने के लिए, परिवर्तन चर, ये सब बातें करते - 9 00:00:31,540 --> 00:00:34,270 मूल रूप से पूरी तरह से एक कार्यक्रम के नियंत्रण 10 00:00:34,270 --> 00:00:38,410 और कार्यक्रम के क्रियान्वयन के किसी भी भाग का निरीक्षण किया. 11 00:00:38,410 --> 00:00:43,030 तो उन सुविधाओं को जाने के लिए आप चीजों डिबग. 12 00:00:43,030 --> 00:00:44,830 ठीक है. 13 00:00:44,830 --> 00:00:50,520 द्विआधारी खोज क्यों आवश्यकता नहीं है कि एक सरणी हल किया जा? 14 00:00:50,520 --> 00:00:53,360 कौन है कि जवाब देने के लिए करना चाहता है? 15 00:00:56,120 --> 00:01:00,070 [छात्र] क्योंकि यह अगर यह हल नहीं है काम नहीं करता. >> हाँ. [हँसी] 16 00:01:00,070 --> 00:01:04,910 अगर यह हल नहीं है, तो यह असंभव है यह आधे में विभाजित 17 00:01:04,910 --> 00:01:07,850 और छोड़ दिया है कि सब कुछ पता है और कम से सही करने के लिए सब कुछ है 18 00:01:07,850 --> 00:01:10,490 मध्यम मूल्य से अधिक है. 19 00:01:10,490 --> 00:01:12,790 तो यह हल किया जा करने की जरूरत है. 20 00:01:12,790 --> 00:01:14,170 ठीक है. 21 00:01:14,170 --> 00:01:17,570 क्यों चुकता n हे में बुलबुले की तरह है? 22 00:01:17,570 --> 00:01:23,230 क्या किसी को पहले एक बहुत जल्दी क्या बुलबुला तरह की उच्च स्तरीय सिंहावलोकन देने के लिए करना चाहते हैं? 23 00:01:25,950 --> 00:01:33,020 [छात्र] आप मूल रूप से प्रत्येक तत्व के माध्यम से जाना है और आप पहले कुछ तत्वों की जाँच करें. 24 00:01:33,020 --> 00:01:37,150 अगर वे जहाँ आप उन्हें स्वैप से बाहर रहे हैं, तो आप अगले कुछ तत्वों और इतने पर की जाँच करें. 25 00:01:37,150 --> 00:01:40,770 जब आप अंत तक पहुँचते हैं, तो आप जानते हैं कि सबसे बड़ा तत्व अंत में रखा गया है, 26 00:01:40,770 --> 00:01:42,750 तो आप की अनदेखी है कि एक तो आप के माध्यम से जा रहा पर रखने, 27 00:01:42,750 --> 00:01:48,490 और हर बार जब आप एक कम तत्व की जांच जब तक आप में कोई परिवर्तन नहीं है. >> हाँ. 28 00:01:48,490 --> 00:01:58,470 यह बुलबुला तरह कहा जाता है क्योंकि अगर आप अपने पक्ष पर सरणी फ्लिप तो यह ऊपर है और नीचे, खड़ी, 29 00:01:58,470 --> 00:02:03,100 तो बड़ी मूल्यों नीचे सिंक और छोटे मूल्यों शीर्ष पर बुलबुला होगा. 30 00:02:03,100 --> 00:02:05,210 यही कारण है कि यह कैसे अपने नाम मिल गया. 31 00:02:05,210 --> 00:02:08,220 और हाँ, तुम बस के माध्यम से जाना. 32 00:02:08,220 --> 00:02:11,190 आप सरणी के माध्यम से जा रहा रखने के लिए, बड़ा मूल्य गमागमन 33 00:02:11,190 --> 00:02:14,040 नीचे करने के लिए सबसे बड़ा मूल्यों को प्राप्त है. 34 00:02:14,040 --> 00:02:17,500 >> चुकता n हे ऐसा क्यों है? 35 00:02:18,690 --> 00:02:24,620 सबसे पहले, किसी को भी कहते हैं कि क्यों यह n हे चुकता करना चाहती है? 36 00:02:24,620 --> 00:02:28,760 [छात्र] क्योंकि प्रत्येक रन के लिए यह n बार चला जाता है. 37 00:02:28,760 --> 00:02:32,100 तुम सिर्फ यकीन है कि आप सबसे बड़ा तत्व सभी तरह से नीचे ले लिया है हो सकता है, 38 00:02:32,100 --> 00:02:35,230 तो आप कई तत्वों के रूप में लिए है कि दोहराना है. >> हाँ. 39 00:02:35,230 --> 00:02:41,800 तो मन में रखने के लिए बड़ी हे क्या मतलब है और क्या बड़ा ओमेगा का मतलब. 40 00:02:41,800 --> 00:02:50,560 बड़ा हे धीमी गति से यह वास्तव में कैसे चला सकते हैं पर बाध्य ऊपरी की तरह है. 41 00:02:50,560 --> 00:02:58,990 तो यह चुकता n हे कह कर, यह पता हे या नहीं है और इसे चलाने के लिए सक्षम होगा 42 00:02:58,990 --> 00:03:02,640 रैखिक समय में है, लेकिन यह पता cubed हे है 43 00:03:02,640 --> 00:03:06,390 क्योंकि यह n cubed हे से घिरा है. 44 00:03:06,390 --> 00:03:12,300 यदि यह चुकता n हे से घिरा है, तो यह भी पता cubed द्वारा घिरा है. 45 00:03:12,300 --> 00:03:20,280 तो यह n चुकता है, और निरपेक्ष सबसे खराब स्थिति में यह चुकता n की तुलना में बेहतर नहीं कर सकते हैं, 46 00:03:20,280 --> 00:03:22,830 जो है क्यों यह चुकता n हे है. 47 00:03:22,830 --> 00:03:31,200 तो देखने के लिए कि यह कैसे बाहर आता n चुकता मामूली गणित, 48 00:03:31,200 --> 00:03:40,530 अगर हम हमारी सूची में पाँच बातें हैं, पहली बार कितने स्वैप हम संभवतः के लिए बनाने की जरूरत सकता है 49 00:03:40,530 --> 00:03:47,170 आदेश में इस पाने के लिए? चलो वास्तव में सिर्फ - 50 00:03:47,170 --> 00:03:52,040 हम कितने स्वैप करने के लिए सरणी के माध्यम से बुलबुला तरह का पहला रन बनाने के लिए है करने के लिए जा रहे हैं? 51 00:03:52,040 --> 00:03:53,540 [छात्र] n - 1. >> हाँ. 52 00:03:53,540 --> 00:03:58,340 >> 1 - अगर वहाँ 5 तत्व हैं, हम करने के लिए n बनाने की आवश्यकता जा रहे हैं. 53 00:03:58,340 --> 00:04:01,100 फिर एक दूसरे पर हम कितने स्वैप करने के लिए बनाने के लिए जा रहे हैं? 54 00:04:01,100 --> 00:04:03,440 [छात्र] n - 2. >> हाँ. 55 00:04:03,440 --> 00:04:11,640 और तीसरा n होना जा रहा है - 3, और फिर सुविधा के लिए मैं पिछले दो लिखेंगे 56 00:04:11,640 --> 00:04:15,270 तब के रूप में हम करने के लिए 2 स्वैप और 1 स्वैप करने की आवश्यकता के लिए जा रहे हैं. 57 00:04:15,270 --> 00:04:19,899 मुझे लगता है कि पिछले एक या होने की जरूरत हो सकता है नहीं वास्तव में. 58 00:04:19,899 --> 00:04:22,820 यह एक स्वैप है? मुझे नहीं मालूम. 59 00:04:22,820 --> 00:04:26,490 तो इन स्वैप की कुल मात्रा में या कम से कम तुलना आपको करना है. 60 00:04:26,490 --> 00:04:29,910 यहां तक ​​कि अगर आप स्वैप नहीं है, तो आप अभी भी मूल्यों की तुलना की जरूरत है. 61 00:04:29,910 --> 00:04:33,910 तो वहाँ n सरणी के माध्यम से 1 रन में 1 तुलना. 62 00:04:33,910 --> 00:04:42,050 यदि आप इन बातों को पुनर्व्यवस्थित, वास्तव में यह छह चीजें बनाने के लिए चीजों को अच्छी तरह से धुआँरा, 63 00:04:42,050 --> 00:04:44,790 और फिर मैं 3 करने के लिए, 2 हूँ, 1. 64 00:04:44,790 --> 00:04:49,910 तो बस इन रकम उलटफेर, हम देखते हैं कितने तुलना हम बनाने चाहते हैं 65 00:04:49,910 --> 00:04:52,700 पूरे एल्गोरिथ्म में. 66 00:04:52,700 --> 00:04:56,550 तो अगर हम यहाँ नीचे इन लोगों को लाने के लिए, 67 00:04:56,550 --> 00:05:07,470 तो हम अब भी कर रहे हैं लेकिन कई की तुलना वहाँ थे संक्षेप. 68 00:05:07,470 --> 00:05:13,280 लेकिन अगर हम इन राशि और हम इन राशि और हम इन संक्षेप 69 00:05:13,280 --> 00:05:18,130 यह अभी भी एक ही समस्या है. हम बस विशेष रूप से उन समूहों का योग. 70 00:05:18,130 --> 00:05:22,400 >> तो अब हम 3 एन संक्षेप रहे हैं. यह सिर्फ 3 n नहीं है. 71 00:05:22,400 --> 00:05:27,650 यह हमेशा n / 2 n होने जा रहा है. 72 00:05:27,650 --> 00:05:29,430 यहाँ तो हम 6 के लिए होता है. 73 00:05:29,430 --> 00:05:34,830 अगर हम 10 बातें किया था, तो हम चीजों के 5 अलग जोड़े के लिए इस समूह कर सकता है 74 00:05:34,830 --> 00:05:37,180 और + n n n + + + n n के साथ खत्म होता है. 75 00:05:37,180 --> 00:05:45,840 तो तुम हमेशा n / 2 n मिल जा रहे हैं, और तो यह हम इसे / 2 चुकता n लिख लेता हूँ. 76 00:05:45,840 --> 00:05:48,890 और तो भले ही आधे का कारक है, जो में आने के लिए होता है 77 00:05:48,890 --> 00:05:54,190 तथ्य यह है कि सरणी पर प्रत्येक चलना के माध्यम से हम कम 1 तुलना की वजह से 78 00:05:54,190 --> 00:05:58,040 इतना है कि कैसे हम 2 से अधिक मिलता है, लेकिन यह अभी भी चुकता n है. 79 00:05:58,040 --> 00:06:01,650 हम एक आधे के निरंतर कारक के बारे में परवाह नहीं है. 80 00:06:01,650 --> 00:06:07,760 तो इस तरह बड़े हे सामान की एक बहुत सिर्फ गणित के इस प्रकार के कर के प्रकार पर निर्भर करता है, 81 00:06:07,760 --> 00:06:12,260 गणित रकम और ज्यामितीय श्रृंखला सामान कर रही है, 82 00:06:12,260 --> 00:06:17,750 लेकिन इस कोर्स में उनमें से ज्यादातर बहुत सीधा कर रहे हैं. 83 00:06:17,750 --> 00:06:19,290 ठीक है. 84 00:06:19,290 --> 00:06:24,430 N के ओमेगा में अंतरवेशन शॉटन क्यों है? ओमेगा क्या मतलब है? 85 00:06:24,430 --> 00:06:27,730 [दो छात्रों को एक ही बार में बोल - unintelligible] >> हाँ. 86 00:06:27,730 --> 00:06:30,630 आप ओमेगा के रूप में कम बाध्य के बारे में सोच सकते हैं. 87 00:06:30,630 --> 00:06:36,550 >> तो कोई बात नहीं कैसे कुशल आपके सम्मिलन सॉर्ट एल्गोरिथ्म है, 88 00:06:36,550 --> 00:06:41,810 की परवाह किए बिना कि सूची में पारित कर दिया है, यह हमेशा के लिए कम से कम n चीजों की तुलना 89 00:06:41,810 --> 00:06:44,620 या यह n बातों पर पुनरावृति है. 90 00:06:44,620 --> 00:06:47,280 ऐसा क्यों है? 91 00:06:47,280 --> 00:06:51,190 [छात्र] क्योंकि यदि सूची पहले से ही सॉर्ट किया जाता है, तो के माध्यम से पहली यात्रा 92 00:06:51,190 --> 00:06:54,080 आप केवल गारंटी नहीं है कि बहुत पहले तत्व कम से कम कर सकते हैं, 93 00:06:54,080 --> 00:06:56,490 और दूसरी यात्रा आप केवल पहले दो की गारंटी कर सकते हैं 94 00:06:56,490 --> 00:07:00,010 क्योंकि आप नहीं जानते कि सूची के बाकी हल है. >> हाँ. 95 00:07:00,010 --> 00:07:08,910 यदि आप एक पूरी तरह से क्रमबद्ध सूची में बहुत कम से कम, पास आप सभी तत्वों पर जाना है 96 00:07:08,910 --> 00:07:12,180 देखने के लिए कुछ भी नहीं करने के लिए चारों ओर ले जाया जा जरूरत है. 97 00:07:12,180 --> 00:07:14,720 तो खत्म हो सूची गुजर रहा है और कह रही है ओह, यह पहले से ही सॉर्ट किया जाता है, 98 00:07:14,720 --> 00:07:18,240 यह असंभव है के लिए आप जानते हैं यह हल है जब तक आप प्रत्येक तत्व की जांच 99 00:07:18,240 --> 00:07:20,660 देखना है कि वे क्रमबद्ध क्रम में हैं. 100 00:07:20,660 --> 00:07:25,290 तो सम्मिलन प्रकार पर ही कम n के ओमेगा है. 101 00:07:25,290 --> 00:07:28,210 सबसे खराब मामला मर्ज तरह के समय क्या चल रहा है, 102 00:07:28,210 --> 00:07:31,390 सबसे खराब मामला बड़ा हे फिर से किया जा रहा है? 103 00:07:31,390 --> 00:07:37,660 तो सबसे बुरी स्थिति में, कैसे मर्ज तरह से चलाने में करता है? 104 00:07:42,170 --> 00:07:43,690 [छात्र] एन लॉग एन. >> हाँ. 105 00:07:43,690 --> 00:07:49,990 सबसे तेजी से सामान्य छँटाई एल्गोरिदम n लॉग एन. बेहतर होगा कि तुम ऐसा नहीं कर सकते. 106 00:07:51,930 --> 00:07:55,130 >> विशेष मामलों में कर रहे हैं, और अगर हम आज समय है लेकिन हम शायद won't - 107 00:07:55,130 --> 00:07:59,330 हम एक है कि n लॉग एन की तुलना में बेहतर करता देख सकता था. 108 00:07:59,330 --> 00:08:04,050 लेकिन सामान्य मामले में, आप n लॉग एन की तुलना में बेहतर नहीं कर सकते हैं. 109 00:08:04,050 --> 00:08:09,680 और मर्ज तरह n लॉग n है कि इस पाठ्यक्रम के लिए एक पता होना चाहिए होता है. 110 00:08:09,680 --> 00:08:13,260 और इतना है कि आज हम वास्तव में लागू करने हो जाएगा. 111 00:08:13,260 --> 00:08:18,070 और अंत में, कोई तीन से अधिक वाक्यों में चयन छंटाई कैसे काम करता है? 112 00:08:18,070 --> 00:08:20,370 क्या किसी को जवाब देना चाहते हैं, और मैं अपने वाक्य गिनती जाएगा 113 00:08:20,370 --> 00:08:22,390 क्योंकि अगर आप 3 से अधिक जाने - 114 00:08:25,530 --> 00:08:28,330 क्या किसी को चयन छंटाई याद है? 115 00:08:31,280 --> 00:08:37,809 चयन तरह आम तौर पर होता है बहुत आसान करने के लिए सिर्फ नाम से याद है. 116 00:08:37,809 --> 00:08:45,350 तुम बस पर पुनरावृति सरणी, जो भी सबसे बड़ा मूल्य है या छोटी - 117 00:08:45,350 --> 00:08:47,290 आदेश जो कुछ भी तुम्हें अंदर छँटाई कर रहे हैं 118 00:08:47,290 --> 00:08:50,750 तो हम कहते हैं कि हम सबसे बड़ी से छोटी छँटाई कर रहे हैं. 119 00:08:50,750 --> 00:08:55,250 आप सरणी पर पुनरावृति, जो न्यूनतम तत्व है के लिए देख रहे हैं, 120 00:08:55,250 --> 00:08:59,750 यह चयन करने के लिए, और फिर बस यह स्वैप जो पहली जगह में है. 121 00:08:59,750 --> 00:09:04,090 और फिर सरणी पर 2 पास न्यूनतम तत्व के लिए फिर देखो, 122 00:09:04,090 --> 00:09:07,490 यह चयन करें, और तब यह क्या 2 की स्थिति में है साथ स्वैप. 123 00:09:07,490 --> 00:09:10,650 तो हम बस उठा रहे हैं और न्यूनतम मूल्यों का चयन 124 00:09:10,650 --> 00:09:16,050 और उन्हें सरणी के सामने में डालने जब तक यह हल है. 125 00:09:19,210 --> 00:09:21,560 उस पर सवाल? 126 00:09:21,560 --> 00:09:25,710 >> ये अनिवार्य रूप से आप बाहर भरने के लिए जब आप प्रस्तुत कर रहे हैं pset रूपों में दिखाई देते हैं. 127 00:09:29,010 --> 00:09:32,360 वे मूल रूप से कर रहे हैं उन लोगों के लिए जवाब है. 128 00:09:32,360 --> 00:09:34,230 ठीक है, तो अब समस्याओं कोडन. 129 00:09:34,230 --> 00:09:40,140 मैं पहले से ही ईमेल पर बाहर भेज दिया - क्या किसी को भी उस ईमेल पाने के लिए नहीं? ठीक है. 130 00:09:40,140 --> 00:09:46,630 मैं पहले से ही ईमेल पर बाहर भेजा जगह है कि हम का उपयोग करने के लिए जा रहे हैं, 131 00:09:46,630 --> 00:09:52,120 और अगर आप मेरे नाम पर क्लिक करें तो मुझे लगता है कि मैं करने के लिए नीचे होने जा रहा हूँ 132 00:09:52,120 --> 00:09:57,170 क्योंकि आर के पीछे की ओर - लेकिन अगर तुम मेरे नाम पर क्लिक करें आप 2 संशोधन देखेंगे. 133 00:09:57,170 --> 00:10:02,650 1 संशोधन करने के लिए मैं पहले से ही नकल हो सकता है और रिक्त स्थान में कोड चिपकाया जा रहा है 134 00:10:02,650 --> 00:10:06,900 खोज बात के लिए आप को लागू करने के लिए जा रहे हैं. 135 00:10:06,900 --> 00:10:10,540 और 2 संशोधन तरह बात यह है कि हम उस के बाद लागू किया जाएगा. 136 00:10:10,540 --> 00:10:15,770 तो तुम मेरे 1 अवतरण पर क्लिक करें और वहाँ से काम कर सकते हैं. 137 00:10:17,350 --> 00:10:22,060 और अब हम द्विआधारी खोज को लागू करना चाहते हैं. 138 00:10:22,060 --> 00:10:26,470 >> क्या किसी को सिर्फ एक pseudocode उच्च स्तर के विवरण देना चाहता हूँ 139 00:10:26,470 --> 00:10:31,440 की हम क्या करने के लिए खोज के लिए क्या करना है करने के लिए जा रहे हैं? हाँ. 140 00:10:31,440 --> 00:10:36,170 [छात्र] तुम बस सरणी के बीच लेने और देखने के लिए कि क्या आप के लिए देख रहे हैं 141 00:10:36,170 --> 00:10:38,650 कि कम से कम या अधिक से अधिक है कि है. 142 00:10:38,650 --> 00:10:41,080 और अगर यह कम है, आप आधा है कि कम है के लिए जाना है, 143 00:10:41,080 --> 00:10:44,750 और अगर यह अधिक है, आप आधा है कि अधिक है और आप दोहराना है कि जब तक आप सिर्फ एक ही बात हो. 144 00:10:44,750 --> 00:10:46,570 [Bowden] हाँ. 145 00:10:46,570 --> 00:10:51,320 सूचना है कि पहले से ही हमारे संख्या सरणी सॉर्ट किया जाता है, 146 00:10:51,320 --> 00:10:57,190 और तो इसका मतलब है कि हम इस बात का फायदा लेने के लिए और हम पहले की जाँच कर सकता कर सकते हैं, 147 00:10:57,190 --> 00:11:00,390 ठीक है, मैं 50 नंबर के लिए देख रहा हूँ. 148 00:11:00,390 --> 00:11:03,720 तो मैं बीच में जा सकते हैं. 149 00:11:03,720 --> 00:11:07,380 मध्य परिभाषित करना मुश्किल है जब यह चीजों की एक भी नंबर है, 150 00:11:07,380 --> 00:11:10,820 लेकिन चलो बस का कहना है कि हम हमेशा बीच में काटना होगा. 151 00:11:10,820 --> 00:11:14,420 तो यहाँ हम 8 बातें है, तो बीच 16 होगा. 152 00:11:14,420 --> 00:11:17,330 मैं 50 के लिए देख रहा हूँ, तो 50 16 से अधिक है. 153 00:11:17,330 --> 00:11:21,310 तो अब मैं मूल रूप से इन तत्वों के रूप में अपने सरणी का इलाज कर सकते हैं. 154 00:11:21,310 --> 00:11:23,450 मैं 16 से अधिक सब कुछ दूर फेंक कर सकते हैं. 155 00:11:23,450 --> 00:11:27,440 अब मेरी सरणी इन 4 तत्वों, और मैं फिर से. 156 00:11:27,440 --> 00:11:31,910 तो फिर मैं बीच खोजने के लिए फिर से करना चाहते हैं, जो 42 होने जा रहा है. 157 00:11:31,910 --> 00:11:34,730 50 से 42 कम है, इसलिए मैं इन दोनों तत्वों को दूर फेंक कर सकते हैं. 158 00:11:34,730 --> 00:11:36,890 यह मेरे शेष सरणी है. 159 00:11:36,890 --> 00:11:38,430 मैं बीच फिर से खोजने के लिए जा रहा हूँ. 160 00:11:38,430 --> 00:11:42,100 मुझे लगता है कि 50 एक बुरा उदाहरण था क्योंकि मैं हमेशा दूर फेंक रहा था छोड़ दिया करने के लिए चीजें, 161 00:11:42,100 --> 00:11:48,280 लेकिन एक ही उपाय है, अगर मैं कुछ के लिए देख रहा हूँ 162 00:11:48,280 --> 00:11:52,100 और यह तत्व कम से कम मैं वर्तमान में देख रहा हूँ, 163 00:11:52,100 --> 00:11:55,080 तो मैं सही करने के लिए सब कुछ दूर फेंक करने के लिए जा रहा हूँ. 164 00:11:55,080 --> 00:11:58,150 तो अब हम को लागू करने की जरूरत है कि. 165 00:11:58,150 --> 00:12:02,310 सूचना है कि हम आकार में पारित करने की जरूरत है. 166 00:12:02,310 --> 00:12:06,730 हम भी कड़ी मेहनत से कोड आकार की जरूरत नहीं कर सकते हैं. 167 00:12:06,730 --> 00:12:11,640 तो अगर हम उससे छुटकारा पाना परिभाषित # 168 00:12:19,630 --> 00:12:21,430 ठीक है. 169 00:12:21,430 --> 00:12:27,180 कैसे मैं अच्छी तरह से समझ सकते हैं कि संख्या सरणी के आकार वर्तमान में क्या है? 170 00:12:27,180 --> 00:12:30,950 >> कितने तत्वों संख्या सरणी में कर रहे हैं? 171 00:12:30,950 --> 00:12:33,630 [छात्र] नंबर, कोष्ठक, लंबाई. 172 00:12:33,630 --> 00:12:36,600 [Bowden] सी. में नहीं मौजूद नहीं है 173 00:12:36,600 --> 00:12:38,580 की जरूरत है. लंबाई. 174 00:12:38,580 --> 00:12:42,010 Arrays गुण नहीं है, तो वहाँ arrays का कोई लंबाई संपत्ति है 175 00:12:42,010 --> 00:12:45,650 कि सिर्फ तुम लेकिन यह लंबे समय के लिए होता है दे देंगे. 176 00:12:48,180 --> 00:12:51,620 देखें [छात्र] कितना स्मृति यह है और कितना विभाजित >> हाँ. 177 00:12:51,620 --> 00:12:55,810 तो हम कैसे देख सकते हैं कितना स्मृति यह कर सकते हैं? >> [छात्र] sizeof. >> हाँ, sizeof. 178 00:12:55,810 --> 00:13:01,680 Sizeof ऑपरेटर है कि संख्या सरणी के आकार वापस जा रहा है है. 179 00:13:01,680 --> 00:13:10,060 और कहा कि लेकिन कई integers होने जा रहा है वहाँ कई बार एक पूर्णांक के आकार के होते हैं 180 00:13:10,060 --> 00:13:14,050 बाद से है कि कितना स्मृति यह वास्तव में ले जा रहा है. 181 00:13:14,050 --> 00:13:17,630 , तो अगर मैं सरणी में बातें की संख्या चाहते हैं 182 00:13:17,630 --> 00:13:20,560 तो मैं एक पूर्णांक के आकार के आधार पर विभाजित करने के लिए जा रहा हूँ. 183 00:13:22,820 --> 00:13:26,010 ठीक है. तो देता है कि मुझे यहाँ आकार में गुजरती है. 184 00:13:26,010 --> 00:13:29,430 मैं आकार में पारित करने की आवश्यकता क्यों है? 185 00:13:29,430 --> 00:13:38,570 मैं सिर्फ क्यों नहीं ऊपर यहाँ कर सकते हैं int आकार = sizeof (टेबल) / sizeof (int)? 186 00:13:38,570 --> 00:13:41,490 यह काम क्यों नहीं करता है? 187 00:13:41,490 --> 00:13:44,470 [छात्र] यह एक वैश्विक चर नहीं है. 188 00:13:44,470 --> 00:13:51,540 [Bowden] टेबल मौजूद है और हम संख्या में सूखी घास का ढेर के रूप में पारित कर रहे हैं, 189 00:13:51,540 --> 00:13:54,700 और यह क्या करने के लिए आ रहा है की एक पूर्वाभास की तरह है. हाँ. 190 00:13:54,700 --> 00:14:00,170 [छात्र] टेबल सिर्फ यह करने के लिए संदर्भ है, तो यह लौटेंगे कितना बड़ा है कि संदर्भ है. 191 00:14:00,170 --> 00:14:02,150 हाँ. 192 00:14:02,150 --> 00:14:09,000 मैं व्याख्यान में संदेह नहीं है कि आप ढेर देखा है अभी तक वास्तव में सही है? 193 00:14:09,000 --> 00:14:11,270 हम अभी इसके बारे में बात की है. 194 00:14:11,270 --> 00:14:16,090 तो हो चुकी है, जहां अपने सभी चर के लिए भंडारित किया जा जा रहे हैं. 195 00:14:16,090 --> 00:14:19,960 >> कोई स्मृति है कि स्थानीय चर के लिए आवंटित किया गया है ढेर में जा रहा है, 196 00:14:19,960 --> 00:14:24,790 और प्रत्येक कार्य के ढेर पर अपनी जगह हो जाता है, अपने स्वयं के ढेर फ्रेम है क्या यह कहा जाता है. 197 00:14:24,790 --> 00:14:31,590 तो मुख्य ढेर फ्रेम है, और इसे के अंदर करने के लिए इस संख्या सरणी मौजूद जा रहा है, 198 00:14:31,590 --> 00:14:34,270 और यह आकार sizeof (संख्या) का होने जा रहा है. 199 00:14:34,270 --> 00:14:38,180 यह तत्वों के आकार के आधार पर विभाजित संख्या के आकार किया जा रहा है, 200 00:14:38,180 --> 00:14:42,010 लेकिन मुख्य ढेर फ्रेम के भीतर सभी जीवन है कि. 201 00:14:42,010 --> 00:14:45,190 जब हम खोज फोन, खोज अपने स्वयं के ढेर फ्रेम हो जाता है, 202 00:14:45,190 --> 00:14:48,840 अपनी जगह अपने स्थानीय चर के सभी स्टोर करने के लिए. 203 00:14:48,840 --> 00:14:56,420 लेकिन इन तर्कों - तो टेबल में इस पूरे सरणी की एक प्रतिलिपि नहीं है. 204 00:14:56,420 --> 00:15:00,990 हम खोज में एक प्रति के रूप में पूरे सरणी में पास नहीं है. 205 00:15:00,990 --> 00:15:04,030 यह सिर्फ कि सरणी के लिए एक संदर्भ गुजरता है. 206 00:15:04,030 --> 00:15:11,470 तो खोज इस संदर्भ के माध्यम से इन नंबरों का उपयोग कर सकते हैं. 207 00:15:11,470 --> 00:15:17,100 यह अभी भी चीजें हैं जो मुख्य ढेर फ्रेम के अंदर रहने तक पहुँचने है, 208 00:15:17,100 --> 00:15:22,990 लेकिन मूल रूप से, जब हम संकेत करने के लिए मिलता है, जो जल्द ही होना चाहिए, 209 00:15:22,990 --> 00:15:24,980 यह है कि संकेत क्या कर रहे हैं. 210 00:15:24,980 --> 00:15:29,400 सूचक सिर्फ बातें करने के लिए संदर्भ, और आप संकेत का उपयोग करने के लिए चीजों का उपयोग कर सकते हैं 211 00:15:29,400 --> 00:15:32,030 है कि अन्य बातें ढेर फ्रेम में हैं. 212 00:15:32,030 --> 00:15:37,660 तो भले ही संख्या मुख्य करने के लिए स्थानीय है, हम अभी भी इस सूचक के माध्यम से उपयोग कर सकते हैं. 213 00:15:37,660 --> 00:15:41,770 लेकिन जब से यह सिर्फ एक सूचक है और यह सिर्फ एक संदर्भ है, 214 00:15:41,770 --> 00:15:45,040 sizeof (टेबल) सिर्फ संदर्भ ही के आकार देता है. 215 00:15:45,040 --> 00:15:47,950 यह बात की ओर इशारा करते है के आकार वापस नहीं करता है. 216 00:15:47,950 --> 00:15:51,110 यह संख्या का वास्तविक आकार वापस नहीं करता है. 217 00:15:51,110 --> 00:15:55,660 और इसलिए यह काम करने के लिए नहीं जा रहा है के रूप में हम यह चाहते है. 218 00:15:55,660 --> 00:15:57,320 >> उस पर सवाल? 219 00:15:57,320 --> 00:16:03,250 सूचक में काफी अधिक रक्तमय विस्तार में चला गया हो सप्ताह में लिए आते हैं. 220 00:16:06,750 --> 00:16:13,740 और इस वजह से चीजें हैं जो आप देखते हैं, सबसे खोज बातें या इस तरह बातें की एक बहुत कुछ है, 221 00:16:13,740 --> 00:16:16,990 वे लगभग सभी सरणी के वास्तविक आकार लेने की आवश्यकता के लिए जा रहे हैं, 222 00:16:16,990 --> 00:16:20,440 सी में है, क्योंकि हम कोई विचार नहीं है सरणी के आकार क्या है. 223 00:16:20,440 --> 00:16:22,720 आप मैन्युअल रूप से इसे पारित अंदर की जरूरत है 224 00:16:22,720 --> 00:16:27,190 और आप स्वयं पूरे सरणी में पारित नहीं क्योंकि आप सिर्फ संदर्भ में गुजर रहे हैं कर सकते हैं 225 00:16:27,190 --> 00:16:30,390 और इसे संदर्भ से आकार नहीं मिल सकता. 226 00:16:30,390 --> 00:16:32,300 ठीक है. 227 00:16:32,300 --> 00:16:38,160 तो अब हम को लागू करने से पहले क्या समझाया गया था चाहते हैं. 228 00:16:38,160 --> 00:16:41,530 तुम उस पर एक मिनट के लिए काम कर सकते हैं, 229 00:16:41,530 --> 00:16:45,250 और आप पूरी तरह से 100% सब कुछ काम कर रही के बारे में चिंता करने की ज़रूरत नहीं है. 230 00:16:45,250 --> 00:16:51,410 बस कैसे आपको लगता है कि यह काम करना चाहिए के लिए 1/2 pseudocode लिखने. 231 00:16:52,000 --> 00:16:53,630 ठीक है. 232 00:16:53,630 --> 00:16:56,350 नहीं करने के लिए पूरी तरह से इस के साथ अभी तक किया जा जरूरत है. 233 00:16:56,350 --> 00:17:02,380 लेकिन किसी को भी वे अब तक क्या किया है के साथ सहज महसूस करता है, 234 00:17:02,380 --> 00:17:05,599 कुछ की तरह हम एक साथ के साथ काम कर सकते हैं? 235 00:17:05,599 --> 00:17:09,690 क्या किसी को करने के लिए स्वयंसेवक चाहते हैं? या मैं बेतरतीब ढंग से ले जाएगा. 236 00:17:12,680 --> 00:17:18,599 यह करने के लिए कोई उपाय है, लेकिन हम एक काम कर रहे राज्य में संशोधित कर सकते हैं कुछ सही होना जरूरी नहीं है. 237 00:17:18,599 --> 00:17:20,720 [छात्र] ज़रूर. ठीक है. >> 238 00:17:20,720 --> 00:17:27,220 तो आप छोटे से बचाने के आइकन पर क्लिक करके संशोधन बचा सकता है. 239 00:17:27,220 --> 00:17:29,950 Ramya आप सही कर रहे हैं? >> [छात्र] हाँ. >> [Bowden] ठीक है. 240 00:17:29,950 --> 00:17:35,140 तो अब मैं अपने संशोधन देखने और हर कोई संशोधन खींच सकते हैं कर सकते हैं. 241 00:17:35,140 --> 00:17:38,600 और यहाँ हम है - ठीक है. 242 00:17:38,600 --> 00:17:43,160 Ramya पुनरावर्ती समाधान है, जो निश्चित रूप से एक मान्य हल के साथ चला गया. 243 00:17:43,160 --> 00:17:44,970 वहाँ के दो तरीके आप इस समस्या को कर सकते हैं कर रहे हैं. 244 00:17:44,970 --> 00:17:48,060 आप या तो यह iteratively या बारी बारी से कर सकते हैं. 245 00:17:48,060 --> 00:17:53,860 ज्यादातर समस्याओं का सामना है कि बारी बारी से किया जा सकता है भी iteratively किया जा सकता है. 246 00:17:53,860 --> 00:17:58,510 तो यहाँ हम यह recursively किया है. 247 00:17:58,510 --> 00:18:03,730 >> क्या किसी को परिभाषित करने के लिए यह क्या एक समारोह पुनरावर्ती बनाने का मतलब है करना चाहते हैं? 248 00:18:07,210 --> 00:18:08,920 [छात्र] जब आप एक समारोह है ही कॉल 249 00:18:08,920 --> 00:18:13,470 और फिर खुद को फोन जब तक यह सच है और सच के साथ बाहर आता है. >> हाँ. 250 00:18:13,470 --> 00:18:17,680 एक पुनरावर्ती समारोह सिर्फ एक समारोह है जो खुद को कॉल है. 251 00:18:17,680 --> 00:18:24,140 वहाँ तीन बड़ी चीजें हैं जो एक पुनरावर्ती समारोह होना चाहिए. 252 00:18:24,140 --> 00:18:27,310 1 जाहिर है, यह ही कहता है. 253 00:18:27,310 --> 00:18:29,650 दूसरा आधार मामला है. 254 00:18:29,650 --> 00:18:33,390 तो कुछ बिंदु पर कार्य करने के लिए ही फोन बंद करने की जरूरत है, 255 00:18:33,390 --> 00:18:35,610 और है कि आधार के मामले के लिए क्या है. 256 00:18:35,610 --> 00:18:43,860 यहाँ तो हम जानते हैं कि हम बंद कर देना चाहिए, हम हमारे खोज में देना चाहिए 257 00:18:43,860 --> 00:18:48,150 जब शुरू अंत के बराबर होती है और हम खत्म हो जाना है कि क्या मतलब है. 258 00:18:48,150 --> 00:18:52,130 लेकिन अंत में, आखिरी बात यह है कि पुनरावर्ती कार्यों के लिए महत्वपूर्ण है: 259 00:18:52,130 --> 00:18:59,250 कार्य किसी आधार के मामले दृष्टिकोण होना चाहिए. 260 00:18:59,250 --> 00:19:04,140 जैसे कि यदि आप वास्तव में कुछ भी नहीं अपडेट कर रहे हैं जब आप 2 पुनरावर्ती कॉल, 261 00:19:04,140 --> 00:19:07,880 यदि आप सचमुच सिर्फ रहे हैं समारोह फिर बुला ही तर्क के साथ 262 00:19:07,880 --> 00:19:10,130 और कोई वैश्विक चर बदल गया है या कुछ भी, 263 00:19:10,130 --> 00:19:14,430 जो बुरा है कि मामले में आप आधार मामला कभी नहीं पहुँच जाएगा, 264 00:19:14,430 --> 00:19:17,950 यह एक अनंत recursion और एक ढेर अतिप्रवाह हो जाएगा. 265 00:19:17,950 --> 00:19:24,330 लेकिन यहां हम देखते हैं कि अद्यतन हम शुरू से अद्यतन कर रहे हैं + 2 / अंत हो रहा है, 266 00:19:24,330 --> 00:19:28,180 हम अंत तर्क यहाँ अपडेट कर रहे हैं, हम शुरू तर्क अपडेट कर रहे हैं यहाँ. 267 00:19:28,180 --> 00:19:32,860 तो सभी पुनरावर्ती कॉल में हम कुछ अद्यतन कर रहे हैं. ठीक है. 268 00:19:32,860 --> 00:19:38,110 क्या आप हमें अपने समाधान के माध्यम से चलना चाहते हैं? ज़रूर. >> 269 00:19:38,110 --> 00:19:44,270 मैं SearchHelp का उपयोग कर रहा हूँ इतना है कि हर बार जब मैं इस समारोह फोन 270 00:19:44,270 --> 00:19:47,910 मैं जहां मैं सरणी में देख रहा हूँ के शुरू और अंत 271 00:19:47,910 --> 00:19:49,380 जहां की मैं सरणी देख रहा हूँ. 272 00:19:49,380 --> 00:19:55,330 >> हर कदम में जहां यह कह रहा है कि यह मध्य तत्व + 2 / अंत है जो शुरुआत है, 273 00:19:55,330 --> 00:19:58,850 वह यह है कि हम क्या देख रहे हो के लिए बराबर है? 274 00:19:58,850 --> 00:20:04,650 और अगर ऐसा है, तो हम यह पाया गया है, और मुझे लगता है कि recursion के स्तर पारित हो जाता है. 275 00:20:04,650 --> 00:20:12,540 और अगर यह सच नहीं है, तो हम जांच कि सरणी के बीच बहुत बड़ा मूल्य है, 276 00:20:12,540 --> 00:20:19,320 जो मामले में हम शुरू से ही मध्य सूचकांक करने के लिए जा रहा द्वारा सरणी के बाईं आधा पर दिखेगा. 277 00:20:19,320 --> 00:20:22,710 अन्यथा हम अंत आधा कर. 278 00:20:22,710 --> 00:20:24,740 [Bowden] ठीक है. 279 00:20:24,740 --> 00:20:27,730 यह अच्छा रहेगा. 280 00:20:27,730 --> 00:20:36,640 ठीक है, तो एक दो बातें, और वास्तव में, यह एक बहुत ही उच्च स्तर बात है 281 00:20:36,640 --> 00:20:41,270 है कि आप इस पाठ्यक्रम के लिए पता करने के लिए कभी नहीं की जरूरत है, लेकिन यह सच है. 282 00:20:41,270 --> 00:20:46,080 पुनरावर्ती काम करता है, तो आप हमेशा सुना है कि वे एक बुरा सौदा कर रहे हैं 283 00:20:46,080 --> 00:20:51,160 क्योंकि अगर आप recursively अपने आप को भी कई बार कहते हैं, आप ढेर अतिप्रवाह 284 00:20:51,160 --> 00:20:54,990 के बाद से, जैसा कि मैंने पहले कहा, हर समारोह में अपने स्वयं के ढेर फ्रेम हो जाता है. 285 00:20:54,990 --> 00:20:59,500 तो पुनरावर्ती समारोह के प्रत्येक कॉल अपने स्वयं के ढेर फ्रेम हो जाता है. 286 00:20:59,500 --> 00:21:04,140 तो अगर आप 1,000 पुनरावर्ती कॉल बनाने के लिए, आप 1,000 ढेर फ्रेम मिल, 287 00:21:04,140 --> 00:21:08,390 और जल्दी से आप भी कई ढेर फ्रेम और बातें सिर्फ तोड़ नेतृत्व. 288 00:21:08,390 --> 00:21:13,480 तो यही कारण है कि पुनरावर्ती कार्य आम तौर पर खराब कर रहे हैं. 289 00:21:13,480 --> 00:21:19,370 लेकिन वहाँ पुनरावर्ती कार्यों का एक अच्छा सबसेट पूंछ पुनरावर्ती कार्य कहा जाता है, 290 00:21:19,370 --> 00:21:26,120 और इस के लिए एक जहां अगर संकलक इस नोटिस का एक उदाहरण होना होता है 291 00:21:26,120 --> 00:21:29,920 और यह होना चाहिए, मुझे लगता है कि बजना में अगर आप यह झंडा O2 पास 292 00:21:29,920 --> 00:21:33,250 तो यह नोटिस इस पूंछ पुनरावर्ती है और बातें अच्छा कर देगा. 293 00:21:33,250 --> 00:21:40,050 >> यह प्रत्येक पुनरावर्ती कॉल के लिए पर और फिर से एक ही ढेर फ्रेम पुनः प्रयोग करेंगे. 294 00:21:40,050 --> 00:21:47,010 और इसलिए क्योंकि आप उसी ढेर फ्रेम का उपयोग कर रहे हैं, आप के बारे में चिंता करने की जरूरत नहीं करते 295 00:21:47,010 --> 00:21:51,690 कभी बह निकला हो चुकी है, और एक ही समय में, जैसे पहले कहा, 296 00:21:51,690 --> 00:21:56,380 जहां एक बार आप वापसी सच है, तो यह ऊपर इन ढेर फ्रेम के सभी लाभ है 297 00:21:56,380 --> 00:22:01,740 और SearchHelp 9 पर लौटने के लिए 10 कॉल, 8 पर लौटने के लिए है. 298 00:22:01,740 --> 00:22:05,360 तो यह है कि हो सकता है जब कार्य पूंछ पुनरावर्ती जरूरत नहीं है. 299 00:22:05,360 --> 00:22:13,740 और इसलिए इस समारोह में पूंछ पुनरावर्ती बनाता क्या सूचना है कि किसी भी searchHelp करने के लिए कॉल के लिए 300 00:22:13,740 --> 00:22:18,470 पुनरावर्ती फोन है कि इसे बना रहा है कि यह क्या लौट रहा है. 301 00:22:18,470 --> 00:22:25,290 SearchHelp के लिए पहले फोन में, हम या तो तुरंत वापसी झूठी, 302 00:22:25,290 --> 00:22:29,590 तुरंत वापसी सच है, या हम एक पुनरावर्ती फोन SearchHelp 303 00:22:29,590 --> 00:22:33,810 जहां हम लौट रहे हैं क्या है कि वह क्या कॉल लौट रहा है. 304 00:22:33,810 --> 00:22:51,560 और हम ऐसा नहीं कर सकता है अगर हम int x वापसी SearchHelp = x * 2 की तरह कुछ किया, 305 00:22:51,560 --> 00:22:55,440 बस कुछ यादृच्छिक परिवर्तन. 306 00:22:55,440 --> 00:23:01,470 >> तो अब यह पुनरावर्ती कॉल, इस int x = SearchHelp पुनरावर्ती कॉल, 307 00:23:01,470 --> 00:23:05,740 कोई लंबी पूंछ पुनरावर्ती है क्योंकि यह वास्तव में वापसी है 308 00:23:05,740 --> 00:23:10,400 वापस पिछले एक ढेर फ्रेम करने के लिए इतना है कि कार्य करने के लिए है कि पिछले कॉल 309 00:23:10,400 --> 00:23:13,040 फिर वापसी मान के साथ कुछ कर सकते हैं. 310 00:23:13,040 --> 00:23:22,190 तो यह पुनरावर्ती पूंछ नहीं है, लेकिन हम क्या था से पहले अच्छी तरह से पुनरावर्ती पूंछ है. हाँ. 311 00:23:22,190 --> 00:23:27,000 [छात्र] 2 आधार मामला पहले नहीं किया जा जाँच की जानी चाहिए 312 00:23:27,000 --> 00:23:30,640 क्योंकि वहाँ एक स्थिति है जहां जब आप यह तर्क से गुजारें सकता है 313 00:23:30,640 --> 00:23:35,770 = अंत शुरू कर दिया है, लेकिन वे सुई मान रहे हैं. 314 00:23:35,770 --> 00:23:47,310 सवाल इस मामले में चला सकते हैं नहीं किया गया था जहाँ हम अंत सुई मूल्य है 315 00:23:47,310 --> 00:23:52,000 या = अंत शुरू करने के लिए उचित है, = अंत शुरू 316 00:23:52,000 --> 00:23:59,480 और आप वास्तव में उस विशेष मान अभी तक की जाँच नहीं की है, 317 00:23:59,480 --> 00:24:03,910 तो + 2 / अंत शुरू करने के लिए बस एक ही मूल्य होने जा रहा है. 318 00:24:03,910 --> 00:24:07,890 लेकिन हम पहले से ही झूठे लौटा दिया है और हम मूल्य वास्तव में कभी नहीं की जाँच की. 319 00:24:07,890 --> 00:24:14,240 तो बहुत कम से कम, पहली कॉल में, अगर आकार 0 है, तो हम झूठी वापसी करना चाहते हैं. 320 00:24:14,240 --> 00:24:17,710 लेकिन यदि आकार 1 है, तो शुरू बराबर अंत करने के लिए नहीं जा रहा है, 321 00:24:17,710 --> 00:24:19,820 और हम कम से कम एक तत्व की जांच करेंगे. 322 00:24:19,820 --> 00:24:26,750 लेकिन मुझे लगता है कि आप सही कर रहे हैं कि हम एक मामले में अंत में, जहां + 2 / अंत शुरू कर सकते हैं, 323 00:24:26,750 --> 00:24:31,190 शुरू शुरू + 2 / अंत के रूप में ही किया जा रहा समाप्त होता है, 324 00:24:31,190 --> 00:24:35,350 लेकिन हम उस तत्व वास्तव में कभी नहीं की जाँच की. 325 00:24:35,350 --> 00:24:44,740 >> तो हम पहले की जाँच करें अगर मध्य तत्व के मूल्य के लिए हम देख रहे हैं, 326 00:24:44,740 --> 00:24:47,110 तो हम तुरंत वापसी सच कर सकते हैं. 327 00:24:47,110 --> 00:24:50,740 वरना अगर वे बराबर हो, तो जारी रखने में कोई मतलब नहीं है 328 00:24:50,740 --> 00:24:58,440 क्योंकि हम सिर्फ एक मामले में जहां हम एक एकल - तत्व सरणी पर हैं अद्यतन करने के लिए जा रहे हैं. 329 00:24:58,440 --> 00:25:01,110 यदि एक के लिए हम देख रहे हैं कि एकल तत्व नहीं है, 330 00:25:01,110 --> 00:25:03,530 तो सब कुछ गलत है. हाँ. 331 00:25:03,530 --> 00:25:08,900 [छात्र] बात यह है कि वास्तव में आकार के बाद से सरणी में तत्वों की संख्या की तुलना में बड़ा है, 332 00:25:08,900 --> 00:25:13,070 वहां पहले से ही एक ऑफसेट - >> तो आकार - 333 00:25:13,070 --> 00:25:19,380 [छात्र] कहते हैं कि अगर सरणी 0 आकार का था, तो SearchHelp वास्तव में 0 की टेबल की जाँच करेगा 334 00:25:19,380 --> 00:25:21,490 पहले फोन पर. 335 00:25:21,490 --> 00:25:25,300 सरणी 0 आकार है तो, 0 - >> हाँ. 336 00:25:25,300 --> 00:25:30,750 वहाँ एक और बात यह है कि यह अच्छा हो सकता है. चलो लगता है. 337 00:25:30,750 --> 00:25:40,120 तो अगर सरणी 10 तत्व था और हम जाँच करने के लिए जा रहे हैं बीच एक 5 सूचकांक है, 338 00:25:40,120 --> 00:25:45,700 तो हम 5 की जाँच कर रहे हैं, और हम कहते हैं कि मूल्य कम है. 339 00:25:45,700 --> 00:25:50,720 तो हम सब कुछ दूर फेंक रहे हैं 5 से आगे. 340 00:25:50,720 --> 00:25:54,030 तो शुरू + 2 / अंत करने के लिए हमारी नई अंत होने जा रहा है, 341 00:25:54,030 --> 00:25:57,450 हाँ तो, यह हमेशा के लिए सरणी के अंत से परे रहने के लिए जा रहा है. 342 00:25:57,450 --> 00:26:03,570 यदि यह मामला है अगर यह भी या विषम था, तो हम जांच, कहते हैं होगा, 4, 343 00:26:03,570 --> 00:26:05,770 लेकिन हम अभी भी दूर फेंक रहे हैं - 344 00:26:05,770 --> 00:26:13,500 तो हाँ, अंत हमेशा सरणी के वास्तविक अंत से परे होने जा रहा है. 345 00:26:13,500 --> 00:26:18,350 तत्व हम पर ध्यान केंद्रित कर रहे हैं तो, अंत हमेशा के लिए है कि एक के बाद एक होने जा रहा है. 346 00:26:18,350 --> 00:26:24,270 और यदि ऐसा है तो शुरू कभी बराबर अंत नहीं है, हम 0 आकार की एक सरणी में हैं. 347 00:26:24,270 --> 00:26:35,600 >> दूसरी बात मैं सोच रहा था कि हम शुरू अपडेट कर रहे हैं शुरू हो + / अंत 2, 348 00:26:35,600 --> 00:26:44,020 इसलिए इस मामले कि मैं मुसीबत के साथ आ रहा है, जहां + अंत / 2 शुरू 349 00:26:44,020 --> 00:26:46,820 तत्व हम जाँच कर रहे हैं. 350 00:26:46,820 --> 00:26:58,150 हम कहते हैं कि हम इस 10-तत्व सरणी था. जो भी हो. 351 00:26:58,150 --> 00:27:03,250 तो शुरू + / 2 को समाप्त करने के लिए यह एक तरह कुछ होने जा रहा है, 352 00:27:03,250 --> 00:27:07,060 और अगर है कि मूल्य नहीं है, कहते हैं, हम अद्यतन करने के लिए करना चाहते हैं. 353 00:27:07,060 --> 00:27:10,060 मूल्य अधिक होता है, तो हम सरणी के इस आधे पर देखना चाहता हूँ. 354 00:27:10,060 --> 00:27:15,910 तो कैसे हम शुरू अद्यतन कर रहे हैं, हम शुरू अपडेट कर रहे हैं अब इस तत्व हो. 355 00:27:15,910 --> 00:27:23,790 लेकिन यह अभी भी काम करते हैं, हो सकता है या बहुत कम से कम, आप शुरू करना + / अंत 2 + एक कर सकते हैं. 356 00:27:23,790 --> 00:27:27,850 आप + अंत शुरू होने की जरूरत नहीं है [छात्र] [अश्राव्य] >> हाँ. 357 00:27:27,850 --> 00:27:33,240 हम पहले से ही इस तत्व की जाँच की है और पता है कि यह एक के लिए हम देख रहे हैं नहीं है. 358 00:27:33,240 --> 00:27:36,800 तो हम शुरू अद्यतन करने के लिए इस तत्व की जरूरत नहीं है. 359 00:27:36,800 --> 00:27:39,560 हम सिर्फ यह छोड़ सकते हैं और इस तत्व होना शुरू करने के लिए अद्यतन. 360 00:27:39,560 --> 00:27:46,060 और वहाँ कभी एक मामला है, हम कहते हैं, कि यह अंत थे, 361 00:27:46,060 --> 00:27:53,140 तो फिर शुरू होगा, + शुरू अंत / 2 यह होगा, 362 00:27:53,140 --> 00:28:00,580 + शुरू अंत - हाँ, मुझे लगता है कि यह अनंत recursion में समाप्त कर सकते हैं. 363 00:28:00,580 --> 00:28:12,690 चलो का कहना है कि यह सिर्फ आकार 2 या 1 आकार की एक सरणी के एक सरणी है. मुझे लगता है कि यह काम करेगा. 364 00:28:12,690 --> 00:28:19,490 तो वर्तमान में, शुरुआत है कि तत्व और अंत 1 से परे है. 365 00:28:19,490 --> 00:28:24,110 तो तत्व है कि हम की जाँच करने के लिए जा रहे हैं यह एक है, 366 00:28:24,110 --> 00:28:29,400 और फिर जब हम शुरू अद्यतन, हम शुरू अपडेट कर रहे हैं 0 + 1/2 हो सकता है, 367 00:28:29,400 --> 00:28:33,160 जो हमें वापस शुरू किया जा रहा है इस तत्व के साथ खत्म हो रहा है. 368 00:28:33,160 --> 00:28:36,210 >> इसलिए हम पर और फिर से एक ही तत्व की जाँच कर रहे हैं. 369 00:28:36,210 --> 00:28:43,310 तो इस मामले में जहां हर पुनरावर्ती फोन वास्तव में कुछ अद्यतन करना चाहिए. 370 00:28:43,310 --> 00:28:48,370 तो हम शुरू + / अंत 2 + 1 और, या करने की जरूरत है, वहाँ एक मामला है 371 00:28:48,370 --> 00:28:50,710 हम वास्तव में, जहां शुरू नहीं अपडेट कर रहे हैं. 372 00:28:50,710 --> 00:28:53,820 हर कोई है कि देख रहे हो? 373 00:28:53,820 --> 00:28:56,310 ठीक है. 374 00:28:56,310 --> 00:29:03,860 क्या किसी को इस समाधान या किसी भी अधिक टिप्पणी पर सवाल है? 375 00:29:05,220 --> 00:29:10,280 ठीक है. किसी को भी एक समाधान है कि हम सब पर देख सकते हैं चलने का है? 376 00:29:17,400 --> 00:29:20,940 क्या हम सब यह recursively कर? 377 00:29:20,940 --> 00:29:25,950 या फिर भी मुझे लगता है कि अगर आप उसकी खोला, तो आप अधिरोहित अपने पिछले एक हो सकता है. 378 00:29:25,950 --> 00:29:28,810 क्या यह स्वचालित रूप से बचाने के लिए? मैं सकारात्मक नहीं हूँ. 379 00:29:35,090 --> 00:29:39,130 क्या किसी को चलने का है? 380 00:29:39,130 --> 00:29:42,430 हम इसे माध्यम से एक साथ चलना अगर नहीं कर सकते हैं. 381 00:29:46,080 --> 00:29:48,100 विचार करने के लिए एक ही होने जा रहा है. 382 00:30:00,260 --> 00:30:02,830 समाधान चलने का. 383 00:30:02,830 --> 00:30:07,140 हम करने के लिए मूल रूप से एक ही विचार करना चाहते हैं के लिए जा रहे हैं 384 00:30:07,140 --> 00:30:16,530 जहां हम सरणी की नई अंत का ट्रैक रखने और सरणी की नई शुरुआत करना चाहते हैं 385 00:30:16,530 --> 00:30:18,510 और क्या है कि और अधिक से अधिक. 386 00:30:18,510 --> 00:30:22,430 और क्या हम कभी एक दूसरे को काटना शुरू और अंत के रूप में ट्रैक के रख रहे हैं अगर, 387 00:30:22,430 --> 00:30:29,020 तो हम यह नहीं मिल रहा था और हम झूठी वापसी कर सकते हैं. 388 00:30:29,020 --> 00:30:37,540 तो मुझे लगता है कि कैसे करते हो? कोई भी सुझाव या मेरे लिए कोड को रोकना है? 389 00:30:42,190 --> 00:30:47,450 [छात्र] एक समय पाश करो. >> हाँ. 390 00:30:47,450 --> 00:30:49,450 आप करने के लिए एक पाश करना चाहते हैं के लिए जा रहे हैं. 391 00:30:49,450 --> 00:30:51,830 >> तुमने कोड है मैं खींच सकता है, या आप क्या करने के लिए सुझाव लिए जा रहे थे? 392 00:30:51,830 --> 00:30:56,340 [छात्र] मुझे ऐसा लगता है. >> सभी सही. यह चीजों को आसान बनाता है. तुम्हारा नाम क्या था? 393 00:30:56,340 --> 00:30:57,890 [छात्र] लुकास. 394 00:31:00,140 --> 00:31:04,190 1 संशोधन. ठीक है. 395 00:31:04,190 --> 00:31:13,200 कम है कि हम क्या से पहले शुरू करने के लिए बुलाया. 396 00:31:13,200 --> 00:31:17,080 नहीं है काफी क्या हम अंत से पहले कहा जाता है. 397 00:31:17,080 --> 00:31:22,750 दरअसल, अंत सरणी के भीतर अब है. यह एक तत्व हम पर विचार करना चाहिए. 398 00:31:22,750 --> 00:31:26,890 तो कम 0 है, सरणी के आकार - 1, 399 00:31:26,890 --> 00:31:34,780 और अब हम पाशन कर रहे हैं, और हम जाँच कर रहे हैं - 400 00:31:34,780 --> 00:31:37,340 मुझे लगता है कि आप इसे माध्यम से चल सकता है. 401 00:31:37,340 --> 00:31:41,420 अपनी सोच को क्या इस के माध्यम से किया गया था? हमें अपने कोड के माध्यम से चलो. 402 00:31:41,420 --> 00:31:49,940 [छात्र] ज़रूर. बीच में टेबल मूल्य को देखो और यह सुई तुलना करने के लिए. 403 00:31:49,940 --> 00:31:58,520 ओह, वास्तव में, कि पीछे की ओर होना चाहिए - तो अगर यह अपने सुई से अधिक है, तो आप के लिए चाहते हैं. 404 00:31:58,520 --> 00:32:05,180 आप दूर करने के लिए सही आधा फेंक देना चाहते हैं के लिए जा रहे हैं, और तो हाँ, कि जिस तरह से होना चाहिए. 405 00:32:05,180 --> 00:32:08,830 [Bowden] तो यह कम होना चाहिए? यह है कि आप ने क्या कहा? >> [छात्र] हाँ. 406 00:32:08,830 --> 00:32:10,390 [Bowden] ठीक है. कम. 407 00:32:10,390 --> 00:32:15,700 यदि ऐसा है तो क्या हम देख रहे हैं कि हम क्या चाहते हैं की तुलना में छोटी है, 408 00:32:15,700 --> 00:32:19,410 तो हाँ, हम दूर बाईं आधा फेंक करना चाहते हैं, 409 00:32:19,410 --> 00:32:22,210 जिसका मतलब है कि हम सब कुछ हम पर विचार कर रहे हैं अद्यतन कर रहे हैं 410 00:32:22,210 --> 00:32:26,610 सरणी के सही करने के लिए कम हिल द्वारा. 411 00:32:26,610 --> 00:32:30,130 यह अच्छा लग रहा है. 412 00:32:30,130 --> 00:32:34,550 मुझे लगता है कि यह एक ही मुद्दा है कि हम पिछले एक पर कहा है, 413 00:32:34,550 --> 00:32:49,760 जहां अगर 0 कम है और ऊपर 1 है, तो कम + ऊपर 2 / स्थापित करने के लिए फिर से वही बात हो जा रहा है. 414 00:32:49,760 --> 00:32:53,860 >> और यहां तक ​​कि अगर यह मामला नहीं है, यह अभी भी बहुत कम से कम और अधिक कुशल है 415 00:32:53,860 --> 00:32:57,630 बस चले तत्व फेंक हम सिर्फ देखा, जिस पर हम जानते हैं कि वह गलत है. 416 00:32:57,630 --> 00:33:03,240 इतनी कम + 1/2 + - >> [छात्र] कि अन्य तरीका होना चाहिए. 417 00:33:03,240 --> 00:33:05,900 [Bowden] या यह होना चाहिए - 1 और अन्य एक 1 + होना चाहिए. 418 00:33:05,900 --> 00:33:09,580 [छात्र] और वहाँ एक डबल होना चाहिए संकेत के बराबर होती है. >> [Bowden] हाँ. 419 00:33:09,580 --> 00:33:11,340 [छात्र] हाँ. 420 00:33:14,540 --> 00:33:15,910 ठीक है. 421 00:33:15,910 --> 00:33:21,280 और अंत में, अब है कि हम इस + 1 - 1 बात, 422 00:33:21,280 --> 00:33:31,520 यह है - यह नहीं हो सकता है - यह कभी संभव है कम करने के लिए एक की तुलना में अधिक मूल्य के साथ समाप्त करने के लिए? 423 00:33:35,710 --> 00:33:40,320 मुझे लगता है कि एक ही तरीका है कि हो सकता है - क्या यह संभव है? >> [छात्र] मुझे नहीं मालूम. 424 00:33:40,320 --> 00:33:45,220 लेकिन अगर इसे छोटा कर दिया जाता है और फिर शून्य से हो जाता है कि 1 और फिर - >> हाँ. 425 00:33:45,220 --> 00:33:47,480 [छात्र] संभवतः यह गड़बड़ हो जाएगी. 426 00:33:49,700 --> 00:33:53,940 मुझे लगता है कि यह अच्छा ही है क्योंकि होना चाहिए 427 00:33:53,940 --> 00:33:58,800 के लिए इसे खत्म करने के लिए कम वे के बराबर होगा, मुझे लगता है. 428 00:33:58,800 --> 00:34:03,070 लेकिन अगर वे समान हैं, तो हम समय के साथ शुरू करने के पाश नहीं किया जाएगा 429 00:34:03,070 --> 00:34:06,670 और हम सिर्फ मान होता है. तो मुझे लगता है कि हम अच्छा कर रहे हैं अब. 430 00:34:06,670 --> 00:34:11,530 सूचना है कि भले ही यह कोई समस्या नहीं रह गया है पुनरावर्ती, 431 00:34:11,530 --> 00:34:17,400 विचारों का एक ही तरह लागू होते हैं जहां हम देख सकते हैं कि कैसे यह इतनी आसानी से ही बख्शी 432 00:34:17,400 --> 00:34:23,659 तथ्य यह है कि हम सिर्फ और अधिक से अधिक हो इंडेक्स फिर से अद्यतन करने के द्वारा एक पुनरावर्ती समाधान करने के लिए, 433 00:34:23,659 --> 00:34:29,960 हम समस्या छोटे और छोटे कर रहे हैं, हम सरणी के एक सबसेट पर ध्यान केंद्रित कर रहे हैं. 434 00:34:29,960 --> 00:34:40,860 [छात्र] यदि कम 0 है और 1 है, वे दोनों 0 + 1/2, जो 0 से जाना होगा होगा, 435 00:34:40,860 --> 00:34:44,429 और फिर एक 1 + होगा, एक होगा - 1. 436 00:34:47,000 --> 00:34:50,870 [छात्र] हम समानता कहाँ की जाँच कर रहे हैं? 437 00:34:50,870 --> 00:34:55,100 जैसे अगर बीच एक सुई वास्तव में है? 438 00:34:55,100 --> 00:34:58,590 वर्तमान में हम यह नहीं कर रहे हैं? ओह! 439 00:35:00,610 --> 00:35:02,460 It's अगर - 440 00:35:05,340 --> 00:35:13,740 हां. हम सिर्फ यहाँ नीचे परीक्षण करना क्योंकि पहले बीच का कहना है - 441 00:35:13,740 --> 00:35:16,430 [छात्र] यह बाध्य दूर फेंक नहीं वास्तव में पसंद है. 442 00:35:16,430 --> 00:35:20,220 तो अगर आप दूर फेंक के लिए बाध्य करने के लिए, आप के लिए यह पहली या जो भी जाँच करने के लिए किया है. 443 00:35:20,220 --> 00:35:23,350 आह. हाँ. >> [छात्र] हाँ. 444 00:35:23,350 --> 00:35:29,650 तो अब हम एक हम वर्तमान में देखा फेंक दिया है, 445 00:35:29,650 --> 00:35:33,260 जिसका मतलब है कि हम अब भी है की जरूरत है 446 00:35:33,260 --> 00:35:44,810 अगर (सूखी घास का ढेर [(कम ऊपर +) / 2] == सुई), तो हम सच लौट सकते हैं. 447 00:35:44,810 --> 00:35:52,070 और क्या मैं और या बस अगर रखा, यह सचमुच एक ही बात का मतलब 448 00:35:52,070 --> 00:35:57,110 क्योंकि यह सच लौटा होता है. 449 00:35:57,110 --> 00:36:01,450 तो मैं किसी और डाल अगर हूँ, लेकिन यह बात नहीं है. 450 00:36:01,450 --> 00:36:10,440 >> तो और, यह नहीं है, और यह एक आम बात है, मुझे क्या करना है अगर 451 00:36:10,440 --> 00:36:14,340 जहां भी अगर यह मामला है, जहां सब कुछ यहाँ अच्छा है, 452 00:36:14,340 --> 00:36:22,780 की तरह कम ऊपर से अधिक कभी नहीं हो सकता है, यह है कि क्या सच है मूल्य के बारे में तर्क नहीं है. 453 00:36:22,780 --> 00:36:28,010 तो आप के रूप में अच्छी तरह से है, जबकि कम से कम या बराबर है कह सकते हैं 454 00:36:28,010 --> 00:36:30,720 या, जबकि कम से कम है 455 00:36:30,720 --> 00:36:35,300 यदि ऐसा है तो वे कभी बराबर या कम कर रहे हैं पारित करने के लिए होता है, 456 00:36:35,300 --> 00:36:40,130 तो हम इस लूप के बाहर तोड़ सकते हैं. 457 00:36:41,410 --> 00:36:44,630 प्रश्न, चिंताओं, टिप्पणी? 458 00:36:47,080 --> 00:36:49,270 ठीक है. यह अच्छा लग रहा है. 459 00:36:49,270 --> 00:36:52,230 अब हम तरह करना चाहते हैं. 460 00:36:52,230 --> 00:37:04,030 अगर हम अपने 2 संशोधन करने के लिए जाना है, हम इन एक ही नंबर देखते हैं, 461 00:37:04,030 --> 00:37:07,550 लेकिन अब वे क्रमबद्ध क्रम में नहीं रह रहे हैं. 462 00:37:07,550 --> 00:37:12,840 और हम तरह लागू n लॉग एन हे में किसी भी एल्गोरिथ्म का उपयोग करना चाहते हैं. 463 00:37:12,840 --> 00:37:17,240 जो एल्गोरिथ्म तो आपको लगता है कि हम यहाँ लागू करना चाहिए? >> [छात्र] मर्ज तरह. 464 00:37:17,240 --> 00:37:23,810 [Bowden] हाँ. मर्ज प्रकार हे (n लॉग एन) है, इसलिए है कि हम क्या करने जा रहे हैं. 465 00:37:23,810 --> 00:37:26,680 और समस्या के लिए बहुत ही होने जा रहा है, 466 00:37:26,680 --> 00:37:31,920 जहां यह आसानी से अपने आप में एक पुनरावर्ती समाधान करने के लिए उधार देता है. 467 00:37:31,920 --> 00:37:35,580 हम एक समाधान के साथ चलने का भी ऊपर आ सकते हैं अगर हम चाहते हैं, 468 00:37:35,580 --> 00:37:42,540 लेकिन recursion यहाँ आसान हो सकता है और हम recursion करना चाहिए. 469 00:37:45,120 --> 00:37:49,530 मुझे लगता है कि हम मर्ज प्रकार के माध्यम से 1 चलना होगा, 470 00:37:49,530 --> 00:37:54,280 हालांकि वहाँ मर्ज प्रकार पर एक सुंदर वीडियो पहले से ही है. [हँसी] 471 00:37:54,280 --> 00:37:59,780 तो मर्ज तरह वहाँ रहे हैं - मैं इस कागज का इतना बर्बाद कर रहा हूँ. 472 00:37:59,780 --> 00:38:02,080 ओह, वहाँ केवल एक ही छोड़ दिया है. 473 00:38:02,080 --> 00:38:03,630 तो विलय. 474 00:38:08,190 --> 00:38:12,470 ओह, 1, 3, 5. 475 00:38:26,090 --> 00:38:27,440 ठीक है. 476 00:38:29,910 --> 00:38:33,460 मर्ज दो अलग arrays लेता है. 477 00:38:33,460 --> 00:38:36,780 व्यक्तिगत रूप से उन दो सरणियों दोनों क्रमबद्ध हैं. 478 00:38:36,780 --> 00:38:40,970 तो इस सरणी, 1, 3, 5, हल. इस सरणी, 0, 2, 4, हल. 479 00:38:40,970 --> 00:38:46,710 अब मर्ज करना चाहिए कि क्या उन्हें एक सरणी है कि खुद को क्रमबद्ध में गठबंधन है. 480 00:38:46,710 --> 00:38:57,130 तो हम 6 आकार की एक सरणी है कि यह के अंदर किया जा रहा है इन तत्वों चाहते हैं 481 00:38:57,130 --> 00:38:59,390 क्रमबद्ध क्रम में. 482 00:38:59,390 --> 00:39:03,390 >> और इसलिए हम तथ्य यह है कि इन दो सरणियों हल कर रहे हैं का लाभ ले सकते 483 00:39:03,390 --> 00:39:06,800 रैखिक समय में ऐसा करते हैं, 484 00:39:06,800 --> 00:39:13,510 रैखिक समय अर्थ है अगर इस सरणी आकार x है और इस आकार y है, 485 00:39:13,510 --> 00:39:20,970 तो कुल एल्गोरिथ्म हे (एक्स, वाई +) होना चाहिए. ठीक है. 486 00:39:20,970 --> 00:39:23,150 सुझाव तो. 487 00:39:23,150 --> 00:39:26,030 [छात्र] हम बाएँ से शुरू कर सकते हैं? 488 00:39:26,030 --> 00:39:30,150 तो आप नीचे पहली और फिर 1 0 डाल दिया और फिर यहाँ आप 2 पर हैं. 489 00:39:30,150 --> 00:39:33,320 तो यह है जैसे आप एक टैब है कि सही करने के लिए बढ़ रहा है की तरह है. >> [Bowden] हाँ. 490 00:39:33,320 --> 00:39:41,070 इन दोनों arrays के लिए अगर हम सिर्फ leftmost तत्व पर ध्यान केंद्रित है. 491 00:39:41,070 --> 00:39:43,530 क्योंकि दोनों arrays को हल कर रहे हैं, हम जानते हैं कि इन 2 तत्वों 492 00:39:43,530 --> 00:39:46,920 या तो सरणी में छोटी तत्व हैं. 493 00:39:46,920 --> 00:39:53,500 तो इसका मतलब है कि 1 उन 2 तत्वों के हमारे विलय सरणी में छोटी तत्व होना चाहिए. 494 00:39:53,500 --> 00:39:58,190 यह सिर्फ इतना होता है कि छोटी से छोटी सही इस समय पर एक है. 495 00:39:58,190 --> 00:40:02,580 तो हम 0 ले, यह बाईं तरफ डालने क्योंकि 0 1 कम से कम है, 496 00:40:02,580 --> 00:40:08,210 इतना 0 ले, यह हमारी पहली स्थिति में डालने के लिए, और फिर हम इस अद्यतन 497 00:40:08,210 --> 00:40:12,070 अब पहली तत्व पर ध्यान केंद्रित है. 498 00:40:12,070 --> 00:40:14,570 और अब हम दोहराएँ. 499 00:40:14,570 --> 00:40:20,670 तो अब हम 2 की तुलना करने के लिए और 1. 1 छोटा है, तो हम 1 डालने देंगे. 500 00:40:20,670 --> 00:40:25,300 हम यह सूचक को अद्यतन करने के लिए इस आदमी को इंगित. 501 00:40:25,300 --> 00:40:33,160 अब हम इसे फिर से ऐसा करते हैं, 2. यह अद्यतन करने के लिए, 2 इन 3, तुलना करेंगे. 502 00:40:33,160 --> 00:40:37,770 इस अद्यतन, तो 4 और 5. 503 00:40:37,770 --> 00:40:42,110 तो यह है कि मर्ज है. 504 00:40:42,110 --> 00:40:49,010 >> यह बहुत स्पष्ट होना चाहिए कि यह रैखिक समय है क्योंकि हम सिर्फ एक बार प्रत्येक तत्व भर जाना. 505 00:40:49,010 --> 00:40:55,980 और लागू करने मर्ज तरह इस कर रही है कि सबसे बड़ा कदम है. 506 00:40:55,980 --> 00:40:59,330 और यह है कि मुश्किल नहीं है. 507 00:40:59,330 --> 00:41:15,020 एक जोड़ी चीजों के बारे में चिंता करने की ज़रूरत है, हम कहते हैं कि हम 1, 2, 3, 4, 5, 6 विलय कर रहे थे. 508 00:41:15,020 --> 00:41:30,930 इस मामले में हम परिदृश्य में जहां यह एक छोटे होने जा रहा है में खत्म होता है, 509 00:41:30,930 --> 00:41:36,160 तो हम इस सूचक को अद्यतन करने के लिए, यह एक के लिए छोटे होने जा रहा है, इस अद्यतन, 510 00:41:36,160 --> 00:41:41,280 यह एक छोटी है, और अब आप को पहचानने 511 00:41:41,280 --> 00:41:44,220 जब आप वास्तव में तत्वों की है बाहर चलाने के लिए के साथ तुलना. 512 00:41:44,220 --> 00:41:49,400 चूंकि हम पहले से ही इस पूरे सरणी इस्तेमाल किया है, 513 00:41:49,400 --> 00:41:55,190 अब इस सरणी में सब कुछ है बस यहाँ में डाला है. 514 00:41:55,190 --> 00:42:02,040 तो अगर हम कभी भी इस मुद्दे पर जहां हमारे arrays में से एक पूरी तरह से पहले से ही मिला दिया गया है में चलाते हैं, 515 00:42:02,040 --> 00:42:06,510 तो हम सिर्फ अन्य सरणी के सभी तत्वों को लेने और उन्हें सरणी के अंत में डालें. 516 00:42:06,510 --> 00:42:13,630 तो हम सिर्फ 4 सम्मिलित करते हैं, कर सकते हैं 5, 6. ठीक है. 517 00:42:13,630 --> 00:42:18,070 वह एक बात को देखने के लिए बाहर है. 518 00:42:22,080 --> 00:42:26,120 लागू कि 1 कदम होना चाहिए. 519 00:42:26,120 --> 00:42:32,600 तब सॉर्ट मर्ज उस पर आधारित है, यह 2 कदम, 2 मूर्खतापूर्ण कदम है. 520 00:42:38,800 --> 00:42:42,090 चलो बस इस सरणी दे. 521 00:42:57,920 --> 00:43:05,680 तो प्रकार का मर्ज करने के लिए, चरण 1 recursively हिस्सों में सरणी को तोड़ने के लिए है. 522 00:43:05,680 --> 00:43:09,350 तो हिस्सों में विभाजित इस सरणी. 523 00:43:09,350 --> 00:43:22,920 अब हम 4, 15, 16, 50, और 8, 23, 42, 108 है. 524 00:43:22,920 --> 00:43:25,800 और अब हम इसे फिर से करते हैं और हम halves में इन विभाजित. 525 00:43:25,800 --> 00:43:27,530 मैं इसे इस तरफ बिल्कुल वैसा ही करूँगा. 526 00:43:27,530 --> 00:43:34,790 15 4, और 16 तो, 50. 527 00:43:34,790 --> 00:43:37,440 हम यहाँ पर एक ही बात करेंगे. 528 00:43:37,440 --> 00:43:40,340 और अब हम हिस्सों में इसे फिर से विभाजित. 529 00:43:40,340 --> 00:43:51,080 और हम 4, 15, 16, 50 है. 530 00:43:51,080 --> 00:43:53,170 तो यह है कि हमारे आधार मामला है. 531 00:43:53,170 --> 00:44:00,540 एक बार arrays 1 आकार के हैं, तो हम हिस्सों में बंटवारे के साथ बंद. 532 00:44:00,540 --> 00:44:03,190 >> अब हम क्या इस के साथ क्या करते हो? 533 00:44:03,190 --> 00:44:15,730 हम अंत में यह भी 8, 23, 42, और 108 में टूट जाएगा. 534 00:44:15,730 --> 00:44:24,000 तो अब है कि हम इस बिंदु पर कर रहे हैं, अब कदम मर्ज तरह की दो सूचियों में जोड़े विलय. 535 00:44:24,000 --> 00:44:27,610 इसलिए हम इन मर्ज करना चाहते हैं. हम सिर्फ मर्ज कहते हैं. 536 00:44:27,610 --> 00:44:31,410 हम जानते हैं कि मर्ज क्रमबद्ध क्रम में इन वापस आ जाएगी. 537 00:44:31,410 --> 00:44:33,920 4, 15. 538 00:44:33,920 --> 00:44:41,440 अब हम इन मर्ज करना चाहते हैं, और उस क्रमबद्ध क्रम में उन लोगों के साथ एक सूची प्रदान करेगा, 539 00:44:41,440 --> 00:44:44,160 16, 50. 540 00:44:44,160 --> 00:44:57,380 हम उन विलय - 8, 23 और 42, 108 - मैं नहीं लिख सकते हैं. 541 00:44:57,380 --> 00:45:02,890 तो हम मर्ज किए गए जोड़े एक बार किया है. 542 00:45:02,890 --> 00:45:05,140 अब हम सिर्फ फिर से विलय. 543 00:45:05,140 --> 00:45:10,130 अपने आप में सूचना है कि इन सूचियों में से प्रत्येक सॉर्ट किया जाता है, 544 00:45:10,130 --> 00:45:15,220 और फिर हम सिर्फ इन सूचियों विलय 4 आकार की एक सूची है जो क्रमबद्ध प्राप्त कर सकते हैं 545 00:45:15,220 --> 00:45:19,990 और इन दो सूचियों का विलय करने के लिए 4 आकार की एक सूची है कि हल है. 546 00:45:19,990 --> 00:45:25,710 और अंत में, हम 4 आकार के उन दो सूचियों में विलय करने के लिए 8 आकार की एक सूची है कि हल है प्राप्त कर सकते हैं. 547 00:45:25,710 --> 00:45:34,030 तो देखने के लिए कि इस समग्र n लॉग एन है, हम पहले से ही देखा है कि मर्ज रैखिक है, 548 00:45:34,030 --> 00:45:40,390 इसलिए हम इन विलय के साथ जब काम कर रहे हैं, तो मर्ज की कुल लागत की तरह, 549 00:45:40,390 --> 00:45:43,410 क्योंकि इन दो सूचियों के लिए सिर्फ 2 - 550 00:45:43,410 --> 00:45:49,610 या अच्छी तरह से, यह पता हे, लेकिन यहाँ n सिर्फ इन 2 तत्वों, तो यह 2 है. 551 00:45:49,610 --> 00:45:52,850 और इन 2 2 हो सकता है और इन 2 2 हो जाएगा और इन 2 2 हो जाएगा, 552 00:45:52,850 --> 00:45:58,820 तो विलीन हो जाती है कि हम ऐसा करने की जरूरत के सभी भर में, हम अंत में पता कर रही है. 553 00:45:58,820 --> 00:46:03,210 2 + 2 + 2 + 2 8 की तरह है, जो n है, 554 00:46:03,210 --> 00:46:08,060 तो इस सेट में विलय की लागत n है. 555 00:46:08,060 --> 00:46:10,810 और फिर यहाँ भी वही बात है. 556 00:46:10,810 --> 00:46:16,980 हम इन 2 मर्ज करने के लिए, तो इन 2, और व्यक्तिगत रूप से इस मर्ज चार आपरेशन ले जाएगा, 557 00:46:16,980 --> 00:46:23,610 इस मर्ज चार आपरेशनों ले, लेकिन एक बार फिर इन सब के बीच, 558 00:46:23,610 --> 00:46:29,030 हम अंत में विलय n कुल बातें, और इसलिए इस कदम लेता है. 559 00:46:29,030 --> 00:46:33,670 और इसलिए प्रत्येक स्तर n तत्वों विलय कर दिया जा रहा है लेता है. 560 00:46:33,670 --> 00:46:36,110 >> और कितने स्तरों वहाँ रहे हैं? 561 00:46:36,110 --> 00:46:40,160 हर स्तर पर, हमारे सरणी आकार 2 से बढ़ता है. 562 00:46:40,160 --> 00:46:44,590 यहाँ हमारे arrays 1 आकार के होते हैं, वे यहाँ 2 आकार की हैं, वे यहाँ 4 आकार के कर रहे हैं, 563 00:46:44,590 --> 00:46:46,470 और अंत में, वे 8 आकार के हैं. 564 00:46:46,470 --> 00:46:56,450 इतने के बाद से दोगुनी है, वहाँ के लिए लॉग n इन स्तरों के एक कुल को होने जा रहे हैं. 565 00:46:56,450 --> 00:47:02,090 तो लॉग n स्तर, प्रत्येक व्यक्ति के स्तर ले n कुल आपरेशनों के साथ, 566 00:47:02,090 --> 00:47:05,720 हम एक n लॉग एन एल्गोरिथ्म मिलता है. 567 00:47:05,720 --> 00:47:07,790 प्रश्न? 568 00:47:08,940 --> 00:47:13,320 लोगों को पहले से ही यह कैसे लागू करने पर प्रगति की है? 569 00:47:13,320 --> 00:47:18,260 एक राज्य में पहले से ही किसी को भी, जहां मैं सिर्फ अपने कोड खींच सकते हैं? 570 00:47:20,320 --> 00:47:22,260 मैं एक मिनट दे सकते हैं. 571 00:47:24,770 --> 00:47:27,470 यह एक करने के लिए लंबे समय तक होने जा रहा है. 572 00:47:27,470 --> 00:47:28,730 मैं अत्यधिक पुनरावृत्ति की सिफारिश - 573 00:47:28,730 --> 00:47:30,510 आप मर्ज के लिए recursion नहीं करना है 574 00:47:30,510 --> 00:47:33,750 क्योंकि मर्ज के लिए recursion करने के लिए, आप करने के लिए विभिन्न आकारों की एक गुच्छा के पास जा रहे हैं. 575 00:47:33,750 --> 00:47:37,150 तुम्हें पता है, लेकिन यह कष्टप्रद है. 576 00:47:37,150 --> 00:47:43,720 लेकिन recursion ही प्रकार के लिए बहुत आसान है. 577 00:47:43,720 --> 00:47:49,190 तुम बस सचमुच तरह बाईं आधे पर कॉल, सही पर आधा तरह. ठीक है. 578 00:47:51,770 --> 00:47:54,860 किसी को भी कुछ भी मैं अभी तक खींच सकता है? 579 00:47:54,860 --> 00:47:57,540 वरना मैं एक मिनट दे दूँगा. 580 00:47:58,210 --> 00:47:59,900 ठीक है. 581 00:47:59,900 --> 00:48:02,970 किसी को कुछ हम साथ काम कर सकते है? 582 00:48:05,450 --> 00:48:09,680 वरना हम सिर्फ इस के साथ काम करेंगे और फिर वहाँ से विस्तार. 583 00:48:09,680 --> 00:48:14,050 >> किसी को भी इस से अधिक है कि मैं ऊपर खींचने के लिए कर सकते हैं? 584 00:48:14,050 --> 00:48:17,770 [छात्र] हाँ. आप मेरा खींच सकते हैं. >> सभी सही. 585 00:48:17,770 --> 00:48:19,730 हाँ! 586 00:48:22,170 --> 00:48:25,280 [छात्र] स्थितियों की एक बहुत थे. >> ओह, गोली मार. आप कर सकते हैं - 587 00:48:25,280 --> 00:48:28,110 [छात्र] मैं इसे बचाने के लिए है. >> हाँ. 588 00:48:32,420 --> 00:48:35,730 तो हम मर्ज अलग नहीं किया. 589 00:48:35,730 --> 00:48:38,570 ओह, लेकिन यह इतना बुरा नहीं है. 590 00:48:39,790 --> 00:48:41,650 ठीक है. 591 00:48:41,650 --> 00:48:47,080 तो तरह ही सिर्फ mergeSortHelp बुला. 592 00:48:47,080 --> 00:48:49,530 हमें समझाने mergeSortHelp क्या करता है. 593 00:48:49,530 --> 00:48:55,700 [छात्र] MergeSortHelp बहुत ज्यादा दो मुख्य चरण करता है, 594 00:48:55,700 --> 00:49:01,270 जो सरणी के प्रत्येक आधा तरह और फिर उन दोनों के मर्ज है. 595 00:49:04,960 --> 00:49:08,050 [Bowden] ठीक है, तो मुझे एक दूसरी दे. 596 00:49:10,850 --> 00:49:13,210 मुझे लगता है कि इस - >> [छात्र] मैं करने की जरूरत - 597 00:49:17,100 --> 00:49:19,400 हाँ. मैं कुछ याद आ रही है. 598 00:49:19,400 --> 00:49:23,100 मर्ज में, मुझे पता है कि मैं एक नई सरणी बनाने की जरूरत है 599 00:49:23,100 --> 00:49:26,530 क्योंकि मैं यह जगह में नहीं कर सका. हाँ. >> तुम नहीं कर सकते हैं. सुधारें. 600 00:49:26,530 --> 00:49:28,170 [छात्र] तो मैं एक नई सरणी बनाने. 601 00:49:28,170 --> 00:49:31,510 मैं फिर से बदलने के लिए मर्ज अंत में भूल गया था. 602 00:49:31,510 --> 00:49:34,490 ठीक है. हम एक नई सरणी की जरूरत है. 603 00:49:34,490 --> 00:49:41,000 मर्ज सॉर्ट में, यह लगभग हमेशा सच. 604 00:49:41,000 --> 00:49:44,340 एक बेहतर समय के लिहाज से एल्गोरिथ्म की लागत का एक हिस्सा 605 00:49:44,340 --> 00:49:47,310 लगभग हमेशा के लिए थोड़ा और अधिक स्मृति का उपयोग करने की आवश्यकता होगी. 606 00:49:47,310 --> 00:49:51,570 यहाँ तो, कोई फर्क नहीं पड़ता कि तुम कैसे करते छंटाई संविलय 607 00:49:51,570 --> 00:49:54,780 आप अनिवार्य रूप से कुछ अतिरिक्त स्मृति का उपयोग करने की आवश्यकता होगी. 608 00:49:54,780 --> 00:49:58,240 वह या वह एक नई सरणी बनाया. 609 00:49:58,240 --> 00:50:03,400 और फिर आप कहते हैं कि अंत में हम सिर्फ मूल सरणी में नई सरणी को कॉपी करने की जरूरत है. 610 00:50:03,400 --> 00:50:04,830 [छात्र] मुझे ऐसा लगता है, हाँ. 611 00:50:04,830 --> 00:50:08,210 मैं अगर कि संदर्भ या जो कुछ भी द्वारा गिनती करने के मामले में यह काम करता है पता नहीं है - 612 00:50:08,210 --> 00:50:11,650 हाँ, यह काम करेगा. >> [छात्र] ठीक है. 613 00:50:20,620 --> 00:50:24,480 क्या आप इस चलाने की कोशिश? >> [छात्र] नहीं, अभी नहीं. ठीक है. >> 614 00:50:24,480 --> 00:50:28,880 इसे चलाने का प्रयास करें, और उसके बाद मैं इसके बारे में एक पल के लिए बात करेंगे. 615 00:50:28,880 --> 00:50:35,200 [छात्र] मैं सभी समारोह प्रोटोटाइप और सब कुछ करने की जरूरत है, हालांकि सही? 616 00:50:37,640 --> 00:50:40,840 समारोह प्रोटोटाइप. हाँ - ओह, आप की तरह मतलब है. 617 00:50:40,840 --> 00:50:43,040 क्रमबद्ध करें mergeSortHelp बुला रही है. 618 00:50:43,040 --> 00:50:47,390 >> इतने में आदेश के लिए तरह mergeSortHelp कॉल करने के लिए, mergeSortHelp या तो है चाहिए परिभाषित किया गया है 619 00:50:47,390 --> 00:50:56,370 तरह से पहले या हम सिर्फ प्रोटोटाइप की जरूरत है. बस कॉपी और पेस्ट करें कि. 620 00:50:56,370 --> 00:50:59,490 और इसी प्रकार, mergeSortHelp मर्ज के लिए बुला रहा है, 621 00:50:59,490 --> 00:51:03,830 लेकिन मर्ज अभी तक परिभाषित नहीं किया गया है, तो हम सिर्फ दो mergeSortHelp पता है 622 00:51:03,830 --> 00:51:08,700 कि है कि क्या मर्ज करते की तरह लग रहा है, और वह है कि. 623 00:51:09,950 --> 00:51:15,730 MergeSortHelp तो. 624 00:51:22,770 --> 00:51:32,660 हम यहाँ एक मुद्दा है, जहां हम कोई आधार मामला है. 625 00:51:32,660 --> 00:51:38,110 MergeSortHelp पुनरावर्ती है, इसलिए किसी भी पुनरावर्ती समारोह 626 00:51:38,110 --> 00:51:42,610 आधार मामले के कुछ प्रकार की जरूरत को पता है जब recursively ही बुला रोकने के लिए जा रहा है. 627 00:51:42,610 --> 00:51:45,590 हमारे आधार मामला क्या हो रहा है यहाँ हो? हाँ. 628 00:51:45,590 --> 00:51:49,110 [छात्र] यदि आकार 1 है? >> [Bowden] हाँ. 629 00:51:49,110 --> 00:51:56,220 तो जैसे हम सही वहाँ देखा, हम बंटवारे arrays बंद कर दिया 630 00:51:56,220 --> 00:52:01,850 एक बार हम 1 आकार, जो अनिवार्य रूप से खुद को हल कर रहे हैं के arrays में मिला. 631 00:52:01,850 --> 00:52:09,530 तो अगर आकार 1 के बराबर होती है, हम जानते हैं कि सरणी क्रमबद्ध पहले से ही है, 632 00:52:09,530 --> 00:52:12,970 तो हम सिर्फ लौट सकते हैं. 633 00:52:12,970 --> 00:52:16,880 >> सूचना है कि शून्य है, तो हम विशेष रूप से कुछ भी वापस नहीं करते हैं, हम सिर्फ वापस. 634 00:52:16,880 --> 00:52:19,580 ठीक है. इसलिए कि हमारे आधार मामला है. 635 00:52:19,580 --> 00:52:27,440 मुझे लगता है कि हमारे आधार के मामले में भी अगर हम 0 आकार की एक सरणी विलय होता है हो सकता है, 636 00:52:27,440 --> 00:52:30,030 हम शायद कुछ बिंदु पर रोक चाहते हैं, 637 00:52:30,030 --> 00:52:33,610 इसलिए हम अभी कम से कम 2 या कम से कम या 1 के बराबर आकार कह सकते हैं 638 00:52:33,610 --> 00:52:37,150 इतना है कि यह किसी भी श्रृंखला के लिए काम करेंगे. 639 00:52:37,150 --> 00:52:38,870 ठीक है. 640 00:52:38,870 --> 00:52:42,740 इसलिए कि हमारे आधार मामला है. 641 00:52:42,740 --> 00:52:45,950 अब आप हमें मर्ज के माध्यम से चलना चाहते हो? 642 00:52:45,950 --> 00:52:49,140 इन सभी मामलों का क्या मतलब है? 643 00:52:49,140 --> 00:52:54,480 यहाँ तक, हम सिर्फ एक ही विचार कर रहे हैं, 644 00:52:56,970 --> 00:53:02,470 [छात्र] मैं सभी mergeSortHelp कॉल के साथ आकार पारित हो की जरूरत है. 645 00:53:02,470 --> 00:53:10,080 मैं एक अतिरिक्त प्राथमिक आकार के रूप में जोड़ा गया है और यह वहाँ / 2 आकार की तरह नहीं है. 646 00:53:10,080 --> 00:53:16,210 [Bowden] ओह, 2 / आकार, आकार / 2. >> [छात्र] हाँ, और भी ऊपर समारोह में के रूप में अच्छी तरह से. 647 00:53:16,210 --> 00:53:21,320 [Bowden] यहाँ? >> [छात्र] आकार बस. >> [Bowden] ओह. आकार, आकार? >> [छात्र] हाँ. 648 00:53:21,320 --> 00:53:23,010 [Bowden] ठीक है. 649 00:53:23,010 --> 00:53:26,580 मुझे एक पल के लिए लगता है. 650 00:53:26,580 --> 00:53:28,780 क्या हम एक मुद्दे में चलाने? 651 00:53:28,780 --> 00:53:33,690 हम हमेशा 0 के रूप में कर रहे हैं बाईं इलाज. >> [छात्र] नहीं 652 00:53:33,690 --> 00:53:36,340 यह भी गलत है. माफ़ कीजिए. यह शुरू होना चाहिए. हाँ. 653 00:53:36,340 --> 00:53:39,230 [Bowden] ठीक है. मुझे लगता है कि बेहतर पसंद है. 654 00:53:39,230 --> 00:53:43,880 और अंत. ठीक है. 655 00:53:43,880 --> 00:53:47,200 तो अब तुम हमें मर्ज के माध्यम से चलना चाहते हो? >> [छात्र] ठीक है. 656 00:53:47,200 --> 00:53:52,150 मैं सिर्फ इस नई सरणी के माध्यम से चल रहा हूँ कि मैंने बनाया है. 657 00:53:52,150 --> 00:53:57,420 इसका आकार सरणी के हिस्से के आकार है कि हम हल किया जा रहा है 658 00:53:57,420 --> 00:54:03,460 और तत्व है कि मैं नई सरणी कदम में रखा जाना चाहिए खोजने की कोशिश कर रहा है. 659 00:54:03,460 --> 00:54:10,140 तो क्या है कि, पहले मैं अगर सरणी के बाईं आधा किसी भी अधिक तत्वों की जाँच कर रहा हूँ, 660 00:54:10,140 --> 00:54:14,260 और अगर ऐसा नहीं है, तो आप है कि किसी और शर्त है, जो सिर्फ कहते हैं, नीचे जाने के 661 00:54:14,260 --> 00:54:20,180 ठीक है, यह सही सरणी में हो सकता है, और चाहिए हम newArray की वर्तमान सूचकांक में डाल देता हूँ कि. 662 00:54:20,180 --> 00:54:27,620 >> और तो अन्यथा, मैं अगर सरणी के दाईं ओर भी समाप्त हो गया है की जाँच कर रहा हूँ, 663 00:54:27,620 --> 00:54:30,630 जो मामले में मैं सिर्फ बाईं में डाल दिया. 664 00:54:30,630 --> 00:54:34,180 यह वास्तव में आवश्यक नहीं हो सकता. मैं ठीक से नहीं कह सकता. 665 00:54:34,180 --> 00:54:40,970 लेकिन वैसे भी, अन्य दो चेक जिनमें से दो को छोड़ दिया है या सही में छोटे होते हैं. 666 00:54:40,970 --> 00:54:49,770 और प्रत्येक मामले में भी, मैं incrementing रहा हूँ जो भी प्लेसहोल्डर मैं वेतन वृद्धि. 667 00:54:49,770 --> 00:54:52,040 [Bowden] ठीक है. 668 00:54:52,040 --> 00:54:53,840 यह अच्छा लग रहा है. 669 00:54:53,840 --> 00:54:58,800 क्या किसी को टिप्पणी या चिंताओं या प्रश्नों है? 670 00:55:00,660 --> 00:55:07,720 या यह पाँच की तरह लग रहा है - चार मामलों में है कि हम बस में चीजों को लाने के लिए है तो 671 00:55:07,720 --> 00:55:13,100 लेकिन हम विचार करना है कि क्या छोड़ दिया सरणी बातें हम विलय की आवश्यकता के बाहर चला गया है, 672 00:55:13,100 --> 00:55:16,390 क्या सही सरणी बातें हम विलय की आवश्यकता के बाहर चला गया है - 673 00:55:16,390 --> 00:55:18,400 मैं कुछ भी नहीं है पर इशारा कर रहा हूँ. 674 00:55:18,400 --> 00:55:21,730 तो बम्माँ सरणी बातें बाहर चला गया है या सही सरणी बातें बाहर चला गया है. 675 00:55:21,730 --> 00:55:24,320 उन दो मामलों हैं. 676 00:55:24,320 --> 00:55:30,920 हम भी क्या छोड़ दिया बात की कम से कम सही बात है तुच्छ मामले की जरूरत है. 677 00:55:30,920 --> 00:55:33,910 तो हम करने के लिए छोड़ दिया बात का चयन करना चाहते हैं. 678 00:55:33,910 --> 00:55:37,630 उन मामलों रहे हैं. 679 00:55:37,630 --> 00:55:40,990 तो यह सही था तो, वह है कि. 680 00:55:40,990 --> 00:55:46,760 ऐरे छोड़ दिया है. यह 1, 2, 3. ठीक है. तो हाँ, उन चार बातें हम करना चाहते हो सकता हैं. 681 00:55:50,350 --> 00:55:54,510 और हम एक चलने का समाधान से अधिक नहीं जाना होगा. 682 00:55:54,510 --> 00:55:55,980 मैं सुझा नहीं होगा - 683 00:55:55,980 --> 00:56:03,070 मर्ज तरह के एक समारोह में कहा कि दोनों पूंछ पुनरावर्ती नहीं है का एक उदाहरण है, 684 00:56:03,070 --> 00:56:07,040 यह आसान नहीं है यह पूंछ पुनरावर्ती बनाना नहीं है, 685 00:56:07,040 --> 00:56:13,450 लेकिन यह भी बहुत आसान बनाने के लिए यह चलने का नहीं है. 686 00:56:13,450 --> 00:56:16,910 यह बहुत आसान है. 687 00:56:16,910 --> 00:56:19,170 मर्ज की तरह के इस कार्यान्वयन, 688 00:56:19,170 --> 00:56:22,140 मर्ज करने के लिए, कोई फर्क नहीं पड़ता कि तुम क्या करते हो, आप मर्ज का निर्माण करने के लिए जा रहे हैं. 689 00:56:22,140 --> 00:56:29,170 >> तो मर्ज मर्ज के शीर्ष पर बनाया तरह बारी बारी से सिर्फ इन तीन लाइनों. 690 00:56:29,170 --> 00:56:34,700 Iteratively, यह अधिक कष्टप्रद और अधिक कठिन करने के बारे में सोचना है. 691 00:56:34,700 --> 00:56:41,860 नोटिस लेकिन कि यह mergeSortHelp के बाद से पुनरावर्ती पूंछ नहीं है - जब वह खुद कहता है - 692 00:56:41,860 --> 00:56:46,590 यह अभी भी इस पुनरावर्ती कॉल रिटर्न के बाद काम करने की जरूरत है. 693 00:56:46,590 --> 00:56:50,830 तो इस ढेर फ्रेम करने के लिए इस फोन करने के बाद भी मौजूद जारी रहना चाहिए. 694 00:56:50,830 --> 00:56:54,170 और फिर जब आप यह कहते हैं, ढेर फ्रेम करने के लिए मौजूद जारी रहना चाहिए 695 00:56:54,170 --> 00:56:57,780 क्योंकि कि फोन करने के बाद भी, हम अभी भी विलय की आवश्यकता है. 696 00:56:57,780 --> 00:57:01,920 और यह nontrivial इस पूंछ पुनरावर्ती. 697 00:57:04,070 --> 00:57:06,270 प्रश्न? 698 00:57:08,300 --> 00:57:09,860 सही सभी. 699 00:57:09,860 --> 00:57:13,400 तो वापस जाने के लिए तरह - ओह, वहाँ दो चीजें मैं दिखाना चाहते है. ठीक है. 700 00:57:13,400 --> 00:57:17,840 तरह करने के लिए वापस जा रहे हैं, हम इस जल्दी करना होगा. 701 00:57:17,840 --> 00:57:21,030 या खोज. तरह? क्रमबद्ध करें. हाँ. 702 00:57:21,030 --> 00:57:22,730 सॉर्ट के शुरुआत करने के लिए वापस जा रहे हैं. 703 00:57:22,730 --> 00:57:29,870 हम है कि एक प्रकार सरणी एल्गोरिथ्म किसी भी एल्गोरिथ्म का उपयोग करना चाहते हैं 704 00:57:29,870 --> 00:57:33,660 n हे. 705 00:57:33,660 --> 00:57:40,860 तो यह कैसे संभव है? क्या किसी को किसी भी प्रकार है - 706 00:57:40,860 --> 00:57:44,300 मैं पर पहले संकेत दिया था - 707 00:57:44,300 --> 00:57:48,300 अगर हम के बारे में n लॉग एन से पता हे सुधार करने के लिए कर रहे हैं, 708 00:57:48,300 --> 00:57:51,450 हम हमारे एल्गोरिथ्म समय के लिहाज से सुधार हुआ है, 709 00:57:51,450 --> 00:57:55,250 जिसका मतलब है कि हम क्या करने के लिए उस के लिए बनाने की जरूरत करने जा रहे हैं? 710 00:57:55,250 --> 00:57:59,520 [स्पेस] छात्र. >> हाँ. हम और अधिक स्थान का उपयोग करने के लिए होने जा रहे हैं. 711 00:57:59,520 --> 00:58:04,490 और भी अधिक स्थान नहीं बस, यह तेजी से और अधिक स्थान है. 712 00:58:04,490 --> 00:58:14,320 तो मुझे लगता है कि इस प्रकार से एल्गोरिथ्म के छद्म कुछ छद्म polynom 713 00:58:14,320 --> 00:58:18,980 छद्म - मैं याद नहीं कर सकते. छद्म कुछ. 714 00:58:18,980 --> 00:58:22,210 लेकिन यह इसलिए है क्योंकि हम इतना अंतरिक्ष का उपयोग करने की जरूरत है 715 00:58:22,210 --> 00:58:28,610 कि यह प्राप्त लेकिन यथार्थवादी नहीं है. 716 00:58:28,610 --> 00:58:31,220 >> और कैसे हम इस लक्ष्य को हासिल करते हैं? 717 00:58:31,220 --> 00:58:36,810 हम इस लक्ष्य को हासिल कर सकते हैं अगर हम गारंटी कर सकते हैं कि सरणी में किसी विशेष तत्व 718 00:58:36,810 --> 00:58:39,600 एक निश्चित आकार से नीचे है. 719 00:58:42,070 --> 00:58:44,500 इसलिए चलो बस का कहना है कि आकार 200 है, 720 00:58:44,500 --> 00:58:48,130 एक सरणी में किसी भी तत्व 200 आकार से नीचे है. 721 00:58:48,130 --> 00:58:51,080 और यह वास्तव में बहुत यथार्थवादी है. 722 00:58:51,080 --> 00:58:58,660 तुम बहुत आसानी से एक सरणी है कि आप यह सब कुछ पता कर सकते हैं 723 00:58:58,660 --> 00:59:00,570 कुछ संख्या की तुलना में कम हो रहा है. 724 00:59:00,570 --> 00:59:07,400 जैसे कि अगर आप कुछ बिल्कुल भारी वेक्टर या कुछ है 725 00:59:07,400 --> 00:59:11,810 लेकिन आप जानते हैं कि सब कुछ करने के लिए 0 और 5 के बीच होने जा रहा है, 726 00:59:11,810 --> 00:59:14,790 तो यह काफी तेजी से यह करने के लिए होने जा रहा है. 727 00:59:14,790 --> 00:59:17,930 और तत्वों में से किसी पर बाध्य 5 है, 728 00:59:17,930 --> 00:59:21,980 तो इस बाध्य है, वह यह है कि आप कितना स्मृति का उपयोग करने के लिए होने जा रहे हैं. 729 00:59:21,980 --> 00:59:26,300 तो बाध्य 200 है. 730 00:59:26,300 --> 00:59:32,960 सिद्धांत रूप में वहाँ हमेशा एक ही है के बाद से केवल एक पूर्णांक 4 अरब तक हो सकता है, 731 00:59:32,960 --> 00:59:40,600 लेकिन यह है कि फिर हम अंतरिक्ष का उपयोग किया था के बाद से अवास्तविक है 732 00:59:40,600 --> 00:59:44,400 4 अरब के आदेश पर. तो यह है कि अवास्तविक है. 733 00:59:44,400 --> 00:59:47,060 लेकिन यहाँ हम हमारे बाध्य कहूँगा 200 है. 734 00:59:47,060 --> 00:59:59,570 n हे में कर चाल है कि हम एक और आकार की गिनती ही बुलाया सरणी बनाने. 735 00:59:59,570 --> 01:00:10,470 तो वास्तव में, इस के लिए एक सरल तरीका है - मैं वास्तव में अगर बजना यह नहीं पता नहीं है. 736 01:00:11,150 --> 01:00:15,330 लेकिन बहुत कम से कम जीसीसी में - मैं संभालने बजना यह भी है - 737 01:00:15,330 --> 01:00:18,180 यह सिर्फ पूरे सरणी को प्रारंभ करने के लिए 0s हो जाएगा. 738 01:00:18,180 --> 01:00:25,320 तो अगर मैं ऐसा नहीं करना चाहती, तो मैं अलग के लिए कर सकता है (int i = 0; 739 01:00:25,320 --> 01:00:31,500 मैं <बाध्य, मैं + +) मायने रखता है और मैं [] = 0; 740 01:00:31,500 --> 01:00:35,260 तो अब सब कुछ 0 से प्रारंभ है. 741 01:00:35,260 --> 01:00:39,570 मैं अपने सरणी पर पुनरावृति, 742 01:00:39,570 --> 01:00:51,920 और मैं क्या कर रहा हूँ मैं प्रत्येक की संख्या की गिनती कर रहा हूँ - चलो यहाँ नीचे जाना. 743 01:00:51,920 --> 01:00:55,480 हम में से 4, 15, 16, 50, 8, 23, 42, 108 है. 744 01:00:55,480 --> 01:01:00,010 मैं भरोसा कर रहा हूँ क्या उन तत्वों में से प्रत्येक की घटनाओं की संख्या है. 745 01:01:00,010 --> 01:01:03,470 चलो वास्तव में यहाँ कुछ और अधिक कुछ दोहराता है साथ जोड़. 746 01:01:03,470 --> 01:01:11,070 मूल्य तो हम यहाँ है, कि के मूल्य सरणी [i] जा रहा है. 747 01:01:11,070 --> 01:01:14,850 तो वैल 4 या 8 या जो कुछ भी हो सकता है. 748 01:01:14,850 --> 01:01:18,870 और अब मैं भरोसा कर रहा हूँ कि मूल्य के कितने मैंने देखा है, 749 01:01:18,870 --> 01:01:21,230 इतना मायने रखता है [वैल] + +; 750 01:01:21,230 --> 01:01:29,430 इस के बाद किया जाता है, की गिनती के लिए 0001 की तरह कुछ लग रहा है. 751 01:01:29,430 --> 01:01:42,190 चलो मायने रखता करना [वैल] - 1 + बाध्य. 752 01:01:42,190 --> 01:01:48,230 >> अब जब कि सिर्फ तथ्य यह है कि हम 0 से शुरू कर रहे हैं के लिए खाते. 753 01:01:48,230 --> 01:01:50,850 तो 200 अगर हमारी सबसे बड़ी संख्या होने जा रहा है, 754 01:01:50,850 --> 01:01:54,720 तो 0 200 201 बातें है. 755 01:01:54,720 --> 01:02:01,540 इतना मायने रखता है, यह 00001 की तरह लग रही है क्योंकि हम एक 4 करने के लिए होगा. 756 01:02:01,540 --> 01:02:10,210 फिर हम 0001 जहां हम गिनती के 8 सूचकांक में 1 एक होगा होगा. 757 01:02:10,210 --> 01:02:14,560 हम गिनती के 23 सूचकांक में 2 होगा. 758 01:02:14,560 --> 01:02:17,630 हम गिनती के 42 सूचकांक में 2 होगा. 759 01:02:17,630 --> 01:02:21,670 तो हम गिनती का उपयोग कर सकते हैं. 760 01:02:34,270 --> 01:02:44,920 तो num_of_item = मायने रखता है [i]. 761 01:02:44,920 --> 01:02:52,540 और इसलिए यदि num_of_item 2 है, इसका मतलब है कि हम संख्या मैं 2 सम्मिलित करना चाहते हैं 762 01:02:52,540 --> 01:02:55,290 हमारे क्रमबद्ध सरणी में. 763 01:02:55,290 --> 01:03:02,000 तो हम कितनी दूर हम सरणी में कर रहे हैं का ट्रैक रखने की जरूरत है. 764 01:03:02,000 --> 01:03:05,470 तो सूचकांक = 0. 765 01:03:05,470 --> 01:03:09,910 ऐरे - मैं सिर्फ यह लिख देंगे. 766 01:03:16,660 --> 01:03:18,020 गणना - 767 01:03:19,990 --> 01:03:28,580 सरणी [सूचकांक + +] = मैं; 768 01:03:28,580 --> 01:03:32,490 यह है कि मैं क्या चाहता हूँ? मुझे लगता है कि मैं क्या चाहता हूँ. 769 01:03:35,100 --> 01:03:38,290 हाँ, यह अच्छा लग रहा है. ठीक है. 770 01:03:38,290 --> 01:03:43,050 तो हर कोई समझ करता है मेरे मायने रखता सरणी के उद्देश्य क्या है? 771 01:03:43,050 --> 01:03:48,140 यह इन नंबरों में से प्रत्येक की घटनाओं की संख्या की गिनती है. 772 01:03:48,140 --> 01:03:51,780 तो मैं जो मायने रखता है सरणी iterating कर रहा हूँ, 773 01:03:51,780 --> 01:03:57,190 और मायने रखता सरणी में ith स्थिति 774 01:03:57,190 --> 01:04:01,930 मैं की संख्या कि मेरी क्रमबद्ध सरणी में दिखाई चाहिए है. 775 01:04:01,930 --> 01:04:06,840 यही कारण है कि 4 की गिनती के लिए एक होने जा रहा है 776 01:04:06,840 --> 01:04:11,840 और 8 की गिनती के लिए एक होने जा रहा है, 23 की गिनती के लिए 2 होने जा रहा है. 777 01:04:11,840 --> 01:04:16,900 तो है कि मैं उनमें से कितने मेरी क्रमबद्ध सरणी में सम्मिलित करना चाहते हैं. 778 01:04:16,900 --> 01:04:19,200 तो मैं सिर्फ इतना है कि. 779 01:04:19,200 --> 01:04:28,960 मैं num_of_item डालने हूँ मैं मेरे क्रमबद्ध सरणी में है. 780 01:04:28,960 --> 01:04:31,670 >> प्रश्न? 781 01:04:32,460 --> 01:04:43,100 तो फिर, यह रैखिक समय है, जब से हम सिर्फ इस पर एक बार पुनरावृति 782 01:04:43,100 --> 01:04:47,470 लेकिन यह भी क्या इस संख्या के लिए होता है में रैखिक है, 783 01:04:47,470 --> 01:04:50,730 और इसलिए यह भारी अपने ही क्या है पर निर्भर करता है. 784 01:04:50,730 --> 01:04:53,290 200 का एक ही साथ, जो कि बुरा नहीं है. 785 01:04:53,290 --> 01:04:58,330 यदि अपने ही 10,000 होने जा रहा है, तो यह है कि एक छोटे से बदतर है, 786 01:04:58,330 --> 01:05:01,360 लेकिन अगर अपने ही करने के लिए 4 अरब हो सकता है, जा रहा है कि पूरी तरह से अवास्तविक है 787 01:05:01,360 --> 01:05:07,720 और इस सरणी के लिए चार अरब आकार, जो अवास्तविक है किया जा रहा है. 788 01:05:07,720 --> 01:05:10,860 तो वह है कि. प्रश्न? 789 01:05:10,860 --> 01:05:13,270 [अश्राव्य छात्र प्रतिक्रिया] ठीक है. >> 790 01:05:13,270 --> 01:05:15,710 मैं एक अन्य बात का एहसास हुआ है जब हम के माध्यम से जा रहे थे. 791 01:05:17,980 --> 01:05:23,720 मुझे लगता है कि समस्या लुकास और शायद हर एक एक हमने देखा था. 792 01:05:23,720 --> 01:05:26,330 मैं पूरी तरह से भूल गया. 793 01:05:26,330 --> 01:05:31,040 केवल एक चीज मैं पर टिप्पणी करना चाहता था यह है कि जब आप इंडेक्स की तरह चीजों के साथ काम कर रहे हैं, 794 01:05:31,040 --> 01:05:38,320 आप यह वास्तव में कभी नहीं देखने के लिए जब आप एक पाश के लिए लिख रहे हैं, 795 01:05:38,320 --> 01:05:41,120 लेकिन तकनीकी रूप से, आप इन सूचकांकों के साथ जब भी काम कर रहे हैं, 796 01:05:41,120 --> 01:05:45,950 आप बहुत ज्यादा हमेशा अहस्ताक्षरित integers के साथ सौदा करना चाहिए. 797 01:05:45,950 --> 01:05:53,850 इसका कारण यह है कि जब आप हस्ताक्षरित integers के साथ काम कर रहे हैं, 798 01:05:53,850 --> 01:05:56,090 इसलिए यदि आप 2 integers पर हस्ताक्षर किए है और आप उन्हें एक साथ जोड़ें 799 01:05:56,090 --> 01:06:00,640 और वे बहुत बड़ा खत्म होता है, तो आप एक नकारात्मक संख्या के साथ खत्म होता है. 800 01:06:00,640 --> 01:06:03,410 तो है कि पूर्णांक अतिप्रवाह क्या है. 801 01:06:03,410 --> 01:06:10,500 >> अगर मैं 2 अरब और 1 अरब जोड़ने के लिए, मैं नकारात्मक 1 अरब के साथ खत्म होता है. 802 01:06:10,500 --> 01:06:15,480 यही कारण है कि कैसे integers कंप्यूटर पर काम करते हैं. 803 01:06:15,480 --> 01:06:17,510 प्रयोग के साथ समस्या तो - 804 01:06:17,510 --> 01:06:23,500 यह ठीक है छोड़कर यदि कम करने के लिए 2 अरब होना होता है और अप करने के लिए 1 अरब होता है, 805 01:06:23,500 --> 01:06:27,120 तो इस के लिए एक अरब नकारात्मक होने जा रहा है और फिर हम को विभाजित करने के लिए जा रहे हैं कि 2 से 806 01:06:27,120 --> 01:06:29,730 और नकारात्मक 500 मिलियन के साथ खत्म होता है. 807 01:06:29,730 --> 01:06:33,760 तो यह केवल एक मुद्दा अगर आप एक सरणी के माध्यम से खोज हो होता है 808 01:06:33,760 --> 01:06:38,070 चीजों के अरबों के. 809 01:06:38,070 --> 01:06:44,050 लेकिन अगर कम + अतिप्रवाह के लिए होता है, तो यह एक समस्या है. 810 01:06:44,050 --> 01:06:47,750 के रूप में जल्द ही के रूप में हम उन्हें अहस्ताक्षरित, तो 2 अरब से अधिक 1 3 अरब डॉलर का है. 811 01:06:47,750 --> 01:06:51,960 3 अरब 2 से विभाजित 1.5 अरब है. 812 01:06:51,960 --> 01:06:55,670 तो जैसे ही वे अहस्ताक्षरित हो, सब कुछ सही है. 813 01:06:55,670 --> 01:06:59,900 और इतना है कि यह भी एक मुद्दा है जब आप loops के लिए लिख रहे हैं, 814 01:06:59,900 --> 01:07:03,940 और वास्तव में, यह शायद यह स्वचालित रूप से करता है. 815 01:07:09,130 --> 01:07:12,330 यह वास्तव में सिर्फ तुम पर चिल्लाना होगा. 816 01:07:12,330 --> 01:07:21,610 तो अगर इस संख्या भी सिर्फ एक पूर्णांक में बड़ा है, लेकिन यह एक अहस्ताक्षरित पूर्णांक में फिट होगा, 817 01:07:21,610 --> 01:07:24,970 यह आप पर चिल्लाना होगा तो, यही कारण है कि आप इस मुद्दे में वास्तव में कभी नहीं चला. 818 01:07:29,150 --> 01:07:34,820 आप देख सकते हैं कि एक सूचकांक नकारात्मक हो सकता है कभी नहीं जा रहा है, 819 01:07:34,820 --> 01:07:39,220 और इसलिए जब आप एक सरणी पर iterating कर रहे हैं, 820 01:07:39,220 --> 01:07:43,970 आप लगभग हमेशा int अहस्ताक्षरित मैं कह सकते हैं, लेकिन आप वास्तव में नहीं है. 821 01:07:43,970 --> 01:07:47,110 बातें करने के लिए बहुत ज्यादा बस के रूप में अच्छी तरह से काम करने के लिए जा रहे हैं. 822 01:07:48,740 --> 01:07:50,090 ठीक है. [फुसफुसाती] समय क्या हुआ है? 823 01:07:50,090 --> 01:07:54,020 आखिरी बात मैं दिखाना चाहता था और मैं सिर्फ यह वास्तव में जल्दी करूँगा. 824 01:07:54,020 --> 01:08:03,190 तुम्हें पता है कि हम तो हम # 5 या कुछ और के रूप में अधिकतम परिभाषित कर सकते हैं परिभाषित किया है? 825 01:08:03,190 --> 01:08:05,940 चलो MAX नहीं है. # 200 के रूप में ही परिभाषित करते हैं. यही कारण है कि हम क्या से पहले किया था. 826 01:08:05,940 --> 01:08:10,380 यह एक निरंतर को परिभाषित करता है, जो सिर्फ नकल की और चिपकाया जा रहा है 827 01:08:10,380 --> 01:08:13,010 जहाँ हम करने के लिए बाध्य लिखने होगा. 828 01:08:13,010 --> 01:08:18,189 >> तो हम वास्तव में # को परिभाषित करता है के साथ और अधिक कर सकते हैं. 829 01:08:18,189 --> 01:08:21,170 हम # कार्यों को परिभाषित कर सकते हैं. 830 01:08:21,170 --> 01:08:23,410 वे वास्तव में कार्य नहीं कर रहे हैं, लेकिन हम उन्हें कार्य कॉल होगा. 831 01:08:23,410 --> 01:08:36,000 एक उदाहरण MAX (एक्स, वाई) की तरह कुछ होगा (: x x 01:08:40,660 तो तुम त्रिगुट ऑपरेटर सिंटैक्स के लिए इस्तेमाल किया जाना चाहिए, 833 01:08:40,660 --> 01:08:49,029 लेकिन एक्स y से कम है? Y लौटें, और लौटने के एक्स. 834 01:08:49,029 --> 01:08:54,390 तो आप देख सकते हैं यह एक अलग समारोह कर सकते हैं, 835 01:08:54,390 --> 01:09:01,399 और समारोह की तरह bool अधिकतम 2 तर्क लेता है हो सकता है, यह वापस. 836 01:09:01,399 --> 01:09:08,340 यह एक सबसे आम लोगों को मैं इस तरह से किया है. हम उन्हें मैक्रोज़ कहते हैं. 837 01:09:08,340 --> 01:09:11,790 यह एक मैक्रो है. 838 01:09:11,790 --> 01:09:15,859 यह सिर्फ इसके लिए वाक्यविन्यास है. 839 01:09:15,859 --> 01:09:18,740 आप एक मैक्रो लिखने के लिए आप जो चाहते हैं कर सकते हैं. 840 01:09:18,740 --> 01:09:22,649 आप अक्सर debugging printfs और सामान के लिए मैक्रोज़ देखते हैं. 841 01:09:22,649 --> 01:09:29,410 तो printf का एक प्रकार है, वहाँ सी में विशेष स्थिरांक तरह लाइन अधोडैस अधोडैस हैं, 842 01:09:29,410 --> 01:09:31,710 2 रेखांकित करता है लाइन अधोडैस, 843 01:09:31,710 --> 01:09:37,550 और वहाँ भी मुझे लगता है कि 2 समारोह को रेखांकित करता है. कि यह हो सकता है. कुछ ऐसा ही. 844 01:09:37,550 --> 01:09:40,880 उन चीजों को समारोह के नाम के साथ प्रतिस्थापित किया जाएगा 845 01:09:40,880 --> 01:09:42,930 या लाइन है कि आप पर कर रहे हैं की संख्या. 846 01:09:42,930 --> 01:09:48,630 अक्सर, आप debugging printfs कि यहाँ नीचे मैं तो बस लिख सकता है लिखने 847 01:09:48,630 --> 01:09:54,260 डिबग और यह लाइन नंबर और समारोह में कहा कि मैं में होने मुद्रित करेगा 848 01:09:54,260 --> 01:09:57,020 कि यह है कि डीबग कथन का सामना करना पड़ा. 849 01:09:57,020 --> 01:09:59,550 और तुम भी अन्य बातों के मुद्रित कर सकते हैं. 850 01:09:59,550 --> 01:10:05,990 तो एक बात आप के लिए बाहर देखना चाहिए है अगर मैं # DOUBLE_MAX को परिभाषित होता है 851 01:10:05,990 --> 01:10:11,380 * 2 * y और 2 की तरह कुछ के रूप में है. 852 01:10:11,380 --> 01:10:14,310 तो जो भी कारण के लिए, आप एक बहुत है कि क्या होता है. 853 01:10:14,310 --> 01:10:16,650 तो यह एक मैक्रो बनाते हैं. 854 01:10:16,650 --> 01:10:18,680 यह वास्तव में टूट गया है. 855 01:10:18,680 --> 01:10:23,050 मैं यह DOUBLE_MAX (3, 6) की तरह कुछ कर रही द्वारा फोन होगा. 856 01:10:23,050 --> 01:10:27,530 तो क्या वापस आ जाना चाहिए? 857 01:10:28,840 --> 01:10:30,580 12 [] छात्र. 858 01:10:30,580 --> 01:10:34,800 हाँ, 12, लौटा किया जाना चाहिए और 12 वापस आ रहा है. 859 01:10:34,800 --> 01:10:43,350 एक्स 3 के लिए बदल दिया जाता है, 6 y के लिए बदल दिया जाता है, और हम 2 * 6, जो 12 है लौटने के. 860 01:10:43,350 --> 01:10:47,710 अब इस बारे में क्या? क्या वापस आ जाना चाहिए? 861 01:10:47,710 --> 01:10:50,330 14 [] छात्र. >> आदर्श रूप में, 14. 862 01:10:50,330 --> 01:10:55,290 मुद्दा यह है कि कैसे हैश काम को परिभाषित करता है, याद है, यह एक शाब्दिक कॉपी और पेस्ट 863 01:10:55,290 --> 01:11:00,160 बहुत ज्यादा सब कुछ है, तो इस के रूप में व्याख्या की जा जा रहा है 864 01:11:00,160 --> 01:11:11,270 3 1 से अधिक 6, 2 1 बार से अधिक 6, 2 3 बार की तुलना में कम है. 865 01:11:11,270 --> 01:11:19,780 >> इस कारण के लिए तो आप लगभग हमेशा कोष्ठक में सब कुछ लपेटो. 866 01:11:22,180 --> 01:11:25,050 किसी भी चर आप लगभग हमेशा कोष्ठक में लपेट. 867 01:11:25,050 --> 01:11:29,570 ऐसे मामलों में जहाँ आप के लिए नहीं है, जैसे मैं जानता हूँ कि मैं यहाँ करने की ज़रूरत नहीं 868 01:11:29,570 --> 01:11:32,110 क्योंकि की तुलना में कम है बहुत ज्यादा हमेशा सिर्फ काम करने के लिए जा रहा है, 869 01:11:32,110 --> 01:11:34,330 हालांकि यह भी सच नहीं हो सकता है. 870 01:11:34,330 --> 01:11:41,870 अगर वहाँ कुछ DOUBLE_MAX (1 == 2) की तरह हास्यास्पद है, 871 01:11:41,870 --> 01:11:49,760 तो यह है कि कम से कम 3 1 के साथ जगह मिल जा रहा है 2 के बराबर होती है के बराबर होती है, 872 01:11:49,760 --> 01:11:53,460 और यदि ऐसा है तो फिर यह 3 1 कम से कम करने के लिए जा रहा है, यह नहीं है कि बराबर 2, 873 01:11:53,460 --> 01:11:55,620 जो नहीं है कि हम क्या चाहते हैं. 874 01:11:55,620 --> 01:12:00,730 इसलिए किसी भी ऑपरेटर पूर्वता समस्याओं को रोकने के क्रम में, 875 01:12:00,730 --> 01:12:02,870 हमेशा कोष्ठक में लपेट. 876 01:12:03,290 --> 01:12:07,700 ठीक है. और वह यह है, 5:30. 877 01:12:08,140 --> 01:12:12,470 यदि आप pset पर किसी भी सवाल है, हमें पता है. 878 01:12:12,470 --> 01:12:18,010 यह मजेदार होना चाहिए, और हैकर संस्करण भी अधिक यथार्थवादी है 879 01:12:18,010 --> 01:12:22,980 पिछले साल के हैकर संस्करण की तुलना में, इसलिए हमें उम्मीद है कि आप में से बहुत इसे करने की कोशिश है. 880 01:12:22,980 --> 01:12:26,460 पिछले साल बहुत भारी था. 881 01:12:28,370 --> 01:12:30,000 >> [CS50.TV]