Nastavimo učiti osnove C++. U ovom ćemo članku pogledati nizove.

Nizovi vam omogućuju pohranjivanje velikih količina podataka u prikladnom formatu. Zapravo, niz je varijabla koja pohranjuje više vrijednosti pod jednim imenom, ali svakoj vrijednosti je dodijeljen vlastiti indeks. je popis vrijednosti kojima se indeksi koriste za pristup.

Uvod u nizove

Možete vizualizirati niz ovako:

Ovo je skup nekih vrijednosti koje su pohranjene jedna za drugom, pod istim imenom. Da biste dobili te vrijednosti, ne morate kreirati nove varijable, samo trebate naznačiti indeks pod kojim je vrijednost pohranjena u nizu. Na primjer, morate podijeliti set od pet igraćih karata za poker, te karte možete pohraniti u niz i promijeniti samo indeksni broj za odabir nove karte, umjesto korištenja nove varijable. To će vam omogućiti da koristite isti kod za inicijalizaciju svih kartica i prijeđete s pisanja ovako:

Kartica1 = getRandomCard(); Kartica2 = getRandomCard(); Kartica3 = getRandomCard(); Kartica4 = getRandomCard(); Kartica5 = getRandomCard();

Za (int i = 0; i< 5; i++) { card[i] = getRandomCard(); }

Sada zamislite razliku ako postoji 100 varijabli!

Sintaksa

Da biste deklarirali polje, trebate navesti dvije stvari (osim imena): vrstu i veličinu polja:

Int moj_niz[ 6 ];

Ovaj redak deklarira niz od šest cjelobrojnih vrijednosti. Imajte na umu da je veličina polja u uglatim zagradama iza naziva polja.

Za pristup elementima niza koristite uglate zagrade, ali ovaj put navodite indeks elementa kojem želite pristupiti:

Moj_niz[ 3 ];

Ovaj proces možete vizualizirati ovako:

my_array se odnosi na cijeli niz, dok se my_array odnosi samo na prvi element, my_array se odnosi na četvrti. imajte na umu da indeksiranje elementi u nizu počinju od 0. Stoga će se pristup elementima niza uvijek odvijati s pomakom, na primjer:

Int moj_niz[ 4 ]; // deklaracija niza my_array[ 2 ] = 2; // postavite vrijednost trećeg (naime trećeg!) na 2

Deklariranje višedimenzionalnih nizova u C++

Nizovi se također mogu koristiti za predstavljanje višedimenzionalnih podataka, poput šahovske ploče ili tic-tac-toe ploče. Kada koristite višedimenzionalne podatke, višestruki indeksi koristit će se za pristup elementima niza.

Da biste deklarirali dvodimenzionalni niz, morate navesti dimenziju dviju dimenzija:

Int tic_tac_toe_board;

Vizualizacija niza s indeksima njegovih elemenata:

Za pristup elementima takvog niza trebat će vam dva indeksa - jedan za redak, a drugi za stupac. Slika prikazuje potrebne indekse za pristup svakom od elemenata.

Korištenje polja

Kada koristite nizove, ne možete bez . Da biste prošli kroz petlju, jednostavno inicijalizirate varijablu na nulu i povećavate je sve dok ne premaši veličinu niza - uzorak kao pravi za petlju.

Sljedeći program demonstrira upotrebu petlje za stvaranje tablice množenja i pohranjivanje rezultata u dvodimenzionalnom polju:

#uključi korištenje imenskog prostora std; int main() ( int array; // Deklarirajte niz koji izgleda kao šahovska ploča za (int i = 0; i< 8; i++) { for (int j = 0; j < 8; j++) { array[i][j] = i * j; // Задаем значения каждого элемента } } cout << "Multiplication table:\n"; for (int i = 0; i < 8; i++) { for (int j = 0; j < 8; j++) { cout << "[ " << i << " ][ " << j << "] = "; cout << array[i][j] << " "; cout << "\n"; } } }

Prijenos nizova funkcijama

Kao što vidite, različiti elementi jezika C++ međusobno djeluju. Kao i s petljama, nizovi se mogu koristiti u kombinaciji s .

Da biste prenijeli niz funkciji, jednostavno navedite njezin naziv:

Int vrijednosti[ 10 ]; zbroj_niza(vrijednosti);

A kada deklarirate funkciju, navedite niz kao argument:

Int sum_array(int vrijednosti);

Imajte na umu da ne navodimo dimenziju niza u argumentima funkcije, to je normalno za jednodimenzionalne nizove, nema potrebe za specificiranjem dimenzije. Veličina mora biti naznačena kada deklariranje nizova , jer Prevodilac mora znati koliko memorije treba dodijeliti. Kada prelazimo na funkciju, jednostavno prosljeđujemo postojeći niz; nema potrebe za navođenjem veličine, jer Ne stvaramo novi. Jer prosljeđujemo niz funkciji, unutar funkcije možemo promijeniti, za razliku od jednostavnih varijabli koje se prosljeđuju po vrijednosti i promjena ove vrijednosti unutar funkcije neće ni na koji način utjecati na izvornu varijablu.

Budući da ne znamo veličinu polja unutar funkcije, trebamo proslijediti dimenziju kao drugi argument:

Int sumArray(int vrijednosti, int veličina) ( int sum = 0; for (int i = 0; i< size; i++) { sum += values[ i ]; } return sum; }

Kada prosljeđujemo višedimenzionalne nizove, moramo navesti sve dimenzije osim prve:

Int check_tic_tac_toe(int ploča);

Možete, naravno, navesti prvu dimenziju, ali ona će biti zanemarena.

O ovoj temi će se detaljnije govoriti u članku o pokazivačima.

Za sada napišimo funkciju koja izračunava zbroj elemenata niza:

#uključi korištenje imenskog prostora std; int sumArray(int values, int size) ( int sum = 0; // petlja će se zaustaviti kada je i == size, jer je indeks zadnjeg elementa = size - 1 for (int i = 0; i< size; i++) { sum += values[i]; } return sum; } int main() { int values; for (int i = 0; i < 10; i++) { cout << "Enter value "<< i <<": "; cin >> vrijednosti[i]; ) cout<< sumArray(values, 10) << endl; }

Sortiraj niz

Riješimo problem sortiranja niza od 100 brojeva koje je unio korisnik:

#uključi korištenje imenskog prostora std; int main() ( int values[ 100 ]; for (int i = 0; i< 100; i++) { cout << "Enter value "<< i <<": "; cin >> vrijednosti[ i ]; ) )

Gotovo, sve što je preostalo je sortirati ovaj niz :) Kako ljudi obično sortiraju nizove? U njemu traže najmanji element i stavljaju ga na vrh liste. Zatim traže sljedeću minimalnu vrijednost i stavljaju je odmah iza prve, i tako dalje.

Cijela ova stvar izgleda kao ciklus: prolazimo nizom, počevši od prvog elementa i tražimo minimalnu vrijednost u preostalom dijelu, te mijenjamo te elemente. Počnimo s pisanjem koda za izvođenje ovih operacija:

Void sort(int array, int size) ( for (int i = 0; i< size; i++) { int index = findSmallestRemainingElement(array, size, i); swap(array, i, index); } }

Sada možete razmisliti o implementaciji dviju pomoćnih metoda, findSmallestRemainingElement i swap. Metoda findSmallestRemainingElement mora iterirati kroz niz i pronaći najmanji element, počevši od indeksa i:

Int findSmallestRemainingElement(int array, int size, int index) ( int index_of_mallest_value = index; for (int i = index + 1; i< size; i++) { if (array[ i ] < array[ index_of_smallest_value ]) { index_of_smallest_value = I; } } return index_of_smallest_value; }

Konačno, moramo implementirati funkciju zamjene. Budući da će funkcija modificirati izvorni niz, samo trebamo zamijeniti vrijednosti pomoću privremene varijable:

Void swap(int array, int first_index, int second_index) ( int temp = array[ first_index ]; array[ first_index ] = array[ second_index ]; array[ second_index ] = temp; )

Da biste testirali algoritam, ispunite polje nasumičnim brojevima i sortirajte ga. Sav programski kod:

#uključi #uključi #uključi korištenje imenskog prostora std; int pronađiNajmanjiPreostaliElement(int niz, int veličina, int indeks); void swap(int niz, int prvi_indeks, int drugi_indeks); void sort(int niz, int veličina) ( for (int i = 0; i< size; i++) { int index = findSmallestRemainingElement(array, size, i); swap(array, i, index); } } int findSmallestRemainingElement(int array, int size, int index) { int index_of_smallest_value = index; for (int i = index + 1; i < size; i++) { if (array[ i ] < array[ index_of_smallest_value ]) { index_of_smallest_value = i; } } return index_of_smallest_value; } void swap(int array, int first_index, int second_index) { int temp = array[ first_index ]; array[ first_index ] = array[ second_index ]; array[ second_index ] = temp; } // вспомогательная функция для вывода массива void displayArray(int array, int size) { cout << "{"; for (int i = 0; i < size; i++) { // если элемент не первый выведем запятую if (i != 0) { cout << ", "; } cout << array[ i ]; } cout << "}"; } int main() { int array[ 10 ]; srand(time(NULL)); for (int i = 0; i < 10; i++) { array[ i ] = rand() % 100; } cout << "Original array: "; displayArray(array, 10); cout << "\n"; sort(array, 10); cout << "Sorted array: "; displayArray(array, 10); cout << "\n"; }

Algoritam sortiranja koji smo upravo pogledali zove se sortiranje umetanjem , ovo nije najbrži algoritam, ali ga je lako razumjeti i implementirati. Ako morate sortirati velike količine podataka, bolje je koristiti složenije i brže algoritme.

Niz je struktura podataka predstavljena kao grupa ćelija iste vrste, ujedinjenih pod jednim imenom. Nizovi se koriste za obradu velikih količina podataka iste vrste. Ime niza je ono što su pokazivači, reći ću vam malo kasnije. Pojedinačna podatkovna ćelija niza naziva se element niza. Elementi niza mogu biti podaci bilo koje vrste. Nizovi mogu imati jednu ili više od jedne dimenzije. Ovisno o broju dimenzija, nizovi se dijele na jednodimenzionalne nizove, dvodimenzionalne nizove, trodimenzionalne nizove i tako dalje do n-dimenzionalnog niza. U programiranju se najčešće koriste jednodimenzionalni i dvodimenzionalni nizovi, pa ćemo razmatrati samo te nizove.

Jednodimenzionalni nizovi u C++

Jednodimenzionalni niz je niz s jednim parametrom koji karakterizira broj elemenata jednodimenzionalnog niza. Zapravo, jednodimenzionalni niz je niz koji može imati samo jedan redak i n broj stupaca. Stupci u jednodimenzionalnom nizu su elementi niza. Slika 1 prikazuje strukturu cjelobrojnog jednodimenzionalnog niza a. Veličina ovog polja je 16 ćelija.

