>> All right, కాబట్టి, గణన సంక్లిష్టత.
ఒక హెచ్చరిక కేవలం ఒక బిట్ మేము చాలా far-- ఈత కొట్టడానికి ముందు
ఈ బహుశా మధ్య ఉంటాం అత్యంత గణిత-భారీ విషయాలు
మేము CS50 గురించి మాట్లాడటానికి.
ఆశాజనక అది చాలా అధిక వుండదు మరియు మేము ప్రయత్నించండి మరియు మీరు మార్గనిర్దేశం చేస్తాము
ప్రక్రియ ద్వారా, కానీ ఒక సరసమైన హెచ్చరిక కేవలం ఒక బిట్.
కొద్దిగా ఉంది గణిత ఇక్కడ చేరి.
అన్ని కుడి, క్రమంలో చేయడానికి మా గణన వనరులను వాడుకోవడం
నిజమైన world-- అది నిజంగా వార్తలు అల్గోరిథంలు అర్థం ముఖ్యం
మరియు ఎలా వారు డేటా ప్రాసెస్.
మేము కలిగి ఉంటే ఒక నిజంగా సమర్థవంతమైన అల్గోరిథం, మేము
వనరుల మొత్తం తగ్గిస్తుంది మేము అది వ్యవహరించే అందుబాటులో ఉన్నాయి.
మేము ఒక అల్గోరిథం ఉంటే ఆ పని చాలా పడుతుంది అన్నారు
నిజంగా ఒక ప్రాసెస్ డేటా పెద్ద సెట్, అంతే
మరింత అవసరం అన్నారు ఎక్కువ వనరులను, మరియు ఇది
విషయాన్ని డబ్బు, RAM, అన్ని ఆ రకమైన ఉంది.
>> కాబట్టి, సామర్థ్యం ఒక విశ్లేషించడానికి అల్గోరిథం, ఈ సాధనం సమితి ఉపయోగించి
ప్రధానంగా, ప్రశ్న అడుగుతుంది ఈ అల్గోరిథం ఎత్తున ఎలా
మేము అది వద్ద మరింత డేటా త్రో వంటి?
CS50 లో, మేము డేటా మొత్తం ఉన్నాము పని అందంగా చిన్నది.
సాధారణంగా, మా కార్యక్రమాలు వెళ్తున్నారు రెండవ లేదా less-- లో అమలు
బహుశా చాలా తక్కువ ముఖ్యంగా ప్రారంభ న.
>> కానీ ఆ ఒప్పందాలు కంపెనీ గురించి ఆలోచించడం వినియోగదారులు వందల మిలియన్ల.
మరియు వారు ప్రాసెస్ అవసరం ఆ కస్టమర్ డేటా.
వినియోగదారుల సంఖ్య వంటి వారు కలిగి, పెద్ద పెద్ద గెట్స్
అది అవసరం జరగబోతోంది మరింత వనరులు.
ఎన్ని ఎక్కువ వనరులను?
Well, ఎంత ఆధారపడి మేము అల్గోరిథం విశ్లేషించడానికి,
ఈ టూల్ లో టూల్స్ ఉపయోగించి.
మేము సంక్లిష్టత గురించి మాట్లాడేటప్పుడు ఒక అల్గోరిథం ఇది కొన్నిసార్లు మీరు చేస్తాము
ఇది సమయం సూచిస్తారు వినడానికి సంక్లిష్టత లేదా ఖాళీ సంక్లిష్టత
కానీ మేము కేవలం చూడాలని complexity-- కాల్
మేము సాధారణంగా గురించి మాట్లాడటం చేస్తున్నాం చెత్త దృష్టాంత.
సంపూర్ణ చెత్త కుప్ప ఇచ్చిన మేము అది వద్ద విసిరి అని డేటా
ఎలా ఈ అల్గోరిథం అన్నారు ప్రాసెస్ లేదా ఆ డేటా ఎదుర్కోవటానికి?
మేము సాధారణంగా దారుణమైన కాల్ ఒక అల్గోరిథం పెద్ద-O యొక్క రన్టైమ్.
కాబట్టి ఒక అల్గోరిథం కావచ్చు స్క్వేర్డ్ n లేదా n యొక్క O యొక్క O లో అమలు.
గురించి మరియు మరింత ఏమిటి ఆ రెండవ అర్థం.
>> కొన్నిసార్లు, మేము సంరక్షణ ఉత్తమ దృష్టాంత గురించి.
డేటా ప్రతిదీ ఉంటే మనం కోరుకున్న అది ఉండాలి మరియు అది ఖచ్చితంగా పక్కాగా
మరియు మేము ఈ పరిపూర్ణ పంపడం జరిగింది మా అల్గోరిథం ద్వారా డేటా సెట్.
ఇది ఎలా ఆ పరిస్థితిలో నిర్వహిస్తారనే?
మేము కొన్నిసార్లు ఆ చూడండి పెద్ద ఒమేగా, పెద్ద O విరుద్ధంగా కాబట్టి,
మేము పెద్ద ఒమేగా కలిగి.
ఉత్తమ దృష్టాంత కోసం బిగ్ ఒమేగా.
చెత్త దృష్టాంత కోసం బిగ్-O.
సాధారణంగా, మేము గురించి ఉన్నప్పుడు మాట్లాడటానికి ఒక అల్గోరిథం యొక్క సంక్లిష్టత,
మనం మాట్లాడే చెత్త దృష్టాంత.
కాబట్టి గుర్తుంచుకోండి.
>> మరియు ఈ తరగతి లో, మేము సాధారణంగా చూడాలని పక్కన ఖచ్చితమైన విశ్లేషణ విడిచి.
శాస్త్రాలు మరియు ఖాళీలను ఉన్నాయి stuff ఈ రకమైన అంకితం.
మేము తార్కికం గురించి మాట్లాడేటప్పుడు అల్గారిధం ద్వారా,
మేము అనేక ముక్క-ద్వారా-ముక్క చేస్తాను ఇది అల్గోరిథంలు మేము తరగతి లో మాట్లాడండి.
మేము నిజంగా కేవలం గురించి మాట్లాడటం చేస్తున్నాం ఇంగితజ్ఞానం తో ద్వారా రీజనింగ్,
కాదు సూత్రాలు, లేదా నిర్ధారణలతో, లేదా అలాంటిదే ఏదైనా.
కాబట్టి చింతించకండి, మేము వుండదు ఒక పెద్ద గణిత తరగతి పెట్టటము.
>> కాబట్టి మనం సంక్లిష్టత గురించి శ్రద్ధ వహిస్తాను అది ప్రశ్న, ఎలా అడుగుతుంది ఎందుకంటే
మా అల్గోరిథంలు పెద్ద నిర్వహించడానికి లేదు మరియు పెద్ద డేటా సమితుల వాటిని విసిరేవారు.
Well, ఒక డేటా సమితి ఏమిటి?
నేను చెప్పినప్పుడు నేను పదానికి అర్ధమేమి?
ఇది చాలా కలిగించే పనులను అర్థం సందర్భంలో భావం, నిజాయితీగా ఉండటానికి.
మేము ఒక అల్గోరిథం ఉంటే ప్రాసెసెస్ Strings-- మేము బహుశా ఉన్నాము
స్ట్రింగ్ యొక్క పరిమాణం గురించి మాట్లాడటం.
ఆ డేటా వార్తలు సెట్ పరిమాణం, సంఖ్య
స్ట్రింగ్ తయారు చేసే అక్షరాలు.
మేము ఒక గురించి మాట్లాడుతూ ఉంటే ఫైళ్లు ప్రాసెస్ అల్గోరిథం,
మేము ఎలా గురించి మాట్లాడుతూ ఉండవచ్చు అనేక కిలోబైట్లు ఆ ఫైల్ వహిస్తాయి.
మరియు ఆ డేటా సమితి యొక్క.
మేము ఒక అల్గోరిథం గురించి మాట్లాడుతూ ఉంటే ఆ, మరింత సాధారణంగా శ్రేణుల నిర్వహిస్తుంది
ఇటువంటి సార్టింగ్ అల్గోరిథంలు వంటి లేదా అల్గోరిథంలు శోధించడం,
మేము బహుశా సంఖ్య గురించి మాట్లాడటం చేస్తున్నాం వ్యూహం కలిగి అంశాల.
>> ఇప్పుడు, మేము ఒక అంచనా వేయవచ్చు అల్గోరిథం ముఖ్యంగా,
నేను చెప్పినప్పుడు మేము నేను ఒక అల్గోరిథం కొలిచేందుకు
మేము ఎలా అంచనా వేయవచ్చు అర్థం అనేక వనరులు అది తీసుకుంటుంది.
ఆ వనరులను ఉన్నాయి లేదో, ఎన్ని RAM యొక్క బైట్లు లేదా RAM యొక్క మెగాబైట్ల
ఇది ఉపయోగిస్తుంది.
లేదా ఎంత సమయం రన్ పడుతుంది.
మరియు మేము ఈ కాల్ చేయవచ్చు n యొక్క f, ఏకపక్ష, కొలిచేందుకు.
ఎక్కడ n సంఖ్య డేటా సెట్ లో అంశాలు.
మరియు n యొక్క f ఎన్ని somethings ఉంది.
ఎన్ని వనరుల యూనిట్లు చేస్తుంది ఆ డేటా ప్రాసెస్ అవసరం.
>> ఇప్పుడు, మేము నిజంగా పట్టించుకోను సరిగ్గా n యొక్క f ఏమిటి గురించి.
నిజానికి, మేము చాలా అరుదుగా అభీష్టం ఖచ్చితంగా ఎప్పటికీ ఈ తరగతి నేను
ఏ నిజంగా లోతైన ప్రవేశిస్తాడు యొక్క f n అని ఏ విశ్లేషణ.
మేము కేవలం ఏమి f గురించి మాట్లాడటానికి వెళుతున్న n సుమారు లేదా దానిని కలిగి ఉంటుంది.
మరియు ఒక అల్గోరిథం యొక్క ప్రవృత్తి దాని అత్యధిక ఆర్డర్ పదం రాయించుకున్నాడు.
మరియు మేము ఏమి చూడగలరు నేను తీసుకొని ఆ అర్ధం
ఒక మరింత కాంక్రీటు ఉదాహరణ చూడండి.
>> కాబట్టి యొక్క మేము చెబుతాను మూడు వేర్వేరు అల్గోరిథంలు.
వీటిలో మొదటి n పడుతుంది వనరుల ఆరోపించింది, కొన్ని యూనిట్లు
పరిమాణం n యొక్క ఒక డేటా సమితి ప్రాసెస్.
మేము పడుతుంది అని రెండవ అల్గోరిథం కలిగి ఆరోపించింది ప్లస్ స్క్వేర్డ్ n వనరులు n
పరిమాణం n యొక్క ఒక డేటా సమితి ప్రాసెస్.
మరియు మేము ఒక మూడవ ఆ in-- నడుస్తుంది ఆ అల్గోరిథం
తీసుకుంటుంది n cubed మైనస్ 8n స్క్వేర్డ్ వనరుల ప్లస్ 20 N యూనిట్లు
ఒక అల్గోరిథం ప్రాసెస్ n పరిమాణం సెట్ డేటా.
>> ఇప్పుడు మళ్ళీ, మేము నిజంగా వెళ్ళడం లేదు వివరాలు ఈ స్థాయి పొందడానికి.
నేను ఈ అప్ నిజంగా చేస్తున్నాను ఇక్కడ ఒక పాయింట్ యొక్క దృష్టాంతం
నేను వెళుతున్న , రెండవ దానిలో అయింది
మేము మాత్రమే నిజంగా పట్టించుకోను ఉంది విషయాలు ధోరణి గురించి
డేటా సమితుల పెద్ద పొందుటకు గా.
డేటా సెట్ చిన్న చేస్తే, అక్కడ నిజానికి ఒక అందమైన పెద్ద తేడా
ఈ అల్గోరిథంలు లో.
అక్కడ మూడవ అల్గోరిథం 13 సార్లు ఇక పడుతుంది
వనరుల 13 సార్లు మొత్తం మొదటి ఒకటి సాపేక్ష అమలు.
>> మా డేటా సెట్ పరిమాణం 10, ఉంటే ఇది పెద్ద, కానీ తప్పనిసరిగా భారీ కాదు
మేము అక్కడ ఆ చూడగలరు నిజానికి తేడా యొక్క ఒక బిట్.
మూడవ అల్గోరిథం మరింత సమర్థవంతంగా అవుతుంది.
ఇది నిజానికి 40% గురించి - లేదా 60% ఎక్కువ సమర్థవంతమైన.
ఇది 40% సమయం మొత్తం పడుతుంది.
ఇది తీసుకోవాలని చేయవచ్చు, రన్ చేయవచ్చు వనరుల 400 యూనిట్లు
పరిమాణం 10 యొక్క ఒక డేటా సమితి ప్రాసెస్.
మొదటి అయితే అల్గోరిథం, దీనికి విరుద్ధంగా,
వనరుల 1,000 యూనిట్లు పడుతుంది పరిమాణం 10 యొక్క ఒక డేటా సమితి ప్రాసెస్.
కానీ ఏమి జరుగుతుందో గమనించు మా సంఖ్యలు కూడా పెద్ద పొందండి.
>> ఇప్పుడు, తేడా ఈ అల్గోరిథంలు మధ్య
కొద్దిగా తక్కువ స్పష్టమైన మారింది మొదలు.
ఉన్నాయి మరియు నిజానికి దిగువ ఆర్డర్ పదాలు లేదా,
తక్కువ exponents-- అవగాహనకు అసంబద్ధం మారింది మొదలు.
ఒక డేటా సమితి పరిమాణం యొక్క ఉంటే 1000 మరియు మొదటి అల్గోరిథం
ఒక బిలియన్ దశల్లో నడుస్తుంది.
మరియు రెండవ అల్గోరిథం లో నడుస్తుంది ఒక బిలియన్ మరియు ఒక మిలియన్ దశలను.
మరియు మూడవ అల్గోరిథం నడుస్తుంది ఒక బిలియన్ దశలను కేవలం పిరికి లో.
ఇది చాలా చక్కని ఒక బిలియన్ దశలను ఉంది.
ఆ దిగువ ఆర్డర్ నిబంధనలు మొదలు నిజంగా అసంబద్ధం మారింది.
మరియు కేవలం నిజంగా హోమ్ సుత్తి పాయింట్
డేటా ఇన్పుట్ పరిమాణం ఒక యొక్క ఉంటే million-- వీటిలో మూడు అందంగా చాలా
ఒక quintillion-- ఉంటే పడుతుంది నా గణిత correct-- దశలను ఉంది
ఒక డేటా ఇన్పుట్ ప్రాసెస్ పరిమాణం ఒక మిలియన్.
ఆ దశలను చాలా ఉంది.
నిజానికి వారికి ఒక మైట్ ఒక జంట 100,000, లేదా ఒక జంట పడుతుంది 100
మిలియన్ కూడా తక్కువ ఉన్నప్పుడు మేము అనేక గురించి మాట్లాడటం చేస్తున్నాం
ఆ రకమైన అసంబద్ధం big--.
వారు అన్ని సమయం తీసుకుంటారు సుమారు n cubed,
అందువలన మేము నిజానికి కాలాన్ని ఈ అల్గోరిథంలు యొక్క అన్ని
n యొక్క ఆర్డర్ మీద గా ఆరోపించింది లేదా n cubed పెద్ద O.
>> ఇక్కడ మరింత కొన్ని జాబితా ఉంది సాధారణ గణన సంక్లిష్టత తరగతుల
మేము లో చూస్తారు ఆ అల్గోరిథంలు సాధారణంగా.
మరియు కూడా ప్రత్యేకంగా CS50 లో.
ఈ నుండి ఆదేశాలు సాధారణంగా ఎగువన అతివేగంగా
దిగువన సాధారణంగా నెమ్మదైన స్థాయి వరకు.
కాబట్టి స్థిరంగా సమయం అల్గోరిథంలు ఉంటాయి సంబంధం లేకుండా వేగంగా ఉండాలి,
పరిమాణంతో డేటా ఇన్పుట్ మీరు పాస్.
వారు ఎల్లప్పుడూ ఒక ఆపరేషన్ పడుతుంది లేదా ఎదుర్కోవటానికి వనరుల ఒక యూనిట్.
ఇది 2 కావచ్చు, అది బలం 3, 4 కావచ్చు.
కానీ అది స్థిరమైన నెంబర్.
ఇది మారుతూ లేదు.
>> సంవర్గమాన సమయం అల్గోరిథంలు కాస్త మెరుగని చెప్పవచ్చు.
మరియు ఒక మంచి ఉదాహరణకు ఒక సంవర్గమాన సమయం అల్గోరిథం
మీరు ఇప్పుడు ద్వారా ఖచ్చితంగా చూసిన చేసిన ఫోన్ బుక్ కాకుండా చిరిగిపోవడానికి
ఫోన్ బుక్ లో మైక్ స్మిత్ కనుగొనేందుకు.
మేము సగం సమస్య కట్.
మరియు n పెద్ద గెట్స్ కాబట్టి ఇది పెద్దగా larger--
నిజానికి, ప్రతిసారీ మీరు రెట్టింపు n, ఇది ఒకే ఒక్క మరింత అడుగు పడుతుంది.
ఆ చాలా ఉత్తమం కాబట్టి కంటే, చెప్పటానికి, సరళ సమయం.
మీరు n రెట్టింపు అయితే ఇది ఉంది దశలను సంఖ్య రెట్టింపు పడుతుంది.
మీరు n మూడు రెట్లు ఉంటే, అది పడుతుంది దశలను సంఖ్య మూడు రెట్లు.
యూనిట్కు ఒక అడుగు.
>> అప్పుడు విషయాలు కొద్దిగా more-- పొందండి కొద్దిగా తక్కువ గొప్ప అక్కడ నుండి.
మీరు కొన్నిసార్లు, సరళ లయ సమయం లాగ్ సరళ సమయం అని లేదా కేవలం n లాగ్ n.
మరియు మేము ఒక ఉదాహరణగా చేస్తాము ఒక అల్గోరిథం యొక్క
ఇప్పటికీ ఉత్తమం, n లాగ్ n, పరుగులు కంటే వర్గ time-- n స్క్వేర్డ్.
లేదా బహుపది సమయం, n రెండు రెండు కంటే ఎక్కువ ఎన్ని.
లేదా ఘాతీయ సమయం, ఇది కూడా worse-- సి n ఉంది.
సో కొన్ని స్థిరమైన సంఖ్య ఎదిగింది ఇన్పుట్ పరిమాణం యొక్క శక్తి.
అలా అయితే 1,000-- ఉంది ఉంటే డేటా ఇన్పుట్, పరిమాణం 1,000 ఉంది
ఇది 1,000 వ అధికారంలోకి సి పడుతుందని.
ఇది బహుపది సమయం కంటే చాలా దారుణంగా ఉంది.
>> కారకమైన సమయం చెత్తగా ఉంది.
నిజానికి, నిజంగా అక్కడ అపారమైన సమయం అల్గోరిథంలు ఉనికిలో,
దీని ఇటువంటి అని పిలవబడే, తెలివితక్కువదని విధమైన ఉద్యోగం యాదృచ్ఛికంగా వ్యూహం షఫుల్
ఆపై చూడటానికి తనిఖీ లేదో అది క్రమబద్ధీకరించబడతాయి.
మరియు ఇది యాదృచ్చికంగా కాదు ఉంటే మళ్ళీ శ్రేణి షఫుల్
మరియు అది క్రమబద్ధీకరించబడతాయి లేదో చూడండి.
మరియు మీరు బహుశా imagine-- చేయవచ్చు మీరు ఒక పరిస్థితి ఊహించే
పేరు చెత్త సందర్భంలో, ఆ సంకల్పం నిజానికి శ్రేణి ప్రారంభం ఎప్పుడూ.
ఆ అల్గోరిథం ఎప్పటికీ అమలు.
అందువలన, ఉంటుంది అపారమైన సమయం అల్గోరిథం.
ఆశాజనక మీరు రాయడం కాదు ఏ కారకమైన లేదా అనంతమైన సమయం
CS50 లో అల్గోరిథంలు.
>> కాబట్టి, యొక్క తీసుకుందాం కొంచెం కొన్ని సులభమైన వద్ద కాంక్రీట్ లుక్
గణన సంక్లిష్టత తరగతులు.
కాబట్టి మేము ఒక ఉదాహరణలో కలిగి లేదా రెండు ఉదాహరణలు ఇక్కడ
స్థిరంగా సమయం అల్గోరిథంలు యొక్క, ఇది ఎల్లప్పుడూ పడుతుంది
చెత్త-సందర్భంలో ఒకే ఆపరేషన్.
మొదటి ఉదాహరణలో కాబట్టి మేము ఒక ఫంక్షన్ కలిగి
మీరు కోసం 4 అనే పేరుతో సూచించిన పరిమాణం 1,000 వ్యూహం పడుతుంది.
కానీ అప్పుడు స్పష్టంగా నిజానికి కనిపించడం లేదు
దానిని నిజంగా ఏమిటి పట్టించుకోరు వద్ద , అది లోపలి శ్రేణి యొక్క.
ఎల్లప్పుడూ కేవలం నాలుగు తిరిగి.
కాబట్టి, ఆ అల్గోరిథం, ఇది వాస్తవం ఉన్నప్పటికీ
1,000 అంశాలు లేదు పడుతుంది వారితో ఏదైనా.
జస్ట్ నాలుగు తిరిగి.
ఇది ఎల్లప్పుడూ ఒకే దశలో ఉంది.
>> నిజానికి, 2 nums-- జోడించండి మేము well-- ముందు చూసిన
కేవలం రెండు పూర్ణాంకాల ప్రాసెస్.
ఇది ఒకే దశలో కాదు.
ఇది నిజానికి ఒక జంట దశలను ఉంది.
మీరు ఒక పొందుటకు, మీరు బి పొందుటకు, మీరు వాటిని జోడించండి కలిసి, మరియు మీరు అవుట్పుట్ ఫలితాలు.
కాబట్టి ఇది 84 దశలను ఉంది.
కానీ అది ఎప్పుడూ స్థిరంగా ఉంది సంబంధం లేకుండా లేదా బి యొక్క.
మీరు ఒక తీసుకురావాలి, బి పొందండి జోడించండి కలిసి, వాటిని అవుట్పుట్ ఫలితంగా.
కాబట్టి ఒక స్థిరమైన సమయం అల్గోరిథం యొక్క.
>> ఇక్కడ ఒక యొక్క ఒక ఉదాహరణ వార్తలు సరళ సమయం అల్గోరిథం
ఆ పడుతుంది gets-- ఒక అల్గోరిథం ఒక అదనపు దశను, బహుశా
మీ ఇన్పుట్ 1 వృధ్ధి.
కాబట్టి, యొక్క మేము చూస్తున్న సే తెలియజేయండి వ్యూహం సంఖ్య 5 లోపల.
మీరు ఒక పరిస్థితి కలిగి ఉండవచ్చు మీరు చాలా ప్రారంభ వెదుక్కోవచ్చు.
కానీ మీరు కూడా కాలేదు పరిస్థితి ఇది
శ్రేణి యొక్క చివరి మూలకం కావచ్చు.
పరిమాణం 5 యొక్క వ్యూహం, ఉంటే మేము సంఖ్య 5 చూస్తున్న.
ఇది 5 దశలను పడుతుంది.
నిజానికి, అక్కడ మనకు ఊహించుకోండి ఈ శ్రేణి లో లేదు 5 ఎక్కడైనా.
మేము ఇంకా నిజానికి చూడటానికి కలిగి యెరే యొక్క ప్రతి మూలకం
నిర్ధారించేందుకు లేదో 5 ఉంది.
>> అలా అని ఇది చెత్త సందర్భంలో, మూలకం శ్రేణి చివరి ఉంది
లేదా అన్ని వద్ద ఉనికిలో లేదు.
మేము ఇంకా చూడండి కలిగి n మూలకాలు అన్ని.
అందువలన ఈ అల్గోరిథం సరళ సమయంలో నడుస్తుంది.
మీరు ద్వారా నిర్ధారించండి చేయవచ్చు ఈ విధంగా ఒక చిన్న బిట్ extrapolating,
మేము ఒక 6-మూలకం శ్రేణి కలిగి ఉంటే మేము సంఖ్య 5 వెతుకుతున్న
ఇది 6 దశలను పడుతుంది.
మేము ఒక 7-మూలకం శ్రేణి కలిగి ఉంటే మేము సంఖ్య 5 చూస్తున్న.
ఇది 7 దశలను పడుతుంది.
మేము మరో మూలకం జోడించండి మా శ్రేణి, ఇది ఒక మరింత అడుగు పడుతుంది.
ఒక సరళ అల్గోరిథం యొక్క చెత్త-కేసు.
>> జంట మీరు త్వరగా ప్రశ్నలు.
ఏమిటి runtime-- ఏమిటి runtime కేసు
కోడ్ యొక్క ఈ ప్రత్యేక స్నిప్పెట్?
నేను నడుస్తుంది ఇక్కడ ఒక 4 లూప్ కలిగి j 0, చి అన్ని మార్గం అప్ సమానం నుండి.
మరియు నేను ఏ ఇక్కడ చూసిన వెబ్, అని లూప్ యొక్క శరీరం స్థిరంగా సమయంలో నడుస్తుంది.
కాబట్టి పరిభాష ఉపయోగించి మేము ఇప్పటికే గురించి మాట్లాడారు చేసిన
చెత్త-సందర్భంలో ఉంటుంది ఈ అల్గోరిథం యొక్క రన్టైమ్?
రెండవ తీసుకోండి.
లూప్ యొక్క లోపలి భాగం స్థిరంగా సమయంలో నడుస్తుంది.
మరియు వెలుపలి భాగం లూప్ m సార్లు అమలు కానుంది.
కాబట్టి చెత్త-runtime కేసు ఇక్కడ ఏమి ఉంది?
మీరు M పెద్ద O అంచనా తెలుసా?
మీరు కుడి భావించాలి.
>> ఎలా మరొక గురించి?
మేము ఒక కలిగి ఈ సమయంలో ఒక లూప్ యొక్క లోపల లూప్.
మేము ఒక బాహ్య లూప్ కలిగి సున్నా నుండి పేజి నడుస్తుంది.
మరియు మేము నడుస్తుంది అని ఒక అంతర్గత లూప్ కలిగి సున్నా నుంచి p, మరియు ఆ లోపల
నేను స్టేట్ శరీరం లూప్ స్థిరంగా సమయంలో నడుస్తుంది.
కాబట్టి చెత్త-runtime కేసు ఏమిటి కోడ్ యొక్క ఈ ప్రత్యేక స్నిప్పెట్?
Well, మళ్ళీ, మేము ఒక కలిగి p సార్లు నడుస్తుంది, ఆ బయటి లూప్.
మరియు ప్రతి time-- మళ్ళా ఆ లూప్ యొక్క, బదులుగా.
మేము ఒక అంతర్గత లూప్ కలిగి కూడా p సార్లు నడుస్తుంది.
ఆ లోపలి ఆపై, ఉంది అక్కడ స్థిరంగా time-- చిన్న స్నిప్పెట్.
>> మేము ఒక బాహ్య లూప్ కలిగి ఉంటే కాబట్టి ఆ వీటిలో లోపల p సార్లు నడుస్తుంది
అంతర్గత లూప్ ఆ ఏమి సార్లు పునరావృతం పే నడుస్తుంది
runtime కేసు కోడ్ యొక్క ఈ స్నిప్పెట్?
మీరు p పెద్ద స్క్వేర్డ్ ఓ అంచనా తెలుసా?
>> నేను డౌ లాయిడ్ ఉన్నాను.
ఈ CS50 ఉంది.