Matrika je podatkovna struktura, predstavljena kot skupina celic istega tipa, združenih pod enim imenom. Nizi se uporabljajo za obdelavo velikih količin podatkov iste vrste. Ime matrike je tisto, kar so kazalci, vam bom povedal malo kasneje. Posamezno podatkovno celico matrike imenujemo element matrike. Elementi matrike so lahko podatki katere koli vrste. Nizi imajo lahko eno ali več dimenzij. Glede na število dimenzij delimo nize na enodimenzionalne nize, dvodimenzionalne nize, tridimenzionalne nize in tako naprej do n-dimenzionalnega niza. Pri programiranju se najpogosteje uporabljajo enodimenzionalni in dvodimenzionalni nizi, zato bomo obravnavali samo te nize.

Enodimenzionalni nizi v C++

Enodimenzionalna matrika je matrika z enim parametrom, ki označuje število elementov enodimenzionalne matrike. Pravzaprav je enodimenzionalna matrika matrika, ki ima lahko samo eno vrstico in n število stolpcev. Stolpci v enodimenzionalni matriki so elementi matrike. Slika 1 prikazuje strukturo celoštevilske enodimenzionalne matrike a. Velikost tega polja je 16 celic.

Slika 1 - Nizi v C++

Upoštevajte, da je največji indeks enodimenzionalne matrike a je 15, vendar je velikost matrike 16 celic, ker se številčenje celic matrike vedno začne z 0. Indeks celice je nenegativno celo število, s katerim lahko dostopate do vsake celice matrike in izvajate poljubna dejanja na njej ( celica).

// sintaksa za deklaracijo enodimenzionalne matrike v C++: /*podatkovni tip*/ /*ime enodimenzionalne matrike*/; //primer deklaracije enodimenzionalne matrike, prikazane na sliki 1: int a;

kjer je int celo število;

A je ime enodimenzionalne matrike;
16 je velikost enodimenzionalne matrike, 16 celic.

Vedno takoj za imenom matrike so oglati oklepaji, v katerih je podana velikost enodimenzionalne matrike, po čemer se matrika loči od vseh ostalih spremenljivk.

//drug način za deklaracijo enodimenzionalnih nizov int mas, a;

Dve enodimenzionalni matriki mas in a sta deklarirani z velikostjo 10 oziroma 16. Poleg tega bodo v tej metodi deklaracije vsi nizi imeli isti tip podatkov, v našem primeru - int.

// matrike je mogoče inicializirati, ko so deklarirane: int a = ( 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // inicializacija enodimenzionalne matrike

Inicializacija enodimenzionalne matrike se izvede v zavitih oklepajih za znakom enako, je vsak element matrike od prejšnjega ločen z vejico.

Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); // inicializacija matrike brez določitve njene velikosti.

V tem primeru bo prevajalnik sam določil velikost enodimenzionalne matrike. Velikost matrike lahko izpustite le, ko jo inicializirate; pri običajni deklaraciji matrike je treba določiti velikost matrike. Razvijmo preprost program za obdelavo enodimenzionalne matrike.

// array.cpp: Definira vstopno točko za konzolno aplikacijo. #include "stdafx.h" #include << "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } system("pause"); return 0; }

// koda Code::Blocks

// Koda Dev-C++

// array.cpp: Definira vstopno točko za konzolno aplikacijo. #vključi uporaba imenskega prostora std; int main(int argc, char* argv) ( cout<< "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } return 0; }

IN vrstice 10-11 Deklarirana in inicializirana je celoštevilska enodimenzionalna matrika z imenom array1, katere velikost je 16 celic, kar pomeni, da lahko taka matrika shrani 16 števil. Kakršna koli obdelava matrike je možna samo v povezavi z zankami. Katero zanko izbrati za obdelavo niza, se odločite sami. Vendar je za to nalogo najbolj primeren. Za dostop do elementov enodimenzionalne matrike array1 bomo uporabili spremenljivko counter counter. Pogoj za nadaljevanje zanke for vsebuje strog znak neenakosti, saj v enodimenzionalni matriki array1 ni šestnajstega indeksa. In ker se številčenje celic začne od nič, je elementov v matriki 16. V telesu zanke for operater cout natisne elemente enodimenzionalne matrike (glej sliko 2).

Obrabotka massiva indeksira element massiva array1 5 array1 -12 array1 -12 array1 9 array1 10 array1 0 array1 -9 array1 -12 array1 -1 array1 23 array1 65 array1 64 array1 11 array1 43 array1 39 array1 -15 Za nadaljevanje pritisnite katero koli tipko. . .

Slika 2 - Nizi v C++

Razvijmo še en program za obdelavo enodimenzionalne matrike v C++. Program mora zaporedno prebrati deset vnesenih številk s tipkovnice. Vse vnesene številke se seštejejo in rezultat se prikaže na zaslonu.

// array_sum.cpp: Določa vstopno točko za konzolno aplikacijo. #include "stdafx.h" #include << "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> << "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; system("pause"); return 0; }

// koda Code::Blocks

// Koda Dev-C++

