Pag-uuri ay isa sa mga pinaka pangunahing at kapaki-pakinabang na pag-andar na inilapat sa data. Nilalayon nito ang pag-aayos ng data sa isang partikular na paraan, na maaaring tumataas o bumababa ayon sa mga kinakailangan. Mayroong builtin na pag-andar sa C ++ STL ng pangalan ng 'pag-uuri ()' na nagbibigay-daan sa amin upang maisagawa nang madali ang pag-uuri ng algorithm. Sa artikulong ito ay susisiyasatin namin ang Sort Function Sa C ++,
Saklaw ang artikulong ito sa artikulong ito:
ano ang pagkakaiba ng git at github
- Pag-uri-uriin () ang pagpapaandar
- Halimbawa- Upang pag-uri-uriin ang data sa pataas na pagkakasunud-sunod
- Halimbawa - Upang pag-uri-uriin ang data sa pababang pagkakasunud-sunod
- Bahagyang_sort
Ang pagpapatuloy sa artikulong ito sa Pag-uuri-uriin ang pag-andar sa C ++
Pagbukud-bukurin ( ) pagpapaandar
Ito ay isang built-in na pag-andar ng file ng header ng algorithm ginagamit ito upang pag-uri-uriin ang mga lalagyan tulad ng isang array, mga vector sa isang tinukoy na pagkakasunud-sunod. Sa panloob ang pagpapaandar na ito ay ipinatupad bilang Quick-sort
Ang Quicksort ay isang paghati at pagsakop sa algorithm. Hinahati muna ng Quicksort ang isang malaking listahan ng mga elemento sa dalawang mas maliit na mga sub-list: ang mas mababang mga elemento at ang mas mataas na mga elemento. Ang Quicksort pagkatapos ay recursively pag-uri-uriin ang mga sub-list.
Ang mga hakbang ay ang mga sumusunod:
1. Pumili ng isang random na elemento (karaniwang ang huling elemento), na tinatawag na isang pivot, mula sa listahan.
2. Muling ayusin ang listahan sa isang paraan tulad ng lahat ng mga elemento na may mga halagang mas mababa kaysa sa pivot ay dumating bago ang pivot, habang ang lahat ng mga elemento na may mga halagang mas malaki kaysa sa pivot ay sundin pagkatapos nito at ang pantay na mga halaga ay maaaring pumunta sa alinmang paraan ito ay ang proseso na tinatawag na operasyon ng pagkahati.
3. Recursively pag-uri-uriin ang sub-list ng mga mas maliit na elemento at ang sub-list ng mas higit na mga elemento, muli pumili ng isang pivot sa sub-list at hatiin ang mga ito.
Ang batayang kaso ng recursion ay mga listahan ng laki ng zero o isa, na hindi kailanman kailangang ayusin at sa gayon sa pamamagitan ng pagsasama sa mga ito ay pinag-uuri namin ang aming listahan.
Ang Quicksort ay mas mabilis sa pagsasanay kaysa sa iba pang mga O (n log n) na mga algorithm tulad ng Insertion Sort o uri ng Bubble. Ang Quicksort ay maaaring ipatupad sa isang in-place na pagkahati algorithm na nangangahulugang ang buong pag-uuri ay maaaring gawin sa pamamagitan lamang ng O (log n) karagdagang puwang. Ang Quicksort ay hindi isang matatag na uri.
Ang pagiging kumplikado nito ay ang mga sumusunod:
Pinakamahusay na Kaso - O (n log n)
Pinakamasamang Kaso - O (n ^ 2)
Karaniwang Kaso - O (n log n)
Syntax:
pag-uri-uriin (una, huling)
Dito,
una - ay ang index (pointer) ng unang elemento sa saklaw na aayos.
huling - ay ang index (pointer) ng huling elemento sa saklaw na aayos.
Halimbawa, nais naming pag-uri-uriin ang mga elemento ng isang array na ‘arr’ mula 1 hanggang 10 na posisyon, gagamitin namin ang pag-uuri (arr, arr + 10) at pag-uuriin nito ang 10 elemento sa pagkakasunud-sunod ng umakyat.
Halaga ng pagbabalik
Wala
Pagiging kumplikado
Ang average ng isang uri ng pagiging kumplikado ay N * log2 (N), kung saan ang N = huling - una.
Sakop ng data
Ang bagay sa saklaw na [una, huling) ay nabago.
Mga pagbubukod
Ang mga labis na karga na may isang parameter ng template na pinangalanan bilang mga error sa ulat ng ExecutionPolicy tulad ng sumusunod:
Kung nabigo ang algorithm na maglaan ng memorya, ang std :: bad_alloc ay itinapon bilang isang pagbubukod.
Kung ang pagpapatupad ng isang pagpapaandar na tinawag bilang bahagi ng algorithm ay nagtatapon ito ng isang eksepsyon std :: wakasan.
Ang pagpapatuloy sa artikulong ito sa Pag-uuri-uriin ang pag-andar sa C ++
Halimbawa - Upang pag-uri-uriin ang data sa pataas na pagkakasunud-sunod:
# isama ang paggamit ng namespace std int main () {int array [] = {10, 35, 85, 93, 62, 77, 345, 43, 2, 10} int n = sizeof (array) / sizeof (array [0] ) // 'sizeof' ay nagbibigay ng laki ng kabuuang array ie laki ng bawat character * hindi. ng mga character // kaya upang makakuha ng hindi. ng mga character // hinahati namin ang sukat ng (array) na may sukat ng anumang isang character ng array // dito ito ay array [0] sort (array, array + n) cout<< 'nArray after sorting using ' 'default sort is : n' for (int i = 0 i < n ++i) cout << array[i] << ' ' return 0 } Output:
Paliwanag
Mula sa halimbawa sa itaas, nakikita namin ang pag-uuri na () pag-andar ng default na pag-uuri ng isang array sa pataas na pagkakasunud-sunod.
Ang pagpapatuloy sa artikulong ito sa Pag-uuri-uriin ang pag-andar sa C ++
Halimbawa - Upang pag-uri-uriin ang data sa pababang pagkakasunud-sunod:
Upang pag-uri-uriin ang data ng array sa pababang pagkakasunud-sunod kailangan naming ipakilala ang isang pangatlong parameter na ginamit upang tukuyin ang pagkakasunud-sunod ng mga elemento na aayos. Maaari naming gamitin ang function na 'mas malaki ()' upang pag-uri-uriin ang data sa pababang pagkakasunud-sunod.
halimbawa ng halimbawang variable sa java
# isama ang paggamit ng namespace std int main () {int array [] = {41, 53, 4, 459, 60, 7, 23, 4, 232, 10} int n = sizeof (array) / sizeof (array [0] ) pag-uri-uriin (array, array + n, mas malaki ()) cout<< 'Array after sorting : n' for (int i = 0 i < n ++i) cout << array[i] << ' ' return 0 } Output:
Exp l isang nasyon
Narito ang pag-uuri () ng pag-andar ay isang paghahambing sa isang paraan na naglalagay ng mas malaking elemento bago.
Ang pagpapatuloy sa artikulong ito sa Pag-uuri-uriin ang pag-andar sa C ++
Bahagyang_sort
Nagbibigay sa amin ang C ++ STL ng isang bahagyang pag-uuri ng pag-uuri, ang pagpapaandar ay katulad ng pag-uuri () na pag-andar ngunit hindi katulad ng pag-uuri () na pagpapaandar na hindi ito ginagamit upang pag-uri-uriin ang buong saklaw sa halip ay ginagamit ito upang pag-uri-uriin lamang ang isang sub-bahagi nito. Pinagsasama-sama nito ang mga elemento sa saklaw ng [una, huling), sa paraang ang mga elemento bago ang gitnang elemento ay pinagsunod-sunod sa pataas na pagkakasunud-sunod, samantalang ang mga elemento pagkatapos ng gitna ay naiwan na tulad nito.
Maaari itong magamit upang mahanap ang pinakamalaking elemento kung gumagamit kami ng isang function na bagay upang pag-uri-uriin para sa unang posisyon
Halimbawa
#include #include #include using namespace std int main () {vector vector = {10, 45, 60, 78, 23, 21, 30} vector :: iterator iptr partial_sort (vec.begin (), vec.begin () + 1, vec.end (), mas malaki ()) iptr = vec.begin () cout<< 'The largest element is = ' << *iptr return 0 } Output:
Paliwanag:
Ang code sa itaas ay maaaring magamit upang makahanap ng pinakamaraming bilang sa isang serye, upang makahanap ng pinakamaliit na numero sa serye kailangan lang nating alisin ang higit na utos.
Sa gayon ay natapos na kami sa artikulong ito sa 'Pag-uri-uriin ang Pag-andar sa C ++'. Kung nais mong matuto nang higit pa, suriin ang Java Training ni Edureka, isang pinagkakatiwalaang kumpanya sa online na pag-aaral. Edureka’s ang kurso ay dinisenyo upang sanayin ka para sa parehong core at advanced na konsepto ng Java kasama ang iba't ibang mga balangkas ng Java tulad ng Hibernate & Spring.
May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng blog na ito at babalikan ka namin sa lalong madaling panahon.