Sissejuhatus massiivi funktsioonidesse C
Massiivi funktsioonid C-s on teatud tüüpi andmestruktuur, mis sisaldab mitut sama andmetüübi elementi. Massiivi suurus on fikseeritud ja elemendid kogutakse järjestikku. Massiivide mõõtmeid võib olla erinevaid ja C-programmeerimine ei piira massiivi mõõtmete arvu.
Massiivi erinevad funktsioonid C-s
Massiivides saab täita erinevaid funktsioone.
1) läbimine
Massiivi läbimine tähendab massiivi iga elemendi läbimist täpselt üks kord. Alustame esimesest elemendist ja läheme viimase elemendi juurde. Allpool on C-keeles toodud näide sellisest programmist, mis täidab sirgjoonelisel massiivil liikumist.
Kood
#include
void main()
(
int array() = (1, 2, 3, 4, 5);
int i, n = 5;
printf(" The array elements are: \n " );
for( i=0;i < n; i++)
(
printf(" array(%d) = %d \n ", i, array(i) );
)
)
Väljund:
2) otsimine
Otsimistoimingut kasutatakse konkreetse andmeüksuse või elemendi leidmiseks massiivist. Massiivi läbimise abil saame otsimist teha sortimata massiivis. Lineaarset läbilõiget esimeselt elemendilt viimasele elemendile saab kasutada otsimiseks, kas massiivis on antud arv, ja selle olemasolul selle asukoha leidmiseks.
Selleks võrreldakse iga elementi antud elemendiga (mida tuleb otsida). Kui element on leitud, peatatakse otsingu toiming. Siin on näide C-massiivis tehtud otsingutoimingute kuvamiseks
Kood
#include
int findElement(int arr(), int n, int key)
(
int i;
for (i = 0; i < n; i++)
if (arr(i) == key
return i;
return -1;
)
int main()
(
int arr() = (1, 4, 0, 6, 3);
int n = sizeof(arr) / sizeof(arr(0));
int key = 4;
int position = findElement(arr, n, key);
if (position == - 1)
printf("Element not found");
else
printf("Element Found at Position: %d", position + 1 );
return 0;
)
Väljund:
3) sisestamine
Sisestusoperatsiooni kasutatakse uue elemendi lisamiseks massiivi. Kui me täpsustame konkreetse elemendi ja positsiooni, kuhu see massiivi lisada, teostame sisestamise operatsiooni. Selle toimingu tegemise ajal massiivi suurus siiski ei häiri. Element sisestatakse massiivi ainult siis, kui selle lisamiseks on piisavalt ruumi. Kui massiivi suurus on juba täis, ei saa uut elementi lisada. Näide sisestamise toimimise kohta sortimata massiivis C-ga.
Kood
#include
int insertSorted(int arr(), int n, int key, int capacity)
(
if (n >= capacity)
return n;
arr(n) = key;
return (n + 1);
)
int main()
(
int arr(20) = (8, 5, 6, 9, 0, 7) ;
int capacity = sizeof(arr) / sizeof(arr(0));
int n = 6;
int i, key = 2;
printf("\n Before Insertion: ");
for (i = 0; i < n; i++)
printf("%d ", arr(i));
n = insertSorted(arr, n, key, capacity);
printf("\n After Insertion: ");
for (i = 0; i < n; i++)
printf("%d ", arr(i));
return 0;
)
Väljund:
4) kustutamine
Kustutamisoperatsiooni korral otsitakse massiivis juba olemas olevat elementi (kasutades lineaarset otsingut) ja kustutatakse, millele järgneb elementide nihutamine. Kasutaja sisestab massiivist kustutatava elemendi positsiooni. Kustutamise toiming, nagu ka sisestamise toiming, ei mõjuta massiivi suurust. Samuti peaks kustutatava elemendi asukoht jääma massiivi suurusesse, kuna massiivi suurusest suurema elemendi kustutamine pole võimalik. C programm sorteerimata massiivi kustutamisoperatsiooni kuvamiseks.
Kood
#include
int findElement(int arr(), int n, int key);
int deleteElement(int arr(), int n, int key)
(
int pos = findElement(arr, n, key);
if (pos == - 1)
(
printf("Element not found");
return n;)
int i;
for (i = pos; i < n - 1; i++)
arr(i) = arr(i + 1);
return n - 1;
)
int findElement(int arr(), int n, int key)
(
int i;
for (i = 0; i < n; i++)
if (arr(i) == key)
return i;return - 1;
)
int main()
(
int i;
int arr() = (1, 5, 3, 4, 2);
int n = sizeof(arr) / sizeof(arr(0));
int key = 3;
printf("Array before deletion\n");
for (i = 0; i < n; i++)
printf("%d ", arr(i));
n = deleteElement(arr, n, key);
printf("\nArray after deletion\n");
for (i = 0; i < n; i++)
printf("%d ", arr(i));
return 0;
)
Väljund:
5) sorteerimine
Seda toimingut tehakse massiivi sorteerimiseks fikseeritud järjekorda, st kas kasvavalt või laskuvalt. Siin on näide C-massiivi sortimistoimingutest
Kood
#include
void main()
(
int i, j, a, n, number(30);
printf("Enter the value of N \n");
scanf("%d", &n);
printf("Enter the numbers \n");
for (i = 0; i < n; ++i)
scanf("%d", &number(i));
for (i = 0; i < n; ++i)
(
for (j = i + 1; j < n; ++j)
(
if (number(i) > number(j))
(
a = number(i);
number(i) = number(j);
number(j) = a;
)
)
)
printf("The numbers arranged in ascending order are given below \n");
for (i = 0; i < n; ++i)
printf("%d\n", number(i));
)
Väljund:
Massiivi sortimise erinevad viisid
Allpool on toodud erinevad massiivi sortimismeetodid:
1) Mullide sortimine
Mullide sortimine võrdleb kõiki elemente ükshaaval ja sorteerib neid nende väärtuste alusel. Alustuseks võrreldakse esimest elementi teisega, kui esimene element on suurem kui teine element, vahetab see mõlemad elemendid ning võrdleb teist ja kolmandat elementi jne.
2) Valiku sortimine
Valiku sortimise põhiidee on sortimata massiivist vähima elemendi leidmine, selle asendamine esimese elemendiga. Seejärel jätkake sama protsessi ülejäänud sortimata massiivi abil, st teisest positsioonist, siis kolmandast ja nii edasi.
3) Ühenda sorteerimine
See sortimismeetod põhineb jagamise ja vallutamise tehnikal. See jagab massiivi kaheks võrdseks alammassiiviks ja jätkub, kuni iga alammassiiv sisaldab ühte elementi, ja liidab need seejärel sorteeritud viisil, saades sorteeritud massiivi.
4) Lisamise sort
Sisestusjärjekorras alustame teise elemendiga. Massiivi elemente võrreldakse üksteisega järjestikku. Kehtivat elementi (sorteeritavat väärtust) võrreldakse kõigi sorteeritud alammassiivi elementidega. Kõiki sorteeritud alammassiivi elemente, mis on suuremad kui praegune element, nihutatakse ja praegune väärtus sisestatakse. Seda protsessi korratakse, kuni kogu massiiv on sorteeritud.
5) Kiire sortimine
Quicksort, nagu ka liitmise sort, põhineb ka jagamise ja vallutamise algoritmil. Selle meetodi korral valitakse pöördepunktiks element (tavaliselt esimene element). Seejärel tehakse massiivi jaotamine valitud pöörde ümber, st kõik pöörde alla jäävad elemendid moodustavad ühe alammassiivi ja kõik elemendid, mis on suuremad kui pöördtelg, moodustavad teise. Protseduuri korratakse ka alammassiividega, kuni kogu massiiv on sorteeritud.
6) sorteerimine hunnikus
Hunnikute sortimise algoritm põhineb võrdlusel. Maksimaalne element valitakse ja asetatakse lõppasendisse. Siis leitakse suuruselt teine element ja asetatakse teise viimasesse positsiooni. Seda protsessi korratakse kõigi elementide puhul.
Soovitatavad artiklid
See on juhend massiivi funktsioonide kohta C-s. Siin käsitleme massiivi sortimise erinevaid funktsioone ja viise. Lisateavet leiate ka meie muudest seotud artiklitest -
- Massiivid C ++
- Massiivid R
- Funktsioonid R-s
- Massiivi eelised
- Massiivi funktsioonide tüübid PHP-s ja näited