Slika 1 - Nizovi u C++

Imajte na umu da je maksimalni indeks jednodimenzionalnog niza a je 15, ali je veličina niza 16 ćelija, jer numeriranje ćelija niza uvijek počinje od 0. Indeks ćelije je nenegativan cijeli broj pomoću kojeg možete pristupiti svakoj ćeliji niza i izvršiti bilo kakve radnje na njoj ( ćelija).

//sintaksa za deklaraciju jednodimenzionalnog niza u C++: /*tip podataka*/ /*ime jednodimenzionalnog niza*/; //primjer deklaracije jednodimenzionalnog niza prikazan na slici 1: int a;

gdje je int cijeli broj;

A je naziv jednodimenzionalnog niza;
16 je veličina jednodimenzionalnog niza, 16 ćelija.

Uvijek odmah iza imena niza nalaze se uglate zagrade u kojima se navodi veličina jednodimenzionalnog niza; to je ono što razlikuje niz od svih ostalih varijabli.

//još jedan način za deklariranje jednodimenzionalnih nizova int mas, a;

Dva jednodimenzionalna niza mas i a deklarirana su veličinama 10 odnosno 16. Štoviše, u ovoj metodi deklaracije, svi nizovi će imati isti tip podataka, u našem slučaju - int.

// nizovi se mogu inicijalizirati kada su deklarirani: int a = ( 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // inicijalizacija jednodimenzionalnog niza

Inicijalizacija jednodimenzionalnog niza izvodi se u vitičastim zagradama iza znaka jednaki, svaki element niza odvojen je od prethodnog zarezom.

Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); // inicijaliziranje niza bez određivanja njegove veličine.

U ovom slučaju, prevodilac će sam odrediti veličinu jednodimenzionalnog niza. Veličina niza se može izostaviti samo kada ga inicijalizirate; kada deklarirate niz normalno, veličina niza mora biti navedena. Razvijmo jednostavan program za obradu jednodimenzionalnog niza.

// array.cpp: Definira ulaznu točku za konzolnu aplikaciju. #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; }

// kod Kod::Blokovi

// Dev-C++ kod

// array.cpp: Definira ulaznu točku za konzolnu aplikaciju. #uključi korištenje imenskog 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; }

