Array (programming)

Index array(sa ilang mga programming language din mesa, hilera) - isang pinangalanang hanay ng mga variable ng parehong uri, na matatagpuan kaagad sa memorya ng isa-isa (kumpara sa isang listahan), na-access ng index.

Index array - isang integer, o isang value ng uri na maaaring i-cast sa isang integer, na tumuturo sa isang partikular na elemento ng array.

Pangkalahatang paglalarawan

Array - Isang nakaayos na hanay ng data, para sa pag-iimbak ng data ng isang uri, na kinilala ng isa o higit pa mga index. Sa pinakasimpleng kaso, ang array ay may pare-parehong haba at nag-iimbak ng mga unit ng data ng parehong uri.

Maaaring mag-iba ang bilang ng mga array index na ginamit. Ang mga array na may isang index ay tinatawag one-dimensional, na may dalawang - dalawang-dimensional atbp. Ang isang one-dimensional na array ay maluwag na tumutugma sa isang vector sa matematika, ang isang two-dimensional array ay hindi mahigpit na tumutugma sa isang matrix. Kadalasan, ang mga array na may isa o dalawang index ay ginagamit, mas madalas - na may tatlo, at higit pang mga index ay napakabihirang.

Halimbawa ng isang static na array sa Pascal -

WordArray: array [ Word ] ng Integer ; // Static, laki = Mataas(Word) + 1 multiArray: array [ Byte , 1 ..5 ] ng Char ; // Static array, 2 dimensyon rangeArray: array [5 ..20] ng String ; // Static array, laki = 16

Halimbawa ng isang static na array sa C -

Int Array[ 10 ] ; // Static, laki 10, base data type - int dobleng Array[ 12 ] [ 15 ] ; // Static array, 2 dimensyon, base data type - numero // na may fractional na bahagi (doble)

Ang suporta para sa mga array ng index (sariling syntax ng deklarasyon nito, mga function para sa pagtatrabaho sa mga elemento, atbp.) ay available sa karamihan ng mga high-level na programming language. Ang maximum na pinahihintulutang laki ng array, mga uri at hanay ng mga halaga ng index, mga paghihigpit sa mga uri ng elemento ay tinutukoy ng programming language at/o isang partikular na tagasalin.

Sa mga programming language na nagpapahintulot sa programmer na magpahayag ng kanyang sariling mga uri, bilang isang panuntunan, posible na lumikha ng isang "array" na uri. Maaaring tukuyin ng kahulugan ng uri na ito ang laki, uri ng elemento, hanay ng halaga, at mga uri ng index. Sa hinaharap, posibleng tukuyin ang mga variable ng nilikhang uri. Ang lahat ng naturang mga variable ng array ay may parehong istraktura. Sinusuportahan ng ilang wika ang mga pagpapatakbo ng pagtatalaga para sa mga variable ng array (kapag ang isang operasyon ay nagtatalaga ng mga halaga ng mga kaukulang elemento ng isa pang array sa lahat ng mga elemento ng isang array).

Ang pagdedeklara ng uri ng "array" sa Pascal -

I-type ang TArrayType = array [0..9] ng Integer; (* Mga deklarasyon ng uri na "array" *) var arr1, arr2, arr3: TArrayType; (* Deklarasyon ng tatlong array variable ng parehong uri *)

Mga Tukoy na Uri ng Array

Mga dynamic na array

Dynamic ay isang array na ang laki ay maaaring magbago sa panahon ng pagpapatupad ng programa. Upang baguhin ang laki ng isang dynamic na array, ang isang programming language na sumusuporta sa mga naturang array ay dapat magbigay ng built-in na function o operator. Nagbibigay ang mga dynamic na array ng pagkakataon para sa mas nababaluktot na trabaho sa data, dahil pinapayagan ka nitong huwag hulaan ang dami ng data na nakaimbak, ngunit upang ayusin ang laki ng array alinsunod sa aktwal na kinakailangang mga volume. Ang mga ordinaryong, hindi dynamic na array ay tinatawag din static.

Halimbawa ng isang dynamic na array sa Delphi

ByteArray: Array ng Byte ; // Isang-dimensional na array multiArray: Array ng Array ng string ; // Multidimensional array

Halimbawa ng isang dynamic na array sa C

Lutang *array1; // Isang-dimensional na array int **array2; // Multidimensional array array1=(float *) malloc (10 *sizeof (float ) ); // maglaan ng 10 bloke ng sizeof(float) bytes bawat isa array2=(int **) malloc (16 *sizeof (int ) ); // paglalaan ng 16*8 na bloke ng sizeof(int) bytes bawat isa para sa (i=0 ;i<16 ;i++) array2[ i] =(int *) malloc (8 *sizeof (int ) ) ;

