Bevezetés a tömbfunkciókba C
A C tömbfunkciók egy olyan adatszerkezet, amely ugyanazon adattípus több elemét tartalmazza. A tömb méretét rögzítjük, és az elemeket egymás után gyűjtjük. A tömbök különböző méretei lehetnek, és a C programozás nem korlátozza a tömb dimenzióinak számát.
A tömb különféle funkciói a C-ben
Különböző funkciók hajthatók végre tömbökön.
1) Átkelés
Egy tömb áthaladása azt jelenti, hogy a tömb minden elemét pontosan egyszer átmegyük. Az első elemtől kezdjük és az utolsó elemhez megyünk. Az alábbiakban a C nyelvû példát mutatjuk be egy olyan programra, amely lineáris tömbön halad át.
Kód
#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) );
)
)
Kimenet:
2) Keresés
A keresési művelet arra szolgál, hogy egy adott adatelemet vagy elemet megtaláljon a tömbben. Keresést végezhetünk egy válogatott tömbben a tömb áthaladásának segítségével. Az első elem és az utolsó elem közötti lineáris keresztezés felhasználható annak keresésére, ha egy adott szám van-e egy tömbben, és felhasználható annak helyzetére, ha van.
Ezt úgy végezzük, hogy összehasonlítunk minden elemet az adott elemmel (amelyet meg kell keresni). Az elem megtalálása után a keresési művelet leáll. Itt található egy példa a C tömbön végrehajtott keresési művelet bemutatására
Kód
#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;
)
Kimenet:
3) beillesztés
A beszúrási művelet új elem hozzáadására szolgál a tömbben. Amikor meghatározzuk azt az elemet és helyet, amelybe hozzá kell adni a tömbben, akkor beillesztési műveletet hajtunk végre. A tömb méretét azonban nem zavarja e művelet végrehajtása közben. Egy elem csak akkor kerül beillesztésre egy tömbbe, ha elegendő hely van hozzá hozzá. Ha egy tömb már megtelt, új elem nem adható hozzá. Példa a beszúrási művelet bemutatására egy válogatott tömbben C-ben.
Kód
#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;
)
Kimenet:
4) Törlés
Törlés közben a tömbben már létező elemet megkeresi (lineáris keresés használatával) és törli, majd az elemek eltolódását követi. A felhasználó beírja az elem pozícióját, amelyet törölni kell a tömbből. A törlés, akárcsak a beszúrási művelet, nem befolyásolja a tömb méretét. Ezenkívül a törlendő elem helyzetének a tömb méretén belül kell lennie, mivel a tömb méretét meghaladó elem törlése nem lehetséges. C program a törlés műveletének bemutatására egy válogatott tömbben.
Kód
#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;
)
Kimenet:
5) Rendezés
Ezt a műveletet egy tömb rögzített sorrendbe rendezésére, vagyis növekvő vagy csökkenő sorrendre hajtják végre. Íme egy példa a C tömbben található rendezési műveletre
Kód
#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));
)
Kimenet:
A tömb rendezésének különböző módjai
Az alábbiakban bemutatjuk az Array különböző rendezési módszereit:
1) Bubble Sort
A Bubble sort összehasonlítja az összes elemet egyenként, és az értékek alapján rendezi őket. Először összehasonlítja az első elemet a másodikval, ha az első elem nagyobb, mint a második elem, akkor kicseréli mindkét elemet, és folytatja a második és a harmadik elem összehasonlítását, és így tovább.
2) Válogatás rendezése
A válogatás mögött rejlő alapvető ötlet a legkevesebb elem megtalálása a válogatott tömbben, helyettesítése az első elemmel. Ezután folytassa ugyanazt a folyamatot a válogatott tömb többi részével, azaz a második helyzetből, majd a harmadikból és így tovább.
3) Rendezés egyesítése
Ez a válogatási módszer a split és conquer technikán alapul. Felosztja a tömböt két egyenlő alsó részre, és folytatja mindaddig, amíg minden egyes tömb egyetlen elemet tartalmaz, majd válogatott módon egyesíti őket, és így válogatott tömböt kap.
4) Beillesztési rendezés
A beszúrási sorrendben a második elemmel kezdjük. A tömb elemeket egymás után hasonlítják össze. Az aktuális elemet (a rendezendő értéket) összehasonlítják a rendezett alcsoport összes elemével. A rendezett alcsoportban az összes olyan elem, amely nagyobb, mint az aktuális elem, eltolódik, és az aktuális érték beillesztésre kerül. Ezt a folyamatot addig ismételjük, amíg a teljes tömb rendezve van.
5) Gyors rendezés
A Quicksort, csakúgy, mint az egyesítés, az osztás és meghódítás algoritmusán alapul. Ebben a módszerben egy elemet választanak pivotként (általában az első elem). Ezután egy tömb partícióit készítik a kiválasztott pivot körül, azaz az összes, de a pivotnál kevesebb elem al-tömböt alkot, és az összes pivotnál nagyobb elem egy másikat alkot. Az eljárást az al-tömbökkel is megismételjük, amíg a teljes tömb rendezésre nem kerül.
6) Halomfajta
A halomfajta algoritmusa az összehasonlításon alapszik. A maximális elemet kiválasztják és a véghelyzetbe helyezik. Ezután a második legnagyobb elem megtalálható, és a második utolsó helyzetbe kerül. Ezt a folyamatot meg kell ismételni az összes elemnél.
Ajánlott cikkek
Ez egy útmutató a tömbfunkciókhoz a C-ben. Itt tárgyaljuk a tömb rendezésének különféle funkcióit és módjait. Megnézheti más kapcsolódó cikkeket is, ha többet szeretne megtudni -
- Tömbök C ++-ban
- Tömbök R-ben
- Funkciók R-ben
- A tömb előnyei
- A tömbfunkciók típusai a PHP-ben és a példákban