U retke 10 - 11 Deklariran je i inicijaliziran cjelobrojni jednodimenzionalni niz imena array1 čija je veličina 16 ćelija, odnosno takav niz može pohraniti 16 brojeva. Bilo kakva obrada polja moguća je samo u kombinaciji s petljama. Koju petlju odabrati za obradu niza ovisi o vama. Ali najprikladniji je za ovaj zadatak. Za pristup elementima jednodimenzionalnog niza array1 koristit ćemo se counter varijablom counter. Uvjet nastavka for petlje sadrži strogi znak nejednakosti, jer ne postoji šesnaesti indeks u jednodimenzionalnom nizu array1. A budući da numeriranje ćelija počinje od nule, u tijelu petlje for postoji 16 elemenata, operator cout ispisuje elemente jednodimenzionalnog niza (vidi sliku 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 nastavak pritisnite bilo koju tipku. . .

Slika 2 - Nizovi u C++

Razvijmo još jedan program za obradu jednodimenzionalnog niza u C++. Program mora sekvencijalno pročitati deset unesenih brojeva s tipkovnice. Svi uneseni brojevi se zbrajaju i rezultat se prikazuje na ekranu.

// array_sum.cpp: Definira ulaznu točku za konzolnu aplikaciju. #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; }

// kod Kod::Blokovi

// Dev-C++ kod

// array_sum.cpp: Definira ulaznu točku za konzolnu aplikaciju. #uključi korištenje imenskog prostora std; int main(int argc, char* argv) ( int array1; // deklarira niz cjelobrojnih brojeva cout<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> niz1; // čitanje brojeva unesenih s tipkovnice 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; }

Prije obrade polja potrebno ga je deklarirati, a veličina jednodimenzionalnog niza je 10, što je i određeno uvjetom zadatka. U varijabli zbroj akumulirati ćemo zbroj elemenata jednodimenzionalnog niza. Prva for petlja ispunjava deklarirani jednodimenzionalni niz brojevima unesenim s tipkovnice, retke 12 - 13. Varijabla brojača koristi se za sekvencijalni pristup elementima jednodimenzionalnog niza array1, počevši od indeksa 0 do i uključujući 9-ti. Druga for petlja prikazuje elemente niza, retke 15 - 16. Treća for petlja sekvencijalno čita elemente jednodimenzionalnog niza i zbraja ih, zbroj se akumulira u varijabli sum. redovi 17 - 18. Rezultat programa prikazan je na slici 3.

Unesite elemente massiva: 0 1 2 3 4 5 6 7 8 9 array1 = (0 1 2 3 4 5 6 7 8 9 ) zbroj = 45 Za nastavak pritisnite bilo koju tipku. . .

Slika 3 - Nizovi u C++

Najprije je redom uneseno svih 10 brojeva, nakon čega je prikazan jednodimenzionalni niz, te je ispisan zbroj brojeva u nizu.

Dvodimenzionalni nizovi u C++

Do ove točke razmatrali smo jednodimenzionalne nizove na koje se ne može uvijek ograničiti. Recimo da trebate obraditi neke podatke iz tablice. Tablica ima dvije karakteristike: broj redaka i broj stupaca. Također u dvodimenzionalnom nizu, pored broja elemenata niza, postoje karakteristike kao što su broj redaka i broj stupaca dvodimenzionalnog niza. To jest, vizualno, dvodimenzionalni niz je pravilna tablica, s redovima i stupcima. Zapravo, dvodimenzionalni niz je jednodimenzionalni niz jednodimenzionalnih nizova. Struktura dvodimenzionalnog niza, nazvanog a, veličine m puta n prikazana je dolje (vidi sliku 4).

Slika 4 - Nizovi u C++

gdje je m broj redaka dvodimenzionalnog niza;
n je broj stupaca dvodimenzionalnog niza;
m * n — broj elemenata niza.

// sintaksa za deklariranje dvodimenzionalnog niza /*tip podataka*/ /*ime niza*/;

Kod deklaracije dvodimenzionalnog niza, kao i kod deklaracije jednodimenzionalnog niza, prije svega potrebno je navesti:

• tip podataka;
• ime polja.

Nakon toga prve uglate zagrade označavaju broj redaka dvodimenzionalnog niza, a druge uglate zagrade označavaju broj stupaca dvodimenzionalnog niza. Dvodimenzionalni niz se vizualno razlikuje od jednodimenzionalnog po drugom paru uglatih zagrada. Pogledajmo primjer deklaracije dvodimenzionalnog niza. Recimo da trebamo deklarirati dvodimenzionalni niz s brojem elemenata jednakim 15. U ovom slučaju, dvodimenzionalni niz može imati tri reda i pet stupaca ili pet redaka i tri stupca.

// primjer deklaracije dvodimenzionalnog niza: int a;

• a je naziv niza cijelih brojeva
• broj u prvim uglatim zagradama označava broj redaka dvodimenzionalnog niza, u ovom slučaju ih je 5;
• broj u drugoj uglatoj zagradi označava broj stupaca dvodimenzionalnog niza, u ovom slučaju ih je 3.

// inicijalizacija dvodimenzionalnog niza: int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1) );

Ovaj niz ima 5 redaka, 3 stupca. iza znaka dodijeli stavljaju se opće vitičaste zagrade unutar kojih se stavlja onoliko pari vitičastih zagrada koliko treba biti linija u dvodimenzionalnom nizu, a te se zagrade odvajaju zarezima. U svaki par vitičastih zagrada upišite elemente dvodimenzionalnog niza odvojene zarezima. U svim vitičastim zagradama broj elemenata mora biti isti. Budući da niz ima pet redaka, postoji i pet unutarnjih parova zagrada. U unutarnjoj zagradi ispisana su tri elementa, jer je broj stupaca tri. Grafički, naš niz će izgledati kao dvodimenzionalna tablica (vidi sliku 5).

Slika 5 - Nizovi u C++

U svakoj ćeliji dvodimenzionalnog niza a prikazana vrijednost, adresa ove ćelije prikazana je u donjem desnom kutu. Adresa ćelije dvodimenzionalnog niza je naziv niza, broj retka i broj stupca.

Razvijmo jednostavan program za obradu dvodimenzionalnog niza, nazvan “Labirint”. Labirint mora biti izgrađen na temelju dvodimenzionalnog niza. Veličinu labirinta biramo prema vlastitom nahođenju.

// array2.cpp: Definira ulaznu točku za konzolnu aplikaciju. #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; }

// kod Kod::Blokovi

// Dev-C++ kod

// array2.cpp: Definira ulaznu točku za konzolnu aplikaciju. #uključi korištenje imenskog prostora std; int main(int argc, char* argv) ( // 1-uvjetno “zidovi labirinta” // 2-“ispravan put, izlaz iz labirinta” // 0-“lažni put” int mas = ( (1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // inicijalizacija dvodimenzionalnog niza ( 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,0,0,0, 0,0,1,) , (1,2,1,0,0,0,1,2,2,2,1,0,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,) ); // dvije petlje - unutarnja i vanjska, pristup svakom elementu niza 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; }

Točna i lažna staza mogu se označiti istim brojem, na primjer nulom, ali radi jasnoće, točna staza je označena brojem 2. Niz je inicijaliziran ručno, samo radi pojednostavljenja programa. Budući da program obrađuje dvodimenzionalni niz, potrebne su dvije petlje za prebacivanje između elemenata dvodimenzionalnog niza. Prva for petlja prebacuje se između redaka dvodimenzionalnog niza. Budući da postoje 33 retka u dvodimenzionalnom nizu, varijabla brojača i se povećava od 0 do 33, linija 46. Unutar prve petlje nalazi se for petlja koja kruži kroz elemente retka dvodimenzionalnog niza. U tijelu druge petlje for, unutra se izvodi operacija pretvorbe unarnog tipa podataka - static_cast<>() , koji ispisuje znak broj 176. Operacija pretvorbe tipa podataka se duplicira kako bi se povećala širina labirinta. Rezultat programa (vidi sliku 6).

Slika 6 - Nizovi u C++

Zadnja izmjena: 17.09.2017

Niz predstavlja skup podataka iste vrste. Formalna definicija niza je sljedeća:

Variable_type array_name [array_length]

Nakon tipa varijable dolazi naziv niza, a zatim njegova veličina u uglatim zagradama. Na primjer, definirajmo niz od 4 broja:

Int brojevi;

Ovaj niz ima četiri broja, ali svi ti brojevi imaju nedefiniranu vrijednost. Međutim, možemo izvršiti inicijalizaciju i dodijeliti neke početne vrijednosti ovim brojevima kroz vitičaste zagrade:

Int brojevi = (1,2,3,4);

Vrijednosti u vitičastim zagradama također se nazivaju inicijalizatori. Ako postoji manje inicijalizatora nego što ima elemenata u nizu, tada se inicijalizatori koriste za prve elemente. Ako ima više inicijalizatora nego elemenata u nizu, tada će se pojaviti pogreška tijekom kompilacije:

Int brojevi = (1, 2, 3, 4, 5, 6);

Ovdje niz ima veličinu 4, ali mu se prosljeđuje 6 vrijednosti.

Ako veličina niza nije eksplicitno navedena, ona se zaključuje iz broja inicijalizatora:

Int brojevi = (1, 2, 3, 4, 5, 6);

U ovom slučaju niz ima 6 elemenata.

Inicijalizacija nizova znakova ima svoje karakteristike. Možemo proslijediti i skup inicijalizatora i niz nizu znakova:

Znak s1 = ("h", "e", "l", "l", "o"); char s2 = "svijet";

Štoviše, u drugom slučaju, niz s2 neće imati 5 elemenata, već 6, jer kada se inicijalizira s nizom, nulti znak "\0" automatski se dodaje nizu znakova.

U ovom slučaju nije dopušteno dodjeljivanje jednog polja drugom polju:

Int nums1 = (1,2,3,4,5); int brojevi2 = brojevi1; // pogreška nums2 = nums1; // pogreška

Nakon što je niz definiran, njegovim pojedinačnim elementima možemo pristupiti pomoću indeksa. Indeksi počinju od nule, tako da za pristup prvom elementu moramo koristiti indeks 0. Pristupom elementu po indeksu možemo dobiti njegovu vrijednost ili je promijeniti:

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

Broj elemenata niza također se može odrediti preko konstante:

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

Ponavljanje nizova

Koristeći petlje, možete iterirati kroz cijeli niz i pristupiti njegovim elementima putem indeksa:

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

Da biste prošli kroz niz, prvo morate pronaći duljinu niza. Za pronalaženje duljine koristi se operator sizeof. U osnovi, duljina niza jednaka je ukupnoj duljini njegovih elemenata. Svi elementi predstavljaju isti tip i zauzimaju istu veličinu u memoriji. Stoga pomoću izraza sizeof(numbers) nalazimo duljinu cijelog niza u bajtovima, a pomoću izraza sizeof(numbers) nalazimo duljinu jednog elementa u bajtovima. Dijeljenjem dviju vrijednosti možete dobiti broj elemenata u nizu. Zatim, koristeći for petlju, ponavljamo kroz sve elemente dok brojač i ne postane jednak duljini niza. Kao rezultat toga, svi elementi niza bit će prikazani na konzoli:

Ali postoji i drugi oblik for petlje, koji je dizajniran posebno za rad sa kolekcijama, uključujući nizove. Ovaj obrazac ima sljedeću formalnu definiciju:

Za(tip varijable: zbirka) ( upute; )

Koristimo ovaj obrazac za ponavljanje niza:

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

Prilikom ponavljanja niza, svaka stavka koja se ponavlja bit će smještena u brojčanu varijablu, čija se vrijednost ispisuje na konzoli u petlji.

Ako ne znamo vrstu objekata u nizu, možemo upotrijebiti auto specifikator da odredimo vrstu:

Za(automatski broj: brojevi) std::cout<< number << std::endl;

Višedimenzionalni nizovi

Osim jednodimenzionalnih nizova, C++ ima i višedimenzionalne. Elementi takvih nizova sami su nizovi, u kojima elementi također mogu biti nizovi. Na primjer, definirajmo dvodimenzionalni niz brojeva:

Int brojevi;

Takav niz se sastoji od tri elementa, pri čemu svaki element predstavlja niz od dva elementa. Inicijalizirajmo niz ovako:

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

Ugniježđene vitičaste zagrade ocrtavaju elemente za svaku podnizu. Takav niz se također može predstaviti kao tablica:

1	2
4	5
7	8

Također možete izostaviti vitičaste zagrade tijekom inicijalizacije:

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

Također je moguće inicijalizirati ne sve elemente, već samo neke:

Int brojevi = ( (1, 2), (), (7) );

A za pristup elementima ugniježđenog niza potrebna su vam dva indeksa:

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

Iterirajmo preko dvodimenzionalnog niza:

#uključi int main() ( const int redaka = 3, stupaca = 2; int brojeva = ( (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; }

Također možete koristiti drugi oblik for petlje za ponavljanje kroz elemente višedimenzionalnog niza:

#uključi int main() ( const int redovi = 3, stupci = 2; int brojevi = ( (1, 2), (3, 4), (5, 6) ); for(auto &podbrojevi: brojevi) ( for(int broj : podbrojevi) ( std::cout<< number << "\t"; } std::cout << std::endl; } return 0; }

Za iteraciju nizova koji su uključeni u niz, koriste se reference. To jest, u vanjskoj petlji for(auto &podbrojevi: brojevi) &podbrojevi predstavljaju referencu podniza u nizu. U unutarnjoj petlji for(int number: subnumbers), iz svakog podniza u podbrojevima dobivamo njegove pojedinačne elemente u varijablu broja i ispisujemo njegovu vrijednost na konzolu.

Nizovi su dizajnirani za pohranjivanje više vrijednosti iste vrste. Na primjer, u programu Fahrenheit to Celsius izračunali smo prosječnu vrijednost temperature od tri. Ako ne postoje tri vrijednosti, već mnogo više, onda je to mjesto gdje trebate koristiti nizove.

Prije nego što možete koristiti polje, morate ga definirati. Definicija niza uključuje: vrstu podataka pohranjenih u nizu, naziv niza i broj elemenata niza u uglatim zagradama:

int polje;

U ovom kodu definirali smo niz s identifikatorom (name) niz od deset elemenata tipa int.
U ovom su obliku svi elementi niza još uvijek neinicijalizirani. Da biste ih inicijalizirali kada su deklarirani, morate koristiti sljedeću sintaksu:

int niz = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9);