// array_sum.cpp: Določa vstopno točko za konzolno aplikacijo. #vključi uporaba imenskega prostora std; int main(int argc, char* argv) ( int array1; // deklariraj celoštevilsko matriko cout<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >>matrika1; // branje številk, vnesenih s tipkovnico cout<< "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; return 0; }

Pred obdelavo matrike je potrebno le-to deklarirati, velikost enodimenzionalne matrike pa je 10, kot to določa pogoj naloge. V spremenljivki vsota bomo akumulirali vsoto elementov enodimenzionalne matrike. Prva zanka for zapolni deklarirano enodimenzionalno matriko s številkami, vnesenimi s tipkovnice, vrstice 12-13. Spremenljivka števca se uporablja za zaporedni dostop do elementov enodimenzionalne matrike array1, začenši z indeksom 0 in do vključno 9. Druga zanka for prikaže elemente matrike, vrstice 15-16. Tretja zanka for zaporedno prebere elemente enodimenzionalne matrike in jih sešteje, vsota se akumulira v spremenljivki sum. vrstice 17-18. Rezultat programa je prikazan na sliki 3.

Vnesite elementi masiva: 0 1 2 3 4 5 6 7 8 9 array1 = (0 1 2 3 4 5 6 7 8 9 ) sum = 45 Za nadaljevanje pritisnite katero koli tipko. . .

Slika 3 – Nizi v C++

Najprej je bilo zaporedoma vnesenih vseh 10 števil, nato pa je bila prikazana enodimenzionalna matrika in izpisana vsota števil v matriki.

Dvodimenzionalni nizi v C++

Do te točke smo obravnavali enodimenzionalne nize, na katere ni vedno mogoče omejiti. Recimo, da morate obdelati nekaj podatkov iz tabele. Tabela ima dve značilnosti: število vrstic in število stolpcev. Tudi v dvodimenzionalni matriki so poleg števila elementov matrike značilnosti, kot so število vrstic in število stolpcev dvodimenzionalne matrike. To pomeni, vizualno je dvodimenzionalni niz običajna tabela z vrsticami in stolpci. Pravzaprav je dvodimenzionalni niz enodimenzionalni niz enodimenzionalnih nizov. Struktura dvodimenzionalne matrike, imenovane a, velikosti m x n je prikazana spodaj (glej sliko 4).

Slika 4 - Nizi v C++

kjer je m število vrstic dvodimenzionalnega polja;
n je število stolpcev dvodimenzionalne matrike;
m * n — število elementov matrike.

// sintaksa za deklaracijo dvodimenzionalne matrike /*vrsta podatkov*/ /*ime matrike*/;

Pri deklaraciji dvodimenzionalne matrike, kot tudi pri deklaraciji enodimenzionalne matrike, morate najprej podati:

• vrsta podatkov;
• ime polja.

Nato prvi oglati oklepaji označujejo število vrstic dvodimenzionalne matrike, drugi oglati oklepaji pa število stolpcev dvodimenzionalne matrike. Dvodimenzionalni niz se vizualno loči od enodimenzionalnega niza po drugem paru oglatih oklepajev. Oglejmo si primer deklaracije dvodimenzionalne matrike. Recimo, da moramo deklarirati dvodimenzionalno matriko s številom elementov, ki je enako 15. V tem primeru ima lahko dvodimenzionalna matrika tri vrstice in pet stolpcev ali pet vrstic in tri stolpce.

// primer deklaracije dvodimenzionalne matrike: int a;

• a je ime niza celih števil
• številka v prvih oglatih oklepajih označuje število vrstic dvodimenzionalnega polja, v tem primeru jih je 5;
• številka v drugem oglatem oklepaju označuje število stolpcev dvodimenzionalne matrike, v tem primeru so 3.

// inicializacija dvodimenzionalne matrike: int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1) );

Ta niz ima 5 vrstic, 3 stolpce. za znakom za dodelitev so postavljeni splošni zavit oklepaj, znotraj katerega je postavljenih toliko parov zavitih oklepajev, kolikor mora biti vrstic v dvodimenzionalnem nizu, ti oklepaji pa so ločeni z vejicami. V vsak par zavitih oklepajev zapišite elemente dvodimenzionalne matrike, ločene z vejicami. V vseh zavitih oklepajih mora biti število elementov enako. Ker je v nizu pet vrstic, je tudi pet notranjih parov oklepajev. V oklepajih so zapisani trije elementi, saj je število stolpcev tri. Grafično bo naše polje videti kot dvodimenzionalna tabela (glej sliko 5).

Slika 5 - Nizi v C++

V vsaki celici dvodimenzionalne matrike a prikazana vrednost, je naslov te celice prikazan v spodnjem desnem kotu. Naslov celice dvodimenzionalne matrike je ime matrike, številka vrstice in številka stolpca.

Razvijmo preprost program za obdelavo dvodimenzionalne matrike, imenovan "Labirint". Labirint mora biti zgrajen na podlagi dvodimenzionalnega niza. Velikost labirinta bomo izbrali po lastni presoji.

// array2.cpp: Definira vstopno točko za konzolno aplikacijo. #include "stdafx.h" #include < 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout<< static_cast(176); ) else cout<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// koda Code::Blocks

// Koda Dev-C++