Heterogenous arrays

Magkakaiba ay isang array kung saan ang iba't ibang elemento ay maaaring direktang isulat sa mga halaga na kabilang sa iba't ibang uri ng data. Ang isang array na nag-iimbak ng mga pointer sa mga halaga ng iba't ibang uri ay hindi heterogenous, dahil ang data mismo na naka-imbak sa array ay kabilang sa isang uri - ang uri ng "pointer". Ang mga heterogenous array ay maginhawa bilang isang unibersal na istraktura para sa pag-iimbak ng mga set ng data ng mga arbitrary na uri. Ang kakulangan ng kanilang suporta sa programming language ay humahantong sa pangangailangan na magpatupad ng mas kumplikadong mga scheme ng pag-iimbak ng data. Sa kabilang banda, ang pagpapatupad ng heterogeneity ay nangangailangan ng mas kumplikadong mekanismo ng suporta sa array sa tagasalin ng wika.

Mga array ng array

Ang mga multidimensional na array ay karaniwang ipinapatupad bilang isang-dimensional na array, ang bawat elemento nito ay isang reference sa isa pang one-dimensional na array.

Pagpapatupad

Ang karaniwang paraan upang ipatupad ang mga static na array na may isang uri ng elemento ay ang mga sumusunod:

1. Ang tuluy-tuloy na bloke ng memorya na may volume na S*m 1 *m 2 *m 3 …m n ay inilalaan para sa array, kung saan ang S ay ang laki ng isang elemento, at m 1 …m n ang mga sukat ng mga saklaw ng index (iyon ay , ang bilang ng mga halaga na maaaring kunin ng kaukulang index).
2. Kapag nag-a-access ng array element A, ang address ng kaukulang elemento ay kinakalkula bilang B+S*(i 1p *m 1 +i 2p *m 2 +…+i (n-1)p *m n-1 +i np ), kung saan ang B - base (address ng simula ng array memory block), ang i kp ay ang halaga ng kth index na binawasan sa isang integer na may zero initial offset.

Sa ganitong paraan, kinakalkula ang address ng isang elemento na may ibinigay na hanay ng mga indeks upang ang oras ng pag-access sa lahat ng elemento ng array ay pareho.

Ang unang elemento ng array, depende sa programming language, ay maaaring may ibang index. May tatlong pangunahing uri ng mga array: zero-based (zero-based), one-based (one-based), at batay sa isang partikular na halaga na tinukoy ng programmer (n-based). Ang pagbibilang ng index ng isang elemento ng array mula sa zero ay mas karaniwan para sa mababang antas ng mga wika, ngunit ang pamamaraang ito ay pinasikat sa mas mataas na antas ng mga wika ng C programming language.

Ang mas kumplikadong mga uri ng array - dynamic at heterogenous - ay mas mahirap ipatupad.

Mga kalamangan

• kadalian ng pagkalkula ng address ng isang elemento sa pamamagitan ng index nito (dahil ang mga elemento ng array ay matatagpuan nang magkakasunod)
• pantay na oras ng pag-access sa lahat ng elemento
• maliit na sukat ng mga elemento: binubuo lamang sila ng isang field ng impormasyon

Bahid

• para sa isang static na array - kakulangan ng dynamics, imposibilidad ng pag-alis o pagdaragdag ng isang elemento nang hindi inililipat ang iba
• para sa isang dynamic at/o heterogenous array - mas mababa (kumpara sa isang regular na static) na performance at karagdagang overhead para sa pagsuporta sa mga dynamic na katangian at/o heterogeneity.
• kapag nagtatrabaho sa isang C-style array (na may mga pointer) at sa kawalan ng karagdagang mga kontrol - ang banta ng paglampas sa mga hangganan ng array at nakakapinsalang data

Maliban sa uri ng file. Ang uri ng sangkap ay tinatawag pangunahing uri. Ang bawat bahagi ay maaaring tahasang matukoy sa pamamagitan ng paggamit ng array variable na pangalan na sinusundan sa mga square bracket ng index. Ang kanilang uri ay tinatawag uri ng index. Ang oras na kinakailangan upang ma-access ang anumang bahagi ay hindi nakasalalay sa halaga ng index. Samakatuwid, maaari nating pag-usapan ang tungkol sa mga array bilang mga bagay na pinapayagan ng istraktura random(o tuwid) access.

Pagdedeklara ng mga variable ng uri ng array

Inilalarawan ang isang variable na uri ng array sa seksyon ng kahulugan ng variable sa sumusunod na form:

Var<идентификатор>: array[<тип индекса>] ng<тип компонент>

Ang pinakakaraniwang ginagamit na uri ng index ay ang uri ng agwat. Halimbawa, ang isang one-dimensional na hanay ng mga average na buwanang temperatura ay ilalarawan tulad ng sumusunod:

Var T: array ng real;

Tinutukoy ng paglalarawan ng array, una, ang paglalagay ng array sa memorya, at pangalawa, ang mga panuntunan para sa karagdagang paggamit nito sa programa. Ang magkakasunod na elemento ng array ay matatagpuan sa magkakasunod na mga cell ng memorya (T, T, atbp.), at ang mga halaga ng index ay hindi dapat mahulog sa labas ng saklaw na 1...12. Anumang expression ng naaangkop na uri ay maaaring gamitin bilang isang index. Halimbawa:

T, T

Ang uri ng index ay maaaring anumang uri ng scalar ordinal maliban sa integer (sa pagpapatupad ng Turbo Pascal). Halimbawa, maaaring maglaman ang programa ng mga sumusunod na paglalarawan:

Var Cod: hanay ng 1..100; L: hanay ng Char;

Sa naturang programa, ang mga sumusunod na notasyon para sa mga elemento ng array ay katanggap-tanggap:

bakalaw["x"]; L; bakalaw; L;

Sa ilang mga kaso, maaaring maginhawang gumamit ng isang enumerated na uri bilang isang index. Halimbawa, ang data sa bilang ng mga mag-aaral sa apat na ikasampung baitang ng isang paaralan ay maaaring maimbak sa sumusunod na hanay:

Uri ng Index=(A, B, C, D); Var Class_10: hanay ng byte;

At kung, halimbawa, ang elemento Class_10[A] ay katumbas ng 35, nangangahulugan ito na mayroong 35 katao sa klase 10 "A". Pinapabuti ng pag-index na ito ang visibility ng program.

Kadalasan ang isang structured na uri ay binibigyan ng pangalan sa seksyon ng uri, na pagkatapos ay ginagamit sa seksyon ng variable na deklarasyon.

Uri ng Mas1 = array ng integer; Mas2 = array[-10..10] ng char; var Num: Mas1; Sim: Mas2;

Multidimensional na mga array

Ang isang multidimensional na array sa Pascal ay itinuturing bilang isang one-dimensional na array, ang uri ng elemento na kung saan ay isang array din (array ng mga array). Halimbawa, ang average na buwanang temperatura ng 10 taon ay maaaring maimbak sa isang array na inilarawan bilang sumusunod:

Var H: array ng array ng real;

Narito ang mga halimbawa ng pagtatalaga ng ilang elemento ng array na ito:

N; N; N;

Gayunpaman, ang isa pa, katumbas na anyo ng pagtatalaga ng mga elemento ng isang two-dimensional array ay mas madalas na ginagamit:

N; N; N;

Ang variable na H ay kumakatawan sa buong unang hilera ng talahanayan, i.e. ang buong hanay ng mga temperatura para sa 1981. Ang isa pang opsyon, katumbas ng paglalarawan sa itaas, ay ang sumusunod:

Uri ng Buwan = array ng real; Taon = hanay ng Buwan; var H:Taon;

Ang pinakamaikling paraan upang ilarawan ang array na ito ay ang mga sumusunod:

Var H: array ng real;

Ang isang three-dimensional array ay maaaring tukuyin bilang isang one-dimensional array na ang mga elemento ay two-dimensional arrays. Narito ang isang halimbawa ng isang three-dimensional na paglalarawan ng array:

Var A: array ng integer;

Ito ay isang array na binubuo ng 10x20x30 = 6000 integer at tumatagal ng hanggang 6000x2 = 12000 bytes sa memorya. Sa Pascal walang pinakamataas na limitasyon sa laki ng isang array. Gayunpaman, nililimitahan ng bawat partikular na pagpapatupad ng Pascal ang dami ng memorya na inilalaan para sa mga array.

Sa pamamagitan ng pagkakatulad sa matematika, ang mga one-dimensional na numeric array ay madalas na tinatawag na mga vector, at ang mga two-dimensional ay tinatawag na matrice. Ang mga array ay hindi maaaring baguhin ang laki sa runtime. Ang pagbabago ng laki ng array ay nangyayari sa pamamagitan ng pagbabago sa teksto ng programa at muling pagsasama-sama. Upang gawing simple ang mga naturang pagbabago, maginhawang tukuyin ang mga parameter ng index sa seksyon ng constants:

Const Imax=10; Jmax=20; var Mas: array ng integer;

Ngayon, upang baguhin ang mga sukat ng Mas array at lahat ng mga pahayag ng programa na nauugnay sa mga sukat na ito, sapat na upang i-edit lamang ang isang linya sa programa - ang seksyon ng mga constant.

Array Operations

Mga pagkilos sa isang array sa kabuuan. Ang ganitong mga aksyon ay pinahihintulutan lamang sa dalawang kaso:

• pagtatalaga ng mga halaga mula sa isang array patungo sa isa pa;
• relational operations “equal” at “not equal”.

Sa parehong mga kaso, ang mga array ay dapat magkaroon ng parehong mga uri (uri ng index at uri ng elemento). Halimbawa:

Var P, Q: Array Of Real;

Kapag isinagawa ang operasyon ng pagtatalaga na P:= Q, ang lahat ng mga elemento ng array P ay magiging katumbas ng mga katumbas na elemento ng array Q.

Sa mga multidimensional na array, ang isang variable na may index ay maaaring kumatawan sa buong array. Halimbawa, kung sa talahanayan H gusto mong ang data para sa 1989 ay kapareho ng para sa 1981 (ang ikasiyam na hilera ay nakatakda sa halaga ng unang hilera), kung gayon maaari itong gawin tulad nito:

N := N;

At kung kailangan mong palitan ang mga halaga ng mga linyang ito, ginagawa ito sa pamamagitan ng ikatlong variable ng parehong uri:

P:= N; N := N; N := P;

kung saan ang P ay inilarawan tulad nito:

Var P: Array Ng Tunay;

Pagproseso ng Array

Ang pagpoproseso ng mga arrays sa mga programa ay isinasagawa sa bawat bahagi. Narito ang mga halimbawa ng pagpasok ng mga halaga sa mga array:

Para sa I:= 1 hanggang 12 do readln(T[I]); para sa I:= 1 hanggang IMax gawin para sa J:= 1 hanggang JMax gawin readln(Mas);

Dito, ang bawat kasunod na halaga ay ilalagay sa isang bagong linya. Para sa line-by-line input, ginagamit ang read operator. Katulad nito, sa isang loop gamit ang isang index variable, ang output ng mga halaga ng array ay nakaayos. Halimbawa:

Para sa I:= 1 hanggang 12 ang sumulat(T[I]:8:4);

Ang sumusunod na fragment ng programa ay nag-aayos ng row-by-row na pagpapakita ng matrix sa screen:

Para sa I:= 1 hanggang IMax ay magsisimula para sa J:= l hanggang JMax ay sumulat(Mas:6); writeln; wakas;

Pagkatapos i-print ang susunod na hilera ng matrix, ililipat ng writeln operator na walang mga parameter ang cursor sa simula ng bagong linya. Dapat tandaan na sa huling halimbawa ang matrix sa screen ay makukuha sa natural na anyo ng isang hugis-parihaba na talahanayan kung ang JMax ay hindi lalampas sa 12.

Mga dynamic na array

Ang isang kawili-wiling tampok ay idinagdag sa FreePascal at Delphi upang ilarawan ang mga array nang hindi tinukoy ang mga sukat at, nang naaayon, mga limitasyon para sa pagbabago ng mga index:

Var IntArray: hanay ng integer;

Ang ganitong mga array ay dynamic at sa una ay may zero na haba. Ang pagtatakda ng laki ng array at pagtukoy nito sa panahon ng pagpapatupad ng programa ay ginagawa sa parehong paraan tulad ng para sa mga string, gamit ang mga function. SetLength At Ang haba, ayon sa pagkakabanggit. Ang mga elemento sa kasong ito ay binibilang simula sa zero.

Programa gamit angDynamicArrays1; var A, B: Array ng Integer; (Paglalarawan ng dalawang variable - mga dynamic na array ng mga elemento ng integer) simulan ang SetLength(A, 5); (Pagtatakda ng laki ng array A (5 elemento)) A := 1; (Pagtatalaga ng value 1 sa array element A na may numero 0) na dulo.

Ang mga dynamic na variable ng array ay mga pointer at ang mga pagpapatakbo sa kanila ay ginagawa tulad ng sa mga pointer. Halimbawa, kapag nagtatalaga ng isang array sa isa pa, ang mga elemento ng isang array ay hindi kinokopya sa pangalawa, ngunit ang address ng array ay kinopya. Alinsunod dito, ang paghahambing ng dalawang array sa mga lohikal na expression ng "pantay - hindi pantay" na uri ay ginagawa sa pamamagitan ng paghahambing ng mga address. Isang halimbawa ng pagtatalaga ng isang array sa isa pa:

Programa gamit angDynamicArrays2; var A, B: array ng integer; (Paglalarawan ng dalawang variable - mga dynamic na array ng mga elemento ng integer) simulan ang SetLength(A, 5); ( Pagtatakda ng laki ng array A (5 elemento) ) A := 14; (Pagtatalaga ng value 14 sa zero element ng array A) B:= A; (Pagtatalaga ng array A sa array B, ngayon ay tumuturo ang variable A at B sa parehong array) B := 2; (Ang pagtatalaga ng zeroth element ng array B sa value 2, ngayon ang zeroth element ng array A ay mayroon ding value 2) end.