U ovom slučaju prvom elementu niza dodijeljena je vrijednost 0, a posljednjem - vrijednost 9.
Možete koristiti petlje za dodjeljivanje vrijednosti elementima niza. Za to bi najprikladnija bila for petlja.

C++ kod int polje; //definicija niza za (int i = 0; i< 10; i++) { array[i] = i; }

Ovdje svakom elementu niza pristupamo preko indeksa - broja u uglatim zagradama. Sa svakom iteracijom petlje, ona uzima vrijednosti od nule do 9.

Imajte na umu da numeriranje indeksa počinje od nule. Stoga je broj indeksa uvijek za jedan manji od broja elemenata niza.

S iznimkom uglatih zagrada i indeksa, element niza koristi se kao i svaka varijabla.

Žice

Do sada smo nizove mogli pohranjivati ​​samo u konstantama: "Primjer konstantnog niza." Mogli smo pohraniti samo jedan znak u varijablama - u tipu char. C++ koristi dvije vrste nizova: niz elemenata tipa char i tipa str. Za sada ćemo se fokusirati na prvu opciju.

Za pohranjivanje niza potreban nam je niz. Izgleda otprilike ovako:

znakovni niz = ("s","t","p","o"."k","a");

Srećom, postoji lakši način :)

char string = "niz";

