Talaan ng nilalaman[Tago][Ipakita]
Ang computer science ay tungkol sa pag-unawa sa mga kumplikado ng mga algorithm at istruktura ng data.
Mayroon kang listahan ng mga item na kailangang pagbukud-bukurin, ngunit wala kang oras o mapagkukunan upang gumamit ng mas kumplikadong algorithm ng pag-uuri.
Ang pag-uuri ng insertion ay isa sa pinakasimpleng algorithm ng pag-uuri, ngunit maaari itong maging mabagal para sa malalaking listahan.
Ang madaling pagpapatupad at pag-unawa ay ginawa ang pamamaraang ito na paborito sa mga programmer. Ito ay perpekto para sa maliliit na listahan o kapag kailangan mo ng mabilis na solusyon.
Sa post sa blog na ito, titingnan natin ang pagiging kumplikado ng oras ng pag-uuri ng insertion. Ang algorithm na ito ay ginagamit upang pag-uri-uriin ang mga array, at mayroon itong runtime na O(n2). Nangangahulugan ito na tumataas ang pagiging kumplikado ng oras sa laki ng array.
Gayunpaman, madalas na mas mabilis ang algorithm na ito kaysa sa iba pang mga algorithm ng pag-uuri, gaya ng quicksort.
Tingnan natin kung paano gumagana ang pag-uuri ng insertion!
Ano ang Insertion Sort Algorithm?
Isang elemento sa isang pagkakataon, ang insertion sort ay bumubuo ng isang sortable array, na madalas na tinatawag bilang isang listahan.
Halimbawa, ang pag-uuri ay inilalapat sa mga kumplikadong programa sa computer tulad ng mga compiler, kung saan ang pagkakasunud-sunod ng mga token ay mahalaga sa interpretasyon ng programa.
Paano Gumagana ang Insertion Sort?
Kapag gumamit kami ng insertion sort upang pagbukud-bukurin ang isang array, magsisimula ang algorithm sa paghahanap ng pinakamaliit na item sa listahan at paglalagay nito sa tamang posisyon.
Pagkatapos ay hahanapin nito ang susunod na pinakamaliit na item at ilalagay ito sa tamang posisyon, at iba pa.
Gumagana ang algorithm sa pamamagitan ng pag-loop sa listahan, paghahambing ng bawat item sa nauna rito.
Kung nasa maling pagkakasunud-sunod ang mga item, pinapalitan sila ng algorithm. Pagkatapos ay susuriin nito upang makita kung ang listahan ay pinagsunod-sunod, at kung ito ay, ang algorithm ay nagtatapos.
Sa pagsasagawa, madalas na ipinapatupad ang insertion sort gamit ang ilang linya ng code, na ginagawa itong popular na pagpipilian para sa pag-uuri ng maliliit na array. Gayunpaman, dapat isaalang-alang ang pagiging kumplikado ng oras kapag ginagamit ang algorithm na ito.
Halimbawa:
Narito ang isang halimbawa kung paano gumagana ang insertion sort. Gagamitin namin ang sumusunod na array:
1, 2, 3, 4, 5, 6
Ang algorithm ay nagsisimula sa pamamagitan ng paghahanap ng pinakamaliit na item sa listahan, na 1. Pagkatapos ay ilalagay ito sa tamang posisyon, ang unang posisyon. Pagkatapos ay hahanapin nito ang susunod na pinakamaliit na item, na 2. Ipinapasok ito sa tamang posisyon, na siyang pangalawang posisyon.
Pagkatapos ay hahanapin nito ang susunod na pinakamaliit na item, na 3. Ilalagay ito sa tamang posisyon, na siyang pangatlong posisyon.
Pagkatapos ay hahanapin nito ang susunod na pinakamaliit na item, na 4. Ilalagay ito sa tamang posisyon, na siyang pang-apat na posisyon, at iba pa. Nakaayos na ang listahan!
Makikita natin mula sa halimbawa na ang algorithm ay tumatagal ng anim na paghahambing at pagpapalit upang ayusin ang listahan. Ito ay dahil ito ay tumatagal ng n2 paghahambing at pagpapalit upang pagbukud-bukurin ang isang listahan ng n aytem. Sa kasong ito, n=6.
Paano Pagbutihin ang Pag-uuri ng Insertion Time Complexity?
Habang ang insertion sort ay may runtime na O(n2), maaari itong mapabuti sa pamamagitan ng paggamit ng isang mas mahusay na algorithm ng pag-uuri, tulad ng quicksort.
Ang Quicksort ay may O(n log n) runtime, na mas mabilis kaysa sa O(n2).
Gayunpaman, sa ilang mga kaso, ang pag-uuri ng insertion ay maaaring mas mabilis kaysa sa quicksort.
Halimbawa, kung maayos na ang listahan, mas kaunting oras ang pag-uuri ng pagpapasok kaysa sa quicksort.
Sa pagsasagawa, madalas na ipinapatupad ang insertion sort gamit ang ilang linya ng code, na ginagawa itong popular na pagpipilian para sa pag-uuri ng maliliit na array.
Gayunpaman, dapat isaalang-alang ang pagiging kumplikado ng oras kapag ginagamit ang algorithm na ito.
Mga Komplikadong Oras
Pinakamasamang Kaso kumplikado O(n2):
Ang pagiging kumplikado ng oras ay tumataas sa laki ng array. Ito ay tumatagal ng n2 paghahambing at pagpapalit upang pagbukud-bukurin ang isang listahan ng n aytem.
Halimbawa, kung mayroon kaming hanay ng laki na 1000, ang algorithm ay kukuha ng 1,000,000 paghahambing at pagpapalit upang ayusin ang hanay.
Pinakamahusay na Kaso kumplikado O(n):
Ang pagiging kumplikado ng oras ay pareho sa laki ng input array. ako
t tumatagal ng n paghahambing at pagpapalit upang pagbukud-bukurin ang isang listahan ng n aytem. Halimbawa, isaalang-alang ang isang array ng laki 5. Ang algorithm ay kukuha ng limang paghahambing at pagpapalit upang ayusin ang array.
Average Case Complexity O(n2):
Ang pagiging kumplikado ng oras ay nasa pagitan ng pinakamasama at pinakamahusay na mga kumplikadong kaso sa kasong ito.
Ito ay tumatagal ng n2 paghahambing at pagpapalit upang pagbukud-bukurin ang isang listahan ng n aytem.
Kaya, ang insertion sorting ay isang matatag na algorithm ng pag-uuri.
Bakit Stable ang Insertion Sort?
Ang insertion sort ay stable dahil pinapanatili nito ang pagkakasunud-sunod ng mga pantay na elemento sa input array.
Ito ay mahalaga para sa maraming mga application, tulad ng data retrieval o financial analysis. Halimbawa, kung mayroon kaming dalawang listahan ng mga numero at gusto naming ihambing ang mga ito, kailangan naming tiyakin na ang pagkakasunud-sunod ng mga elemento ay napanatili.
Kung ang mga listahan ay hindi pinagsunod-sunod, hindi namin ihahambing ang mga ito nang tumpak.
Mag-iwan ng Sagot