Pagkakaiba sa pagitan ng Liblib at Iteration
Nilalaman
Ang recursion at pag-iiba ay parehong paulit-ulit na isinasagawa ang hanay ng mga tagubilin. Ang Recursion ay kapag ang isang pahayag sa isang function ay tumatawag sa sarili nang paulit-ulit. Ang pag-iilaw ay kapag ang isang loop na paulit-ulit na isinasagawa hanggang sa hindi pagkontrol ang kondisyon. Ang pangunahing pagkakaiba sa pagitan ng recursion at pag-iiba ay na pag-urong ay isang proseso, palaging inilalapat sa isang function. Ang pag-iiba ay inilalapat sa hanay ng mga tagubilin na nais naming ulitin nang paulit-ulit.
- Tsart ng paghahambing
- Kahulugan
- Pangunahing Pagkakaiba
- Konklusyon
Tsart ng paghahambing
| Batayan Para sa Paghahambing | Libangan | Iteration |
|---|---|---|
| Pangunahing | Ang pahayag sa isang katawan ng pag-andar ay tumatawag sa pag-andar mismo. | Pinapayagan ang hanay ng mga tagubilin na paulit-ulit na naisakatuparan. |
| Format | Sa pag-andar ng recursive, tinukoy lamang ang kondisyon ng pagwawakas (base case). | Ang pagsukat ay nagsasama ng inisasyon, kondisyon, pagpapatupad ng pahayag sa loob ng loop at pag-update (mga pagdaragdag at pagbubuti) ang variable na kontrol. |
| Pagwawakas | Ang isang kondisyon na pahayag ay kasama sa katawan ng pag-andar upang pilitin ang pag-andar na bumalik nang hindi naisakatuparan ang tawag sa recursion. | Ang pahayag ng pag-ulit ay paulit-ulit na isinasagawa hanggang sa maabot ang isang tiyak na kondisyon. |
| Kondisyon | Kung ang pag-andar ay hindi nakikipag-ugnay sa ilang kundisyon na tinatawag na (base case), humahantong ito sa walang hanggan pag-urong. | Kung ang kondisyon ng kontrol sa pahayag ng pag-ulit ay hindi kailanman magiging mali, humahantong ito sa walang hanggan na pag-iiba. |
| Walang-katapusang Pag-uulit | Ang walang-katapusang pag-urong ay maaaring mag-crash sa system. | Ang walang hanggan na loop ay gumagamit ng mga siklo ng CPU nang paulit-ulit. |
| Inilapat | Ang libu-libong ay palaging inilalapat sa mga pag-andar. | Ang heteration ay inilalapat sa mga pahayag ng pag-ulit o "mga loop". |
| Stack | Ang salansan ay ginagamit upang maiimbak ang hanay ng mga bagong lokal na variable at mga parameter sa tuwing tinawag ang pagpapaandar. | Hindi gumagamit ng stack. |
| Overhead | Ang pag-urong ay nagtataglay ng overhead ng paulit-ulit na mga tawag sa pag-andar. | Walang overhead ng paulit-ulit na tawag sa pag-andar. |
| Bilis | Mabagal sa pagpapatupad. | Mabilis sa pagpapatupad. |
| Sukat ng Code | Ang pagbabalik ay binabawasan ang laki ng code. | Ang pagsukat ay ginagawang mas mahaba ang code. |
Kahulugan ng Recursion
Pinapayagan ng C ++ ang isang function na tawagan ang sarili sa loob ng code nito. Nangangahulugan ito ng kahulugan ng pag-andar ay nagtataglay ng isang tawag na function sa sarili nito. Minsan tinatawag din itong "kahulugan ng pabilog". Ang hanay ng mga lokal na variable at mga parameter na ginagamit ng function ay bagong nilikha sa tuwing ang function ay tumatawag sa sarili at naka-imbak sa tuktok ng salansan. Ngunit, sa bawat oras na ang isang pag-andar ay tumatawag sa sarili nito, hindi ito lumilikha ng isang bagong kopya ng pagpapaandar na iyon. Ang pag-andar ng recursive ay hindi makabuluhang bawasan ang sukat ng code at hindi kahit na mapabuti ang paggamit ng memorya, ngunit ginagawa nito ang ilan kung ihahambing sa pag-iiba.
Upang wakasan ang recursion, dapat mong isama ang isang piling pahayag sa kahulugan ng pagpapaandar upang pilitin ang function na bumalik nang hindi binigyan ang isang recursive call sa sarili nito. Ang kawalan ng napiling pahayag sa kahulugan ng isang pag-andar ng recursive ay magbibigay-daan sa pag-andar sa walang hanggan na pag-recursion na tinawag na minsan.
Unawain natin ang pag-urong na may isang function na ibabalik ang factorial ng numero.
int factorial (int num) {int answer; kung (num == 1) {bumalik 1; } iba pa (sagot = factorial (num-1) * num; // recursive calling} bumalik (sagot); }
Sa itaas na code, ang pahayag sa ibang bahagi ay nagpapakita ng recursion, dahil ang pahayag ay tumatawag sa function factorial () kung saan ito nakatira.
Kahulugan ng Iteration
Ang Iteration ay isang proseso ng pagpapatupad ng hanay ng mga tagubilin nang paulit-ulit hanggang sa hindi totoo ang kondisyon sa pahayag ng pag-ulit. Kasama sa pahayag ng pag-iiba ang pagsisimula, paghahambing, pagpapatupad ng mga pahayag sa loob ng pahayag ng pag-iiba at sa wakas ang pag-update ng variable variable. Matapos ma-update ang control variable, ito ay inihambing muli, at ang proseso ay umuulit mismo, hanggang sa mali ang kundisyon sa pahayag ng pag-ulit. Ang mga pahayag ng pag-ulit ay "para sa" loop, "habang" loop, "do-habang" loop.
Ang pahayag ng pag-ulit ay hindi gumagamit ng isang salansan upang maiimbak ang mga variable. Samakatuwid, ang pagpapatupad ng pahayag ng pag-ulit ay mas mabilis kung ihahambing sa pag-andar ng recursive. Kahit na ang pag-andar ng pag-iilaw ay hindi magkaroon ng overhead ng paulit-ulit na pagtawag sa pag-andar na ginagawang mas mabilis din ang pagpapatupad nito kaysa sa recursive function. Ang pag-iilaw ay natapos kapag ang control na kondisyon ay naging maling. Ang kawalan ng kondisyon ng kontrol sa pahayag ng pag-ulit ay maaaring magresulta sa isang walang hanggan na loop, o maaaring magdulot ito ng isang error sa pag-iipon.
Unawain natin ang pag-iiba tungkol sa halimbawa sa itaas.
int factorial (int num) {int answer = 1; // nangangailangan ng pagsisimula dahil maaaring naglalaman ito ng isang halaga ng basura bago ang pagsisimula nito para sa (int t = 1; t> num; t ++) // iteration {answer = answer * (t); bumalik (sagot); }}
Sa itaas na code, ang pag-andar ay nagbabalik sa factorial ng numero gamit ang pahayag ng pag-iiba.
- Ang recursion ay kapag ang isang pamamaraan sa isang programa ay paulit-ulit na tinatawag ang sarili samantalang, ang pag-iiba ay kapag ang isang hanay ng mga tagubilin sa isang programa ay paulit-ulit na naisakatuparan.
- Ang isang paraan ng recursive ay naglalaman ng hanay ng mga tagubilin, pahayag na tumatawag sa sarili nito, at isang kondisyon ng pagwawakas samantalang ang mga pahayag ng pag-iiba ay naglalaman ng pagsisimula, pagdaragdag, kondisyon, hanay ng pagtuturo sa loob ng isang loop at isang variable variable.
- Ang isang kondisyon na pahayag ay nagpapasya sa pagtatapos ng halaga ng recursion at control variable na magpapasya sa pagwawakas ng pahayag sa pag-iiba.
- Kung ang pamamaraan ay hindi humantong sa kondisyon ng pagwawakas ay pumapasok ito sa walang hanggan na pag-urong. Sa kabilang banda, kung ang control variable ay hindi humahantong sa pagwawakas ng halaga ng pahayag ng pag-iiba iterates walang hanggan.
- Ang walang limitasyong pag-urong ay maaaring humantong sa pag-crash ng system samantalang, ang walang hanggan na pag-ubos ay kumokonsumo ng mga siklo ng CPU.
- Ang libu-libong ay palaging inilalapat sa pamamaraan samantalang, ang pag-ihi ay inilalapat sa hanay ng pagtuturo.
- Ang mga variable na nilikha sa panahon ng recursion ay naka-imbak sa stack samantalang, ang pag-iiba ay hindi nangangailangan ng isang stack.
- Ang pag-urong ay nagiging sanhi ng overhead ng paulit-ulit na pagtawag sa pag-andar, samantalang ang pag-iilaw ay walang function na tumatawag sa itaas.
- Dahil sa pag-andar sa pagtawag ng overhead na pagpapatupad ng recursion ay mas mabagal samantalang, ang pagpapatupad ng pag-iiba ay mas mabilis.
- Ang pagbabalik ay binabawasan ang laki ng code samantalang, ang mga iterations ay gumagawa ng isang code na mas mahaba.
Konklusyon:
Ang pag-andar ng recursive ay madaling isulat, ngunit hindi sila gumanap ng maayos kumpara sa pag-iinit, samantalang ang pagsusulit ay mahirap isulat ngunit ang kanilang pagganap ay mabuti kumpara sa recursion.