U ovom slučaju automatski će se stvoriti niz od sedam elemenata. Zašto od sedam? Poanta je da svaki redak mora završiti sa karakternom konstantom "\0", koja predstavlja prazan bajt.

U prethodnim primjerima, ako pokušamo unijeti niz duži od šest znakova u niz znakova, niz će se preliti jer Ne možete promijeniti veličinu niza dok program radi (iako ne uvijek):

znakovni niz; // niz može pohraniti šest znakova i "\0"

niz = "niz!"; // linija sadrži sedam znakova
Nije preporučljivo to raditi :)

Postoji još jedna točka na koju vam želim skrenuti pozornost. Kada korisnik unese niz, razmaci se broje kao "\0". Još nećemo unositi nizove u naše programe, pa neću detaljno objašnjavati ovaj slučaj.

Nizovi nizova (dvodimenzionalni nizovi)

Pa, konačno dolazimo do najvažnije stvari u ovom broju.

Karta u strateškim (i ne samo) igrama (RTS) podijeljena je na ćelije (na engleskom - tile). Prikladno je te ćelije predstaviti pomoću dvodimenzionalnog niza.

U ovom primjeru nastavit ćemo raditi s programom pseudo_game i pomoću dvodimenzionalnog niza simulirati ćemo kartu po kojoj se igrač može kretati. Do sada je "kretanje" bilo predstavljeno pomoću x, y koordinata.

Ćelije ćemo prikazati simbolima. Veličina "kartice" je 15x20. Petnaest visok, dvadeset širok. Igrača ćemo predstaviti simbolom T.

Prvo dodajte datoteku zaglavlja stdlib.h.

Poboljšana pseudo_igra

Dat ću samo dijelove koda. Preporučljivo je da cijeli program imate pred očima. Možete ga pronaći u odjeljku "popisi programa" - pseudo_game_0_2. Sastavlja se i izvodi. Samo ga kopirajte u svoj IDE editor i slijedite tekst.

Inicijalizacija podataka:

C++ kod char act; // varijabla za čitanje korisničkog unosa int ch; // varijabla za pohranjivanje smanjene vrijednosti varijable act int x = 0; // dvije varijable za pohranjivanje koordinata igrača int y = 0; char karta; // niz za pohranjivanje karte igre // inicijaliziranje niza za (int i = 0; i< 15; i++) { for (int j = 0; j < 20; j++) { map[i][j] = " "; } } map = "T";

Ovdje je novi operator za nas definicija dvodimenzionalnog niza. Ali gotovo se ne razlikuje od jednodimenzionalnog, samo dodaje još jedan par uglatih zagrada. U prvim smo zagradama naveli broj redaka, u drugom - broj stupaca.

Nakon toga, u dvije petlje, inicijaliziramo svaki element niza s vrijednošću " " - što je samo razmak. Prvo, u vanjskoj petlji, prolazimo kroz sve redove. Za svaki red u unutarnjoj petlji "prelazimo" stupce.

Dat ću detaljan primjer: nakon nekoliko iteracija vanjske petlje, brojač i postaje jednak 9. Tijelo vanjske petlje počinje se izvršavati: varijabla j (brojač unutarnje petlje) se inicijalizira na nulu, uvjet se provjerava i tijelo unutarnje petlje se izvršava: map = " ";, To jest, prvom znaku (indeks nula) desetog retka (ne zaboravite da je odbrojavanje od nule) dodijeljen je razmak. Tada se brojaču j dodjeljuje 1, izvršava se tijelo petlje... i tako dalje dok brojač j ne postane jednak 20 - uvjet nije ispunjen i izlazi se iz unutarnje petlje. Tada se vanjski brojač povećava. Sada je jednako 10 i tijelo vanjske petlje se ponovno izvršava...