// array2.cpp: Definira vstopno točko za konzolno aplikacijo. #vključi uporaba imenskega prostora std; int main(int argc, char* argv) ( // 1-pogojno "stene labirinta" // 2-"pravilna pot, izhod iz labirinta" // 0-"napačna pot" int mas = ( (1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // inicializacija dvodimenzionalne matrike ( 1,2,1,0 ,0,1,0,1,2,2,2,1,1,1,1,0,0,0,0,1,), (1,2,1,1 ,0,1,0, 1,2,1,2,2,2,2,1,0,1,1,0,1,), (1,2,2,2,2,2,2, 1,2,1,1 ,1,1,2,1,0,0,1,0,1,), (1,1,1,1,1,1,2,1,2,1,0 ,0,1,2, 1,1,0,1,0,1,), (1,0,0,1,0,0,2,2,2,1,1,0,0,2, 0,0,0,1 ,0,1,), (1,0,1,1,0,1,1,1,1,1,0,0,1,2,1,1,1,1 ,0,1,), (1,0,0,0,0,0,0,0,0,1,1,1,1,2,1,0,0,0,0,1,), (1,1,1, 1,1,1,0,1,1,1,2,2,2,2,1,0,1,1,1,1,), (1,1,0, 0,0,1,0 ,0,1,1,2,1,1,1,1,0,0,0,0,1,), (1,0,0,1,0,0,0 ,0,0,1, 2,2,2,2,1,1,1,1,0,1,), (1,1,1,1,1,1,1,1,1,1, 1,1,1,2 ,1,0,0,0,0,1,), (1,2,2,2,2,2,2,2,2,2,2,2,2,2 ,1,0,1, 1,1,1,), (1,2,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,0, 0,0,1,) , (1,2,1,0,0,0,1,2,2,2,1,0,0,0,0,0,1,1,0,1,) , (1,2,1 ,1,1,1,1,2,1,2,1,1,1,0,1,0,0,0,0,1,), (1,2,1 ,2,2,2, 1,2,1,2,2,2,1,1,1,1,1,1,1,1,), (1,2,1,2,1,2, 1,2,1,0 ,1,2,2,2,2,2,2,2,2,1,), (1,2,1,2,1,2,1,2,1,0 ,1,1,1, 1,1,1,1,1,2,1,), (1,2,1,2,1,2,1,2,1,0,0,0,0, 0,0,0,0 ,0,2,1,), (1,2,1,2,1,2,2,2,1,0,1,1,1,1,1,1,0 ,1,2,1, ), (1,2,1,2,1,1,1,1,1,0,0,0,1,0,1,0,0,1,2,1, ), (1,2, 1,2,2,1,0,0,1,1,1,0,0,0,1,0,1,1,2,1,), (1,2, 1,1,2,1 ,1,0,0,0,0,0,1,0,1,0,0,1,2,1,), (1,2,1,1,2,1 ,0,0,1, 1,1,1,1,1,1,1,1,1,2,1,), (1,2,1,1,2,1,1,0,1, 2,2,2,2 ,2,2,2,2,2,2,1,), (1,2,1,1,2,1,0,0,1,2,1,1,1 ,1,1,1, 1,1,1,1,), (1,2,1,1,2,1,0,1,1,2,1,1,1,1,1,1, 1,1,2,2 ,), (1,2,1,1,2,1,0,0,1,2,1,1,2,2,2,2,2,2,2,1 ,), (1,2 ,1,1,2,1,0,1,1,2,1,1,2,1,1,1,1,1,1,1,), (1,2 ,1,1,2, 1,0,0,1,2,1,1,2,1,0,0,0,1,0,1,), (1,2,2,2,2, 1,0,1,1 ,2,2,2,2,0,0,1,0,0,0,1,), (1,1,1,1,1,1,1,1,1 ,1,1,1, 1,1,1,1,1,1,1,1,) ); // dve zanki - notranja in zunanja, dostop do vsakega elementa matrike za (int i = 0; i< 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout<< static_cast(176); ) else cout<< " "; // вывести два пробела cout << endl; } return 0; }

Pravilna in napačna pot sta lahko označeni z isto številko, na primer z ničlo, zaradi jasnosti pa je pravilna pot označena s številko 2. Matriko smo inicializirali ročno, samo zaradi poenostavitve programa. Ker program obdeluje dvodimenzionalno matriko, sta za preklapljanje med elementi dvodimenzionalne matrike potrebni dve zanki. Prva zanka for preklaplja med vrsticami dvodimenzionalne matrike. Ker je v dvodimenzionalnem nizu 33 vrstic, se spremenljivka števca i poveča od 0 do 33, vrstica 46. Znotraj prve zanke je zanka for, ki kroži skozi elemente vrstice dvodimenzionalne matrike. V telesu druge zanke for se znotraj izvede operacija pretvorbe unarnega podatkovnega tipa - static_cast<>() , ki natisne številko znaka 176. Operacija pretvorbe podatkovnega tipa se podvoji, da se poveča širina labirinta. Rezultat programa (glej sliko 6).

Slika 6 - Nizi v C++