Tandaan natin ang isang makabuluhang pagkakaiba sa pagtatrabaho sa mga string at dynamic na array, na may parehong panloob na representasyon batay sa mga pointer, ngunit magkaibang mga paraan ng pagtatrabaho. Dalawang magkaibang string na naglalaman ng parehong hanay ng mga character ay itinuturing na pantay, ngunit dalawang magkaibang array na naglalaman ng parehong mga elemento ay hindi pantay.

>> Mga artikulo

Ano ang mga arrays sa programming?

Ang array ay isang variable na isang koleksyon ng mga bahagi ng parehong uri. Upang gumamit ng mga arrays sa programming, kakailanganin mo ng isang paunang paglalarawan ng isang tiyak na uri at isang indikasyon ng pag-access sa mga elemento. Ang mga elemento ng array sa programming ay pinagsama ng isang karaniwang pangalan. Kung kailangan mong mag-access ng isang partikular na elemento ng array, tukuyin lamang ang pangalan at index. Sa matematika mayroong isang malinaw na halimbawa ng isang array - ito ay mga vectors at sequence ng mga numero kung saan ang isang pangkat ng mga numero ay maaaring italaga ng isang pangalan. Kapag tumutukoy sa isang tiyak na numero, iba't ibang mga indeks ang ginagamit.

Mga uri ng array: one-dimensional at two-dimensional

Kung ang isa ay ginagamit upang ma-access ang mga elemento serial number, pagkatapos ang array ay tinatawag na one-dimensional o linear. Parang table na may isang row. Ang laki ng isang array ay tinutukoy ng bilang ng mga indeks ng elemento.

Kapag ginamit ang dalawang index, magiging two-dimensional ang array. Kung ang isang array ay kinakatawan sa isang ideya ng talahanayan, ang numero ng row ay tumutugma sa unang index, at ang column o cell number ay tumutugma sa pangalawa.

Paano punan ang isang array?

Ang isang paraan upang punan ang isang array ay ang assignment operator. Kapag ang mga elemento ay paulit-ulit na nauugnay at may isang tiyak na dependency, ang paraan ng pagpuno ay angkop. Maaari mo ring punan homogenous na hanay homogenous na elemento o value na nakukuha sa pamamagitan ng random number sensor..

Anong mga aksyon ang ginagawa sa mga elemento ng array?

Pag-uuri ng mga elemento sa isang tiyak na pagkakasunud-sunod - pababa o pataas

Paghahanap ng mga halaga

Binibilang ang bilang ng mga elemento sa isang array na nakakatugon sa isang partikular na kundisyon

Kapag ang dalawang array ay katumbas, posibleng italaga ang isang array ng pangalan ng isa pa. Ang lahat ng mga bahagi ay kinokopya sa array, kung saan ang isang halaga ay itinalaga.

Paano magdeklara ng isang array

Upang magdeklara ng array at maglaan ng lokasyon sa memorya upang mag-imbak ng mga elemento, dapat mong tukuyin ang dimensyon at pangalan. Ang keyword ay array. Halimbawa, ang A 20 ay nangangahulugan na ang isang one-dimensional na array ay binubuo ng dalawampung elemento. K 6.5 ang ibig sabihin nito ay dalawang-dimensional na hanay, na ipinakita bilang isang talahanayan ng anim na hanay at limang mga cell. Kung pinag-uusapan natin ang mga limitasyon ng isang one-dimensional na array sa programming, kung gayon ito ay isang libong elemento. Para sa dalawang-dimensional na array, ang maximum na pinahihintulutang halaga ay isang talahanayan ng isang libong row at isang libong cell.

Mga array sa programming: nagtatrabaho sa kanila

Kapag ang isang array ay idineklara, ang bawat elemento ay pinoproseso na may isang pangalan at index sa mga square bracket. Upang makilala ang isang one-dimensional array mula sa isang two-dimensional array, dalawang index ang ginagamit. Ang mga elemento ng array na itinalaga ng isang index ay tinatawag na mga variable na na-index, ngunit maaari ding gamitin bilang mga simpleng variable. Halimbawa, ang pagiging isang argumento sa isang pangkat.

Mga uri ng pangalan, elemento, index

Paano makabuo ng isang pangalan para sa array? Magagawa ng anumang identifier. Ayon sa mga panuntunan sa istilo, ang pangalan ay dapat magsimula sa titik T sa isang malaking font. Sa ganitong paraan maaari mong makilala ang identifier mula sa iba. Ang kasunod na bahagi ng pangalan ay maaaring imbento alinsunod sa partikular na data na itatabi sa array. Pangalawa bahagi ng pangalan kailangan ding magsimula sa malaking titik. Maaaring mag-imbak ang T Vector ng impormasyon tungkol sa mga coordinate ng abstract vector.

Tulad ng para sa uri ng mga elemento sa array, maaari itong maipasok dati o pamantayan. Ang mga integer ay ginagamit upang lumikha ng mga index, at ang uri ay magiging isang hanay. Sabihin nating ang uri 1...20 ay nangangahulugan na ang array ay binubuo ng dalawampung elemento, bawat isa ay tumutugma sa isang integer mula isa hanggang dalawampu.

Kung gusto mong malaman ang tungkol sa mga hanay ng mga puno, ang artikulong ito ay hindi tungkol dito. Ngunit huwag magmadali upang isara ang artikulo, makakatulong ito sa iyo na maging mas matalino, dahil bilang karagdagan sa mga array ng kahoy, malalaman mo kung ano ang array sa programming. Sa katunayan, ang mga salita ay may napakaraming kahulugan na maaari kang malito...

Array sa programming

Upang magkaroon ng pang-unawa, magsimula tayo sa pinakasimpleng kahulugan ng array.

Ang array ay isang hanay ng mga value na nakatago sa ilalim ng isang partikular na pangalan. Iyon ay, maaari nating pag-usapan ang tungkol sa isang hanay ng mga variable na may isa o ibang halaga, o maaari nating pag-usapan ang tungkol sa isang set ng mga variable na ito (homogeneous elements), ang bawat variable ay maaaring ma-access sa pamamagitan ng index nito, o serial number (nakasulat sa mga square bracket ).

Para sa kalinawan, magbigay tayo ng isang halimbawa mula sa buhay. Kaya ang listahan ng mga mag-aaral sa journal ay isang array. Ang serial number ng bawat mag-aaral (karaniwan ay ayon sa alpabetikong pagkakasunud-sunod, ibig sabihin, ang mga apelyido na nagsisimula sa "A" ang mauuna) ay ang kanyang index.

Ang bawat halaga ng array (mga mag-aaral sa halimbawa) ay tinatawag na isang bahagi (o elemento).

Ang mga array ay ginagamit upang malutas ang iba't ibang mga problema sa programming.

Mga uri ng array

Maaari nating pag-usapan ang tungkol sa dalawang uri ng mga array:

1. isang-dimensional;
2. multidimensional.

Gayunpaman, ang mga one-dimensional at two-dimensional na array ay kadalasang ginagamit sa paglutas ng mga problema sa programming.

• Upang mas malinaw na isipin kung ano ang isang one-dimensional na array, isipin natin ang isang parisukat na piraso ng papel ng notebook. Kaya, anumang linya patayo o pahalang (o maaaring pahilis) - narito ito, isang one-dimensional na array. At ang bilang ng mga cell ang tutukuyin ang dimensyon ng one-dimensional array na ito. Sa bawat elemento (cell) maaari kang magsulat ng isang halaga (halimbawa, isang numero), ngunit isa lamang (!). Mahahanap mo ang value na ito sa pamamagitan ng pagpahiwatig ng serial number nito (sa mga square bracket).
• Tingnan natin kung ano ang isang two-dimensional array, gamit ang parehong halimbawa ng isang parisukat na piraso ng papel ng notebook. Ilang mga cell nang pahalang, ilang patayo - at nakakakuha kami ng ilang uri ng hugis-parihaba na plato (basahin ang tungkol sa parisukat sa ibaba). Ito ay magiging isang two-dimensional array. Dito maaari nating pag-usapan ang tungkol sa mga hilera ng matrix (mga patayong selula) at mga haligi (mga pahalang na selula, ayon sa pagkakabanggit). Tulad ng sa isang one-dimensional na array, ang bawat cell ay nag-iimbak ng isang halaga. Ang pagkakaiba ay sa paghahanap ng tamang halaga. Dito kailangan nating ipahiwatig ang numero ng linya at numero ng haligi, ang intersection kung saan ay magbibigay sa amin ng elemento na kailangan namin.

Ang isang variant ng isang two-dimensional array ay isang square matrix, kung saan ang bilang ng mga column at row ay pareho. Sa kasong ito, sa programming ay hindi na kailangang ipasok ang bilang ng mga hilera at haligi; sapat na upang ipahiwatig lamang ang sukat ng aming matrix.

Mayroong dalawang uri ng mga diagonal sa isang square matrix:

1. home - mula sa kaliwang sulok sa itaas hanggang sa kanang ibaba (i.e. kung saan tumutugma ang mga numero ng row at column);
2. gilid - mula sa kanang sulok sa itaas hanggang sa kaliwang ibaba.

Upang palakasin ito, magbigay tayo ng isa pang halimbawa sa totoong buhay upang ilarawan ang mga array.

Kaya, mga residente ng pasukan, hayaan itong maging isang array sa ilalim ng pangalang K.

Ang index dito ay ang numero ng apartment. Ang elementong ito (apartment) ay kumakatawan sa isa pang hanay - mga residente ng apartment. Halimbawa, sa 1st apartment mayroong 4 na tao, sa ika-2 - 3 tao, sa ika-3 - 5 tao.

Kaya, ang one-dimensional array ay isang listahan sa mga square bracket (!) ng bilang ng mga residente: 4, 3, 5.

Two-dimensional array (sa halip na mga square bracket ay magkakaroon tayo ng "*"): **1, 1, 1, 1*, *1,1,1*, *1, 1, 1, 1, 1**

Iyon lang. Mababasa mo ang tungkol sa kung ano ang raid array.

. Form o istraktura ng array- impormasyon tungkol sa bilang ng mga dimensyon at ang laki (haba) ng array para sa bawat dimensyon; ay maaaring katawanin bilang isang one-dimensional array.

Encyclopedic YouTube

• 1 / 5

  Ang array ay isang nakaayos na koleksyon ng data na ginagamit upang mag-imbak ng data ng isang uri, na kinilala ng isa o higit pang mga index. Sa pinakasimpleng kaso, ang array ay may pare-parehong haba at nag-iimbak ng mga unit ng data ng parehong uri.

  Maaaring magkaiba ang bilang ng mga indeks ng array na ginamit: ang mga array na may isang index ay tinatawag na one-dimensional, na may dalawa - two-dimensional, atbp. Ang isang one-dimensional array ("column", "column") ay hindi mahigpit na tumutugma sa isang vector sa matematika; dalawang-dimensional - matris. Kadalasan, ginagamit ang mga array na may isa o dalawang index; mas madalas - na may tatlo; ang isang mas malaking bilang ng mga index ay napakabihirang.

  Isang halimbawa ng isang nakapirming array sa Pascal

  (One-dimensional na hanay ng mga integer. Pagbilang ng mga elemento mula 1 hanggang 15) a : array [ 1 .. 15 ] ng Integer ; (Two-dimensional na hanay ng mga character. Pagnunumero ng column ayon sa uri ng Byte (mula 0 hanggang 255) sa mga linya mula 1 hanggang 5) multiArray: array [Byte, 1 .. 5] ng Char; (One-dimensional na hanay ng mga string. Pagnunumero ayon sa uri ng salita (mula 0 hanggang 65536)) rangeArray : array [ Word ] ng String ;

  Halimbawa ng isang nakapirming array sa C/C++

  IntArray[10]; // One-dimensional array: integers, size 10; // Pagbilang ng mga elemento - mula 0 hanggang 9. dobleng Array[ 12 ][ 15 ]; // Dalawang-dimensional na array: // double precision real number,// laki 12 by 15; // Numbering: ayon sa linya - mula 0 hanggang 11, // ayon sa mga hanay - mula 0 hanggang 14.

  Sa ilang mga programming language, ang mga multidimensional na array ay nilikha batay sa mga one-dimensional, na ang mga elemento ay array.

  Halimbawa ng isang two-dimensional na array sa JavaScript

  //ES6. Paglikha ng dalawang-dimensional na hanay ng mga numero: var array = [ [ 11 , 12 , 13 , 14 , 15 , 16 ], // Ang unang hilera ay isang array[ 21 , 22 , 23 , 24 , 25 , 26 ], // Pangalawa [ 31 , 32 , 33 , 34 , 35 , 36 ] // Pangatlo ]; // I-output ang array sa console: array. forEach ((subArray ) => ( // Para sa bawat sub-array, subArray. forEach ((item ) => ( // para sa bawat elemento nito, console. log(item); // - ipakita ang elementong ito sa console. }); });

  Ang suporta para sa mga index arrays (sariling declaration syntax nito, mga function para sa pagtatrabaho sa mga elemento, atbp.) ay available sa karamihan ng mga high-level na programming language. Ang maximum na pinahihintulutang laki ng array, mga uri at hanay ng mga halaga ng index, mga paghihigpit sa mga uri ng elemento ay tinutukoy ng programming language at (o) isang partikular na tagasalin.

  Sa mga programming language na nagpapahintulot sa programmer na magpahayag ng kanyang sariling mga uri, bilang isang panuntunan, posible na lumikha ng isang "array" na uri. Ang kahulugan ng ganitong uri ay maaaring tukuyin: laki, uri ng elemento, hanay ng halaga, at mga uri ng index. Sa hinaharap, posibleng tukuyin ang mga variable ng nilikhang uri. Ang lahat ng naturang mga variable ng array ay may parehong istraktura. Sinusuportahan ng ilang wika ang mga pagpapatakbo ng pagtatalaga para sa mga variable ng array (kapag ang isang operasyon ay nagtatalaga ng mga halaga ng mga kaukulang elemento ng isa pang array sa lahat ng mga elemento ng isang array).

  Deklarasyon ng uri ng "array" sa Pascal

  I - type ang TArrayType = array [ 0 .. 9 ] ng Integer ; (*Mga array na may tinukoy na mga parameter: 1. Sukat - 10 mga cell; 2. Uri ng mga bagay na angkop para sa imbakan - - mga integer sa hanay [−32,768; 32,767], - ay idineklara ng isang uri ng operand na tinatawag na "TArrayType". *) var arr1, arr2, arr3: TArrayType; (* Deklarasyon ng tatlong array variable ng parehong uri (ang nasa itaas na "TArrayType"). *)

  Mga Tukoy na Uri ng Array

  Mga dynamic na array

  Ang "Dynamic" ay isang array ng isang laki na maaaring "dynamic" na magbago sa panahon ng pagpapatupad ng programa (halimbawa, bumaba pagkatapos mag-unload ng hindi nauugnay na data). Ang isang programming language na nagbibigay ng kakayahang ito ay tinatawag na dynamic array-supporting. Ginagawa ng mga dynamic na array na mas flexible ang pagtatrabaho sa data, dahil hindi nila kailangan ang paunang pagtukoy sa dami ng data na iimbak, ngunit pinapayagan kang ayusin ang laki ng array alinsunod sa mga tunay na pangangailangan. Tinatawag din ang mga ordinaryong (non-dynamic) na array nakapirming.

  Halimbawa ng isang dynamic na array sa Delphi

  ByteArray: Array ng Byte; // Isang-dimensional na array multiArray : Array ng Array ng string ; // Multidimensional array

  Halimbawa ng isang dynamic na array sa C

  Float * array1 ; // Isang-dimensional na array int**array2; // Dalawang-dimensional na array array1 = (float * ) malloc (10 * sizeof (float )); // maglaan ng 10 bloke ng sizeof(float) bytes bawat isa array2 = (int ** ) malloc (16 * sizeof (int * )); // paglalaan ng 16 na bloke ng sizeof(int*) bytes bawat isa. Ang mga pointer sa one-dimensional string arrays ay isusulat dito para sa (i = 0 ; i< 16 ; ++ i ) array2 [ i ] = (int * ) malloc (8 * sizeof (int )); // paglalaan ng 8 bloke ng sizeof(int) bytes bawat isa. Ito ay mga one-dimensional na array - mga matrix row. // Access sa array array1[i] = 5.0; * (array1 + i ) = 5.0 ; array2[i][j] = 6; // Ang mga entry ay katumbas. Ang una ay gumagamit ng index,* (* (array2 + i ) + j ) = 6 ; // pangalawa sa pagpapatakbo ng dereferencing. libre(array1); para sa (i = 0 ; i< 16 ; ++ i ) free (array2 [ i ]); free (array2 );

  Halimbawa ng dynamic na array sa C++

  Float * array1 ; // Isang-dimensional na array int**array2; // Multidimensional array array1 = bagong float [10]; // paglalaan ng 10 bloke ng laki ng float array2 = bagong int * [16]; // paglalaan ng 16 na bloke na may sukat ng isang pointer sa int para sa (int i = 0 ; i< 16 ; ++ i ) array2 [ i ] = new int [ 8 ]; // Paggawa gamit ang mga array. tanggalin ang array1 ; // Mahalagang tandaan na ibalik ang inilalaang memorya sa system. para sa (int i = 0 ; i< 16 ; ++ i ) delete array2 [ i ]; // Ibalik ang memory na ginamit para sa matrix row. tanggalin ang array2 ; // Ibalik ang memory na ginamit para sa mga column ng matrix.

  Heterogenous arrays

  Magkakaiba ay isang array kung saan ang iba't ibang elemento ay maaaring direktang maimbak na may mga halaga na kabilang sa iba't ibang uri ng data. Ang isang array na nag-iimbak ng mga pointer sa mga halaga ng iba't ibang uri ay hindi heterogenous, dahil ang data mismo na naka-imbak sa array ay kabilang sa isang uri - ang uri ng "pointer". Ang mga heterogenous array ay maginhawa bilang isang unibersal na istraktura para sa pag-iimbak ng mga set ng data ng mga arbitrary na uri. Ang pagpapatupad ng heterogeneity ay nangangailangan ng isang mas kumplikadong mekanismo para sa pagsuporta sa mga array sa tagasalin ng wika.

  Pagpapatupad

  Ang isang paraan upang ipatupad ang mga static na array na may isang uri ng elemento ay ang mga sumusunod (sa