Nakon inicijalizacije razmacima, postavljamo lik naše igre u prvi stupac prvog reda.

Na početku glavne petlje pozivamo funkciju system() da očistimo ekran od prethodnog izlaza.

Zatim postoje dva ciklusa slična ciklusima inicijalizacije. Koriste se za prikaz elemenata niza na ekranu. Jedina značajna razlika je izlaz znaka novog retka na kraju tijela prve petlje.

Pa onda postoji grananje u kojem se određuje koja je tipka pritisnuta. Samo grananje se malo promijenilo od prošlog puta, ali postoje razlike u sadržaju blokova: prvo, dodjeljujemo razmak koordinatama na kojima se objekt nalazi. Odnosno, brišemo prethodno mjesto. Tada mijenjamo jednu od koordinata. Zatim elementu niza s novim indeksima dodijelimo znak "T".

Primjer koda "75" - kretanje ulijevo:

C++ kod if else (ch == 75) ( map[x][y] = " "; y--; map[x][y] = "T"; )

Pa, to je sve. Trenutno imamo mapu 15x20 na kojoj strelicama možete pomicati lik - slovo "T". Nije loše za šestu lekciju! Ova aplikacija će postati osnova za sve naše konzolne programe. Neće biti grafičkih poboljšanja. Jednostavno ne možete dobiti više od DOS konzole, a mi nećemo uzeti u obzir Windows konzolu. To će značajno uštedjeti vrijeme i trud.

Detaljno sam komentirao program pseudo_game i najvjerojatnije ćete ga razumjeti bez poteškoća. Ako ne, onda ponovno pročitajte popis programa i nećete razumjeti ovo pitanje dok ga ne shvatite :). Vježbe će vam pomoći da učvrstite gradivo. Izvođenje vježbi je obavezno. Ako nešto nije jasno, pišite mi na moj e-mail - pokušat ću pomoći.

Vježbe:

1. U kompletnom popisu programa koristio sam grananje prekidača. Kôd za jedan if granalni blok također je prikazan ovdje. Dodajte preostale if blokove.

2. Sada program može pisati u nepostojeće elemente niza. Provjerite napuštanje granica karte.

3. Za vježbu izradite program koji na ekranu iscrtava dva polja za pomorsku bitku. Prvi je za igrača, drugi je za neprijatelja. Drugo polje treba biti smješteno desno od prvog.
Ispunite unutarnje ćelije razmacima. Za crtanje obruba koristite minus i ravnu razdjelnu crtu: -, |, a za kutove koristite hash #. Lijevo od svakog polja nalazi se niz brojeva; na vrhu su slova.
Možda će vam trebati nekoliko petlji da inicijalizirate cijelo polje. Evo kako bi mogao izgledati kod za popunjavanje stupca brojeva u drugom polju:

C++ kod int niz; // varijabla koja predstavlja retke int column; // varijabla koja predstavlja stupce char map; stupac = 15; za (niz = 2; niz< 12; string++) { map = string - 1; }

Recimo da moramo raditi s velikom količinom podataka iste vrste. Na primjer, imamo tisuću mjerenja koordinata njihala s nekim vremenskim korakom. Stvaranje 1000 varijabli za pohranjivanje svih vrijednosti vrlo je... glomazno. Umjesto toga, mnogi isti tipovi podataka mogu se kombinirati pod jednim imenom, a svakom specifičnom elementu može se pristupiti njegovim serijskim brojem.
Niz u C-u je definiran na sljedeći način
<тип> <имя массива>[<размер>];
Na primjer,
int a;
Dobit ćemo niz pod nazivom a, koji sadrži stotinu elemenata tipa int. Kao i kod varijabli, polje sadrži smeće.
Za pristup prvom elementu upišite njegov broj (indeks) u uglate zagrade. Na primjer

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

Prvi element ima indeksni broj 0. Važno je razumjeti zašto. U nastavku ćemo memoriju računala prikazati kao vrpcu. Naziv niza je pokazivač na memorijsku adresu na kojoj se nalaze elementi niza.

Riža. 1 Niz pohranjuje adresu prvog elementa. Indeks i elementa je pomak i*sizeof(type) bajtova od početka

Indeks niza označava koliko bajtova mora biti pomaknuto od početka niza da bi se pristupilo željenom elementu. Na primjer, ako niz A ima tip int, tada A znači da smo pomaknuli 10*sizeof(int) bajtova u odnosu na početak. Prvi element je na samom početku i ima pomak 0*sizeof(int) .
U C-u polje ne pohranjuje svoju veličinu i ne provjerava ispravnost indeksa polja. To znači da možete izaći izvan niza i pristupiti memoriji koja je dalje od posljednjeg elementa niza (ili bliže).

Početna inicijalizacija niza.

Napišimo jednostavan program. Kreirajmo niz i zatim pronađimo njegov najveći element.

#uključi #uključ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] >

Pogledajmo primjer. Prvo kreiramo niz i inicijaliziramo ga nakon stvaranja. Nakon toga, najvećem pronađenom elementu dodjeljujemo vrijednost prvog elementa niza.

Max = a;

Zatim prolazimo nizom. Budući da smo prvi element već pogledali (ima indeks 1), nema smisla ponovno ga gledati.
Isti primjer, samo što sada korisnik unosi vrijednosti