Recimo, da moramo delati z veliko količino podatkov iste vrste. Imamo na primer tisoč meritev koordinat nihala z nekim časovnim korakom. Ustvarjanje 1000 spremenljivk za shranjevanje vseh vrednosti je zelo ... okorno. Namesto tega je mogoče veliko podatkov iste vrste združiti pod enim imenom in do vsakega specifičnega elementa je mogoče dostopati z njegovo serijsko številko.
Niz v C je definiran na naslednji način
<тип> <имя массива>[<размер>];
na primer
int a;
Prejeli bomo niz z imenom a, ki vsebuje sto elementov tipa int. Tako kot pri spremenljivkah tudi matrika vsebuje smeti.
Za dostop do prvega elementa zapišite njegovo številko (indeks) v oglatem oklepaju. Na primer

#vključi #vključi void main() ( int a; a = 10; a = 333; a = 234; printf("%d %d %d", a, a, a); getch(); )

Prvi element ima indeksno številko 0. Pomembno je razumeti, zakaj. V nadaljevanju bomo računalniški pomnilnik predstavljali kot trak. Ime matrike je kazalec na pomnilniški naslov, kjer se nahajajo elementi matrike.

riž. 1 Matrika shrani naslov prvega elementa. Indeks elementa i je premik i*sizeof(type) bajtov od začetka

Indeks matrike označuje, koliko bajtov je treba premakniti od začetka matrike za dostop do želenega elementa. Na primer, če niz A ima vrsto int, potem A pomeni, da smo premaknili 10*sizeof(int) bajtov glede na začetek. Prvi element je na samem začetku in ima odmik 0*sizeof(int) .
V C matrika ne shrani svoje velikosti in ne preverja pravilnosti indeksa matrike. To pomeni, da lahko greste izven matrike in dostopate do pomnilnika, ki je dlje od zadnjega elementa matrike (ali bližje).

Začetna inicializacija matrike.

Napišimo preprost program. Ustvarimo matriko in nato poiščimo njen največji element.

#vključi #vključi void main() ( int a = (1, 2, 5, 3, 9, 6, 7, 7, 2, 4); unsigned i; int max; max = a; for (i = 1; i<10; i++) { if (a[i] >

Poglejmo si primer. Najprej ustvarimo matriko in jo ob ustvarjanju inicializiramo. Po tem največjemu najdenemu elementu dodelimo vrednost prvega elementa matrike.

Max = a;

Nato gremo skozi niz. Ker smo prvi element že pogledali (ima indeks 1), ga nima smisla ponovno gledati.
Isti primer, le da uporabnik zdaj vnese vrednosti

#vključi #vključi void main() ( int a; unsigned i; int max; printf("Vnesite 10 številk\n"); for (i = 0; i<10; i++) { printf("%d. ", i); scanf("%d", &a[i]); } max = a; for (i = 1; i<10; i++) { if (a[i] >max) ( max = a[i]; ) ) printf("največji element je %d", max); getch(); )

Če je med inicializacijo določenih manj vrednosti od velikosti matrike, se preostali elementi zapolnijo z ničlami.

#vključi #vključi void main() ( int a = (1,2,3); unsigned i; for (i = 0; i<10; i++) { printf("%d ", a[i]); } getch(); }

Če je treba celotno matriko zapolniti z ničlami, potem pišemo

Int a = (0);

Na primer, ni vam treba izrecno nastaviti velikosti matrike

Int a = (1, 2, 3);

matrika bo imela velikost 3

Velikost niza

Niz v C mora imeti konstantno velikost. To pomeni, da je nemogoče na primer vprašati uporabnika za velikost in nato to velikost nastaviti na polje.

Printf("Vnesite dolžino niza "); scanf("%d", &dolžina); (plavajoči x;)

O ustvarjanju dinamičnih nizov bomo podrobneje razpravljali pri delu s kazalci in pomnilnikom
V nekaterih primerih lahko ugotovite velikost matrike s funkcijo sizeof.

#vključi #vključi void main() ( int A; //sizeof vrne velikost celotne matrike v bajtih //Če želite določiti število elementov, //delite velikost matrike z velikostjo njenega elementa int size = sizeof(A) / sizeof(int); printf("Velikost matrike je enaka %d", velikost); getch(); )

Toda to verjetno ne bo koristno. Pri posredovanju matrike kot argumenta funkciji bo posredovan kazalec, tako da velikost matrike ne bo znana.
Statični nizi so uporabni, kadar je število elementov znano vnaprej. Omogočajo hiter, a nezanesljiv dostop do elementov.

Prelivanje polja

Upajmo, da imate to kodo

Int A; int i; za (i=0; i<=10; i++) { A[i] = 1; }

Tukaj je zanka za navedeno z napako. V nekaterih starejših različicah prevajalnikov bi se ta koda vrtela v zanki. Bistvo je, da spremenljivka jaz se je med prevajanjem nahajal takoj za matriko A. Ko je niz presegel meje, je bil števec nastavljen na 1.
Nizi niso varni, saj lahko nepravilno delo z indeksom vodi do dostopa do poljubnega dela pomnilnika (teoretično. Sodobni prevajalniki sami skrbijo, da ne posegate po tujem pomnilniku).
Če delate z nizi, morate zagotoviti, da števec ne presega velikosti niza in ni negativen. Za to najmanj