#uključi #uključi void main() ( int a; unsigned i; int max; printf("Unesite 10 brojeva\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("max element je %d", max); dobiti(); )

Ako je tijekom inicijalizacije navedeno manje vrijednosti od veličine niza, preostali elementi popunjavaju se nulama.

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

Ako je potrebno ispuniti cijeli niz nulama, tada pišemo

Int a = (0);

Na primjer, ne morate eksplicitno postaviti veličinu niza

Int a = (1, 2, 3);

niz će imati veličinu 3

Veličina polja

Niz u C-u mora imati konstantnu veličinu. To znači da je nemoguće, na primjer, pitati korisnika za veličinu i zatim postaviti tu veličinu na niz.

Printf("Unesite duljinu niza "); scanf("%d", &duljina); (float x;)

O stvaranju dinamičkih nizova raspravljat ćemo dalje pri radu s pokazivačima i memorijom
U nekim slučajevima možete saznati veličinu niza pomoću funkcije veličina.

#uključi #uključi void main() ( int A; //sizeof vraća veličinu cijelog niza u bajtovima //Da odredite broj elemenata, //podijelite veličinu niza s veličinom njegovog elementa int size = sizeof(A) / sizeof(int); printf("Veličina niza je jednaka %d", veličina();

Ali malo je vjerojatno da će ovo biti korisno. Prilikom prosljeđivanja niza kao argumenta funkciji, bit će proslijeđen pokazivač, tako da veličina niza neće biti poznata.
Statički nizovi korisni su kada je broj elemenata unaprijed poznat. Omogućuju brz, ali nesiguran pristup elementima.

Prelivanje polja

Nadajmo se da imate ovaj kôd

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

Evo petlje za navedeno s greškom. U nekim starijim verzijama prevoditelja, ovaj kod bi se ponavljao. Stvar je u tome da varijabla ja nalazio se tijekom kompilacije odmah nakon niza A. Kada je niz prešao granice, brojač je postavljen na 1.
Nizovi nisu sigurni, budući da pogrešan rad s indeksom može dovesti do pristupa proizvoljnom dijelu memorije (teoretski. Moderni prevoditelji sami brinu da ne zadirete u tuđu memoriju).
Ako radite s nizovima, morate osigurati da brojač ne premašuje veličinu niza i da nije negativan. Za ovo, u najmanju ruku,

• 1. Za indeksiranje koristite tip size_t. Zaštitit će vas od negativnih vrijednosti i uvijek će biti dovoljno za niz bilo koje veličine.
• 2. Zapamtite da niz počinje od nule.
• 3. Zadnji element niza ima indeks (veličina niza je 1)

Nema punopravnih načina da provjerimo jesmo li izašli iz niza ili ne. Dakle, ili točno znamo njegovu veličinu ili ga pohranimo u varijablu i pročitamo kada je potrebno.

Primjeri

Evo nekoliko tipičnih primjera rada s nizovima
1. Obrnite niz.

#uključi #uključi //Ovo je makronaredba. SIZE u kodu bit će zamijenjen s 10u #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); unsigned i, j; // brojači unsigned half; //sredina niza unsigned tmp; //privremena varijabla za razmjenu vrijednosti half = SIZE / 2; //Jedan brojač ide slijeva nadesno, drugi s desna nalijevo za (i = 0, j = VELIČINA - 1;< half; i++, j--) { tmp = A[i]; A[i] = A[j]; A[j] = tmp; } for (i = 0; i < SIZE; i++) { printf("%d ", A[i]); } getch(); }

Ovdje je dizajn koji vam nije poznat

#definiraj VELIČINU 10u

makro. U cijelom kodu, predprocesor će automatski zamijeniti sva pojavljivanja SIZE s 10u.
2. Brisanje elementa odabranog od strane korisnika.

#uključi #uključi #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); unsigned i; //brojač int indeks; //indeks koji unosi korisnik / /Izlazni niz 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(); }

U ovom slučaju, naravno, element se ne briše. Niz ostaje iste veličine kao prije. Jednostavno prepisujemo element koji se briše sljedećim i ispisujemo elemente SIZE-1.
3. Korisnik unosi vrijednosti u polje. Nakon toga ispišite sve različite vrijednosti koje je unio.
Neka korisnik unese konačan broj elemenata, recimo 10. Tada se unaprijed zna da neće biti više od 10 različitih vrijednosti ukupno. Svaki put kada korisnik unese broj, proći ćemo niz i provjeriti da li je takav broj upisan.

#uključi #uključi #define SIZE 10u void main() ( int A = (0); unsigned i, j; int counter = 1; //koliko je različitih brojeva uneseno. Najmanje jedan. int input; int wasntFound; //oznaka da je uneseni broj nije pronađen //Unesite prvi broj Još nije pronađen printf("0.");< 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. Korisnik upisuje broj - broj mjerenja (od 2 do 10). Nakon toga unosi sva mjerenja. Program prikazuje prosječnu vrijednost, varijancu i pogrešku.

#uključi #uključi #uključi #define SIZE 20u void main() ( //Studentski koeficijenti počinju od dvije dimenzije 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 sum = .0f; float relError; do (printf("Unesite broj mjerenja "); 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. Mjehuričasto sortiranje polja

#uključi #uključ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; //Izlazni niz 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; zastavica = istina; ) ) ) dok(zastavica == istina); //Izlaz sortiranog niza za (i = 0; i< SIZE; i++) { printf("%.3f ", a[i]); } getch(); }

6. Pomiješajte niz. Upotrijebimo algoritam za ovo