• 1. Za indeksiranje uporabite vrsto size_t. Zaščitil vas bo pred negativnimi vrednostmi in bo vedno dovolj za niz katere koli velikosti.
• 2. Ne pozabite, da se niz začne od nič.
• 3. Zadnji element matrike ima indeks (velikost matrike je 1)

Ni popolnih načinov za preverjanje, ali smo presegli meje matrike ali ne. Zato ali natančno poznamo njegovo velikost ali pa ga shranimo v spremenljivko in ga po potrebi preberemo.

Primeri

Tukaj je nekaj tipičnih primerov dela z nizi
1. Obrnite niz.

#vključi #vključi //To je makro. SIZE v kodi bo nadomeščen z 10u #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); nepredznačeni i, j; // števci unsigned half; //sredina matrike unsigned tmp; //začasna spremenljivka za izmenjavo vrednosti half = SIZE / 2; //En števec gre od leve proti desni, drugi od desne proti levi za (i = 0, j = VELIKOST - 1; i< half; i++, j--) { tmp = A[i]; A[i] = A[j]; A[j] = tmp; } for (i = 0; i < SIZE; i++) { printf("%d ", A[i]); } getch(); }

Tukaj je dizajn, ki ga ne poznate

#define VELIKOST 10u

makro. V celotni kodi bo predprocesor samodejno zamenjal vse pojavitve SIZE z 10u.
2. Brisanje elementa, ki ga je izbral uporabnik.

#vključi #vključi #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); unsigned i; //števec int indeks; //indeks, ki ga vnese uporabnik / /Izhodna matrika za (i = 0; i< SIZE; i++) { printf("(%d)=%d ", i, A[i]); } //Просим пользователя ввести валидный индекс while (1) { printf("\nEnter index of element to delete "); scanf("%d", &index); if (index >0 && indeks< SIZE) { break; } } //Копируем следующий элемент массива на место удаляемого //и так до конца for (i = index; i < SIZE-1; i++) { A[i] = A; } //Выводим результат for (i = 0; i < SIZE-1; i++) { printf("(%d)=%d ", i, A[i]); } getch(); }

V tem primeru se element seveda ne izbriše. Niz ostaja enake velikosti kot prej. Element, ki ga brišemo, preprosto prepišemo z naslednjim in izpišemo elemente SIZE-1.
3. Uporabnik vnese vrednosti v matriko. Po tem natisnite vse različne vrednosti, ki jih je vnesel.
Naj uporabnik vnese končno število elementov, recimo 10. Potem je vnaprej znano, da ne bo skupaj več kot 10 različnih vrednosti. Vsakič, ko uporabnik vnese število, bomo šli skozi matriko in preverili ali je bila takšna številka vpisana.

#vključi #vključi #define SIZE 10u void main() ( int A = (0); unsigned i, j; int counter = 1; //koliko različnih števil je vnesenih. Vsaj ena. int input; int wasntFound; //zastavica, da vnesena številka ni bila najdena //Vnesite prvo številko. Še ni bila najdena. printf("0. "); scanf("%d", &A); for (i = 1; i< SIZE; i++) { printf("%d. ", i); scanf("%d", &input); wasntFound = 1; //Проверяем, встречалось ли такое число. Если да, //то выставляем флаг и выходим из цикла for (j = 0; j <= counter; j++) { if (input == A[j]) { wasntFound = 0; break; } } //Если флаг был поднят, то заносим число в массив if (wasntFound) { A = input; counter++; } } for (i = 0; i < counter; i++) { printf("%d ", A[i]); } getch(); }

4. Uporabnik vnese številko - število meritev (od 2 do 10). Po tem vnese vse meritve. Program prikaže povprečno vrednost, varianco in napako.

#vključi #vključi #vključi #define SIZE 20u void main() ( //Koeficienti študenta se začnejo z dvema dimenzijama const float student = (12.7, 4.3, 3.2, 2.8, 2.6, 2.4, 2.4, 2.3, 2.3); float A; unsigned i; unsigned limit; float tmp; float sum = .0f; float mean; float disp; float absError; float relError; do ( printf("Vnesite število meritev "); scanf("%u", &limit); if (limit > 1 && limit< 11) { break; } } while(1); for (i = 0; i < limit; i++) { printf("#%d: ", i); scanf("%f", &A[i]); sum += A[i]; } mean = sum / (float)limit; sum = .0f; for (i = 0; i < limit; i++) { tmp = A[i] - mean; sum += tmp * tmp; } disp = sum / (float)limit; absError = student * sqrt(sum / (float)(limit - 1)); relError = absError / mean * 100; printf("Mean = %.6f\n", mean); printf("Dispertion = %.6f\n", disp); printf("Abs. Error = %.6f\n", absError); printf("Rel. Error = %.4f%", relError); getch(); }

5. Razvrščanje v obliki mehurčkov

#vključi #vključi #define SIZE 10 #define false 0 #define true !false void main() ( float a = (1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 0.0) f); float tmp; unsigned i, j; char zastavica; //Izdaj matriko za (i = 0; i< SIZE; i++) { printf("%.3f ", a[i]); } printf("\n"); //Пока массив не отсортирован do { flag = false; //Проходим по массиву. Если следующий элемент больше предыдущего, то //меняем их местами и по новой проверяем массив for (i = 1; i < SIZE; i++) { if (a[i] >a) ( tmp = a[i]; a[i] = a; a = tmp; flag = true; ) ) ) medtem ko(flag == true); //Izpis razvrščene matrike za (i = 0; i< SIZE; i++) { printf("%.3f ", a[i]); } getch(); }

6. Zmešajte niz. Za to uporabimo algoritem

Začasno ustavite AdBlock na tem spletnem mestu.

Niz je najpreprostejši sestavljeni podatkovni tip. Ko smo razpravljali o spremenljivkah, smo imeli dobro analogijo s škatlo. Vrnimo se k njej. Če je spremenljivka ena škatla, potem je matrika več oštevilčenih enakih škatel, ki imajo isto ime in se razlikujejo le po zaporedni številki.

Slika 1 Spremenljivke in nizi. Analogija s škatlami.

Zgornja slika prikazuje tri nize:

• 8-elementno niz celih števil z imenom arr_int
• float niz 11 elementov z imenom arr_float
• 6-elementno niz znakov z imenom arr_char

Matrika ima tako kot spremenljivka svoje ime in vrsto podatkov. Poleg tega ima matrika še eno dodatno značilnost - velikost matrike. Velikost matrike je število elementov, ki jih je mogoče shraniti v njej. V naši analogiji s škatlami je to število škatel.

Opomba!

Številčenje elementov niza se začne od nič, ne od ena.

Deklaracija in inicializacija matrike

Deklaracija matrike je zelo podobna deklaraciji spremenljivke. Edina razlika je v tem, da morate dodatno navesti velikost polja v oglatih oklepajih. Tukaj je nekaj primerov:

Seznam 1.

Int arr_int; dvojno arr_float; float številka;

Ime matrike je podvrženo omejitvam, podobnim tistim, ki veljajo za ime spremenljivke.

Pravilo poimenovanja matrike

Ime matrike je katero koli zaporedje znakov, številk in podčrtaja »_«, ki se začne s črko. Velike črke so pomembne.

Tukaj je še nekaj primerov deklaracij matrike:

Seznam 2.

Int ocene, vrstni red; dvojne cene;

Matriki, tako kot vsaki spremenljivki, lahko dodelimo začetne vrednosti, ko jo deklariramo. Če elementom matrike ni dodeljena nobena vrednost, bodo shranjevali smeti, tako kot navadne spremenljivke.

Seznam 3.

Int arr_int = (2, 5, 5, 3, 4); dvojni arr_float = (1,2, -2,3, 4,5, 3,83, 0,01, -0,12, 44,2, 123,7, 23,44, -3,7, 7);

Če morate vsem elementom matrike dodeliti ničelne vrednosti, lahko to storite takole:

Seznam 4.

Dvojni arr = (0);

Delo s posameznimi elementi polja

Če se želite sklicevati na posamezen element polja, morate zapisati njegovo ime in zaporedno številko v oglatih oklepajih. Ne pozabite, da se številčenje začne od nič, ne od ena.

Recimo, da na zaslonu prikažemo elemente matrike s petimi elementi.

Seznam 5.

#vključi int main(void)( int arr = (2, 4, 3, 5, 5); printf("%d %d %d %d %d\n",arr, arr, arr, arr, arr); return (0); )

Seveda, če je niz zelo velik, potem je izpis element za elementom na ta način še vedno užitek. In tega nihče ne počne z majhnimi nizi. Bolje in pravilneje je uporabljati zanke. Na primer:

Seznam 6.

#vključi int main(void)( int arr = (0); for(int i = 0; i< 100; i = i + 1){ arr[i] = 2*i; } for(int i = 0; i < 100; i = i + 1){ printf("%d\t",arr[i]); } return(0); }

Program v prvi zanki prvih sto sodih števil shrani v matriko, v drugi zanki pa jih prikaže na zaslonu.

Oboroženi z našimi novimi orodji, prepišimo naš program z začetka lekcije, tako da bo uporabljal matriko za shranjevanje statistike naključnih števil.

Seznam 7.

#vključi #vključi #vključi int main(void) ( srand(time(NULL)); int count = (0); int rand_number; for (int i = 0; i< 100000; i = i + 1){ rand_number = rand()%3; count = count + 1; } for(int i = 0; i < 3; i = i + 1){ printf("%d - %d\n", i, count[i]); } return 0; }

Bodite pozorni na tehniko, uporabljeno v tem programu.
Ničelni element matrike shrani število pojavitev števila 0, prvi element - število pojavitev števila 1, drugi element - število 2. To pomeni, da vam ustvarjeno število omogoča, da določite, kateremu elementu matrike ga morate dodati. Zato ni potrebe po izjavi o izbiri stikala. Priročno, kajne?

Kaj so nizi v C?

Kako deklarirati nize v C?

Kako inicializirati nize v C?

Nizi v C za lutke.

Nizi v C

Matrika v C je zbirka elementov istega tipa, do katerih je mogoče dostopati z indeksom. Elementi nizov v C se nahajajo drug za drugim v pomnilniku računalnika.

Preprost primer ustvarjanja in polnjenja matrike v C:

// @author Subbotin B.P..h> void main(void) ( int nArr; nArr = 1; nArr = 2; nArr = 3; printf("\n\tArray\n\n"); printf("nArr\t =\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); vrni 0 ;)

Dobimo:

V primeru deklariramo matriko, ki vsebuje elemente tipa int:

tukaj je ime matrike nArr, število elementov matrike je tri, tip elementa matrike je int.

Niz je zbirka elementov. Na vsak element matrike se lahko sklicujemo po njegovi številki. Število običajno imenujemo indeks. Elementi niza so oštevilčeni od nič. Dodelimo vrednost prvemu elementu matrike in prvi element ima indeks nič:

Dodelimo vrednost drugemu elementu matrike in drugi element ima indeks ena:

Dodelimo vrednost tretjemu elementu matrike in tretji element ima indeks dva:

Ko elemente polja prikažemo na zaslonu, dobimo njihove vrednosti. Všečkaj to:

printf("nArr\t=\t%d\n", nArr);

Če želite pridobiti element matrike, morate podati ime matrike in indeks elementa:

To je prvi element matrike, ker ima prvi element indeks nič.

Priredimo vrednost tretjega elementa matrike spremenljivki int a:

indeks tretjega elementa matrike je enak dve, saj se indeksi štejejo od nič.

Zdaj pa splošno pravilo za deklariranje nizov v C: ko deklarirate niz, morate navesti njegovo ime, vrsto elementov in število elementov. Število elementov je naravno število, tj. vse je pozitivno. Nič ne more biti število elementov. Ne morete določiti spremenljivega števila elementov polja. Tu so primeri deklaracij matrike v C:

int nArr; // Za matriko je bilo deklarirano, da vsebuje sto celih števil;
float fArr; // Matrika, zasnovana za shranjevanje 5 števil s plavajočim delom, je bila deklarirana;
char cArr; // Matrika je bila deklarirana za shranjevanje dveh znakov;

Napačno bi bilo deklarirati matriko s spremenljivim številom elementov:

Int varElem;
int nArr; // Napaka! Število elementov ni mogoče nastaviti na spremenljivko;

Lahko pa nastavite število elementov s konstantno vrednostjo: neposredno pozitivno celo število 1, 2, 3 ... ali konstanto:

Const int arrayLength = 3;
int nArr;

Ko deklarirate matriko v C, jo lahko takoj inicializirate:

int nMassiv = (1, 2, 3);

Število elementov polja v oglatih oklepajih lahko izpustite, če so vsi elementi polja inicializirani:

int nMassiv = (1, 2, 3);

število elementov bo v tem primeru samodejno določeno.

Ko deklarirate matriko, lahko definirate le del elementov:

int nMassiv = (1, 2);

v tem primeru sta prva dva elementa matrike inicializirana, tretji pa je nedefiniran.

Primer niza znakov:

char cArr = ("S", "B", "P");

Ko deklarirate matriko, ne morete določiti števila elementov spremenljivke. Lahko pa uporabite spremenljivke pri dostopu do elementov polja:

Int ind = 0;
char cr = cArr;

To se uporablja pri delu z zankami. primer:

// @author Subbotin B.P..h> void main(void) ( const int arrayLength = 3; int nArr; for(int inn = 0; inn< 3; inn++) { nArr = inn + 1; } printf("\n\tArray\n\n"); for(int inn = 0; inn < 3; inn++) { printf("nArr[%d]\t=\t%d\n", inn, nArr); } return 0; }

V primeru v prvi zanki zapolnimo matriko z elementi tipa int, v drugi zanki pa te elemente prikažemo na zaslonu.

Zadnja posodobitev: 17.09.2017

Niz predstavlja nabor podatkov iste vrste. Formalna definicija matrike je naslednja:

Vrsta_spremenljivke ime_matrike [dolžina_matrike]

Za tipom spremenljivke sledi ime matrike in nato njena velikost v oglatih oklepajih. Na primer, definirajmo niz 4 števil:

Int številke;

Ta niz ima štiri števila, vendar imajo vsa ta števila nedefinirano vrednost. Vendar pa lahko izvedemo inicializacijo in dodelimo nekaj začetnih vrednosti tem številkam prek zavitih oklepajev:

Int števila = (1,2,3,4);

Vrednosti v zavitih oklepajih se imenujejo tudi inicializatorji. Če je inicializatorjev manj, kot je elementov v matriki, se inicializatorji uporabijo za prve elemente. Če je v matriki več inicializatorjev kot elementov, bo med prevajanjem prišlo do napake:

Celotna števila = (1, 2, 3, 4, 5, 6);

Tukaj ima matrika velikost 4, vendar se ji posreduje 6 vrednosti.

Če velikost matrike ni eksplicitno podana, se izpelje iz števila inicializatorjev:

Celotna števila = (1, 2, 3, 4, 5, 6);

V tem primeru ima niz 6 elementov.

Inicializacija znakovnih nizov ima svoje posebnosti. Matriki znakov lahko posredujemo nabor inicializatorjev in niz:

Char s1 = ("h", "e", "l", "l", "o"); char s2 = "svet";

Poleg tega v drugem primeru matrika s2 ne bo imela 5 elementov, ampak 6, saj se ob inicializaciji z nizom ničelni znak "\0" samodejno doda matriki znakov.

V tem primeru dodeljevanje ene matrike drugi matriki ni dovoljeno:

Int nums1 = (1,2,3,4,5); int nums2 = nums1; // napaka nums2 = nums1; // napaka

Ko je matrika definirana, lahko do njenih posameznih elementov dostopamo po indeksu. Indeksi se začnejo pri nič, zato moramo za dostop do prvega elementa uporabiti indeks 0. Z dostopom do elementa po indeksu lahko pridobimo njegovo vrednost ali jo spremenimo:

#vključi int main() ( int numbers = (1,2,3,4); int first_number = numbers; std::cout<< first_number << std::endl; // 1 numbers = 34; // изменяем элемент std::cout << numbers << std::endl; // 34 return 0; }

Število elementov polja je mogoče določiti tudi s konstanto:

Const int n = 4; int števila [n] = (1,2,3,4);

Ponavljanje po nizih

Z uporabo zank lahko ponavljate celotno matriko in dostopate do njenih elementov prek indeksov:

#vključi int main() ( int numbers = (1,2,3,4); int size = sizeof(numbers)/sizeof(numbers); for(int i=0; i< size; i++) std::cout << numbers[i] << std::endl; return 0; }

Za zanko po matriki morate najprej najti dolžino matrike. Operator sizeof se uporablja za iskanje dolžine. V bistvu je dolžina niza enaka skupni dolžini njegovih elementov. Vsi elementi predstavljajo isto vrsto in zasedajo enako velikost v pomnilniku. Zato z izrazom sizeof(numbers) poiščemo dolžino celotne matrike v bajtih, z izrazom sizeof(numbers) pa dolžino enega elementa v bajtih. Z delitvijo obeh vrednosti lahko dobite število elementov v matriki. In nato z uporabo zanke for ponavljamo vse elemente, dokler števec i ne postane enak dolžini niza. Posledično bodo vsi elementi matrike prikazani na konzoli:

Obstaja pa tudi druga oblika zanke for, ki je zasnovana posebej za delo z zbirkami, vključno z nizi. Ta obrazec ima naslednjo formalno definicijo:

Za (tip spremenljivke: zbirka) ( navodila; )

Ta obrazec uporabljamo za ponavljanje skozi matriko:

#vključi int main() ( int numbers = (1,2,3,4); for(int number: numbers) std::cout<< number << std::endl; return 0; }

Pri ponavljanju skozi matriko bo vsak element, ki ga ponovimo, postavljen v številsko spremenljivko, katere vrednost se natisne na konzolo v zanki.

Če ne poznamo vrste objektov v matriki, lahko za določitev vrste uporabimo samodejni specifikator:

Za (samodejno število: števila) std::cout<< number << std::endl;

Večdimenzionalni nizi

Poleg enodimenzionalnih nizov v C++ obstajajo tudi večdimenzionalni. Elementi takih nizov so sami po sebi nizi, v katerih so elementi lahko tudi nizi. Na primer, definirajmo dvodimenzionalni niz števil:

Int številke;

Tak niz je sestavljen iz treh elementov, pri čemer vsak element predstavlja niz dveh elementov. Inicializirajmo matriko, kot je ta:

Int števila = ( (1, 2), (4, 5), (7, 8) );

Ugnezdeni zavit oklepaj označuje elemente za vsako podmatriko. Takšen niz je lahko predstavljen tudi kot tabela:

1	2
4	5
7	8

Med inicializacijo lahko tudi izpustite zavite oklepaje:

Int števila = ( 1, 2, 4, 5, 7, 8 );

Možno je tudi inicializirati ne vse elemente, ampak samo nekatere:

Int števila = ( (1, 2), (), (7) );

Za dostop do elementov ugnezdene matrike potrebujete dva indeksa:

Int števila = ( (1, 2), (3, 4), (5, 6) ); std::cout<< numbers << std::endl; // 3 numbers = 12; // изменение элемента std::cout << numbers << std::endl; // 12

Ponovimo čez dvodimenzionalni niz:

#vključi int main() ( const int vrstice = 3, stolpci = 2; int števila = ( (1, 2), (3, 4), (5, 6) ); for(int i=0; i< rows; i++) { for(int j=0; j < columns; j++) { std::cout << numbers[i] [j] << "\t"; } std::cout << std::endl; } return 0; }

Za ponavljanje elementov večdimenzionalne matrike lahko uporabite tudi drugo obliko zanke for:

#vključi int main() ( const int vrstice = 3, stolpci = 2; int številke = ( (1, 2), (3, 4), (5, 6) ); for(samodejno &podštevilke: številke) ( for(int številka : podštevilke) ( std::cout<< number << "\t"; } std::cout << std::endl; } return 0; }

Za ponavljanje matrik, ki so vključene v matriko, se uporabljajo reference. To pomeni, da v zunanji zanki for(auto &subnumbers: numbers) &subnumbers predstavlja sklic na podmatriko v matriki. V notranji zanki for(int number: subnumbers) iz vsake podmatrike v podštevilah dobimo njene posamezne elemente v spremenljivko števila in njeno vrednost izpišemo na konzolo.