Datenstrukturen und Algorithmen - Arrays

Array ist ein Container, der eine feste Anzahl von Elementen enthalten kann. Diese Elemente sollten vom gleichen Typ sein. Die meisten Datenstrukturen verwenden Arrays, um ihre Algorithmen zu implementieren. Im Folgenden finden Sie wichtige Begriffe zum Verständnis des Array-Konzepts.

Element - Jedes in einem Array gespeicherte Element wird als Element bezeichnet.
Index - Jede Position eines Elements in einem Array verfügt über einen numerischen Index, mit dem das Element identifiziert wird.

Array-Darstellung

Arrays können auf verschiedene Arten in verschiedenen Sprachen deklariert werden. Nehmen wir zur Veranschaulichung die C-Array-Deklaration.

Gemäß der obigen Abbildung sind die folgenden wichtigen Punkte zu berücksichtigen.

Index beginnt mit 0.
Die Array-Länge beträgt 10, was bedeutet, dass 10 Elemente gespeichert werden können.
Auf jedes Element kann über seinen Index zugegriffen werden. Zum Beispiel können wir ein Element am Index 6 als 9 abrufen.

Grundoperationen

Im Folgenden sind die grundlegenden Operationen aufgeführt, die von einem Array unterstützt werden.

Traverse - Drucken Sie alle Array-Elemente einzeln aus.
Insertion - Fügt ein Element am angegebenen Index hinzu.
Deletion - Löscht ein Element am angegebenen Index.
Search - Sucht ein Element anhand des angegebenen Index oder anhand des Werts.
Update - Aktualisiert ein Element am angegebenen Index.

Wenn in C ein Array mit der Größe initialisiert wird, weist es seinen Elementen Standardwerte in der folgenden Reihenfolge zu.

Datentyp	Standardwert
Bool	falsch
verkohlen	0
int	0
schweben	0.0
doppelt	0.0f
Leere
wchar_t	0

Verfahrbetrieb

Diese Operation dient zum Durchlaufen der Elemente eines Arrays.

Beispiel

Das folgende Programm durchläuft und druckt die Elemente eines Arrays:

#include <stdio.h>
main() {
   int LA[] = {1,3,5,7,8};
   int item = 10, k = 3, n = 5;
   int i = 0, j = n;   
   printf("The original array elements are :\n");
   for(i = 0; i<n; i++) {
      printf("LA[%d] = %d \n", i, LA[i]);
   }
}

Wenn wir das obige Programm kompilieren und ausführen, ergibt es das folgende Ergebnis:

Ausgabe

The original array elements are :
LA[0] = 1 
LA[1] = 3 
LA[2] = 5 
LA[3] = 7 
LA[4] = 8

Einfügevorgang

Die Einfügeoperation besteht darin, ein oder mehrere Datenelemente in ein Array einzufügen. Abhängig von der Anforderung kann ein neues Element am Anfang, Ende oder einem beliebigen Array-Index hinzugefügt werden.

Hier sehen wir eine praktische Implementierung der Einfügeoperation, bei der wir Daten am Ende des Arrays hinzufügen -

Beispiel

Es folgt die Implementierung des obigen Algorithmus -

#include <stdio.h>

main() {
   int LA[] = {1,3,5,7,8};
   int item = 10, k = 3, n = 5;
   int i = 0, j = n;
   
   printf("The original array elements are :\n");

   for(i = 0; i<n; i++) {
      printf("LA[%d] = %d \n", i, LA[i]);
   }

   n = n + 1;
	
   while( j >= k) {
      LA[j+1] = LA[j];
      j = j - 1;
   }

   LA[k] = item;

   printf("The array elements after insertion :\n");

   for(i = 0; i<n; i++) {
      printf("LA[%d] = %d \n", i, LA[i]);
   }
}

Wenn wir das obige Programm kompilieren und ausführen, ergibt es das folgende Ergebnis:

Ausgabe

The original array elements are :
LA[0] = 1 
LA[1] = 3 
LA[2] = 5 
LA[3] = 7 
LA[4] = 8 
The array elements after insertion :
LA[0] = 1 
LA[1] = 3 
LA[2] = 5 
LA[3] = 10 
LA[4] = 7 
LA[5] = 8

Für andere Variationen der Array-Einfügeoperation klicken Sie hier

Löschvorgang

Löschen bezieht sich auf das Entfernen eines vorhandenen Elements aus dem Array und das Neuorganisieren aller Elemente eines Arrays.

Algorithmus

Erwägen LA ist ein lineares Array mit N Elemente und K ist eine positive ganze Zahl, so dass K<=N. Es folgt der Algorithmus zum Löschen eines Elements, das an der k- ^ten Position von LA verfügbar ist .

1. Start
2. Set J = K
3. Repeat steps 4 and 5 while J < N
4. Set LA[J] = LA[J + 1]
5. Set J = J+1
6. Set N = N-1
7. Stop

Beispiel

Es folgt die Implementierung des obigen Algorithmus -

#include <stdio.h>

void main() {
   int LA[] = {1,3,5,7,8};
   int k = 3, n = 5;
   int i, j;
   
   printf("The original array elements are :\n");
	
   for(i = 0; i<n; i++) {
      printf("LA[%d] = %d \n", i, LA[i]);
   }
    
   j = k;
	
   while( j < n) {
      LA[j-1] = LA[j];
      j = j + 1;
   }
	
   n = n -1;
   
   printf("The array elements after deletion :\n");
	
   for(i = 0; i<n; i++) {
      printf("LA[%d] = %d \n", i, LA[i]);
   }
}

Wenn wir das obige Programm kompilieren und ausführen, ergibt es das folgende Ergebnis:

Ausgabe

The original array elements are :
LA[0] = 1 
LA[1] = 3 
LA[2] = 5 
LA[3] = 7 
LA[4] = 8 
The array elements after deletion :
LA[0] = 1 
LA[1] = 3 
LA[2] = 7 
LA[3] = 8

Suchvorgang

Sie können eine Suche nach einem Array-Element basierend auf seinem Wert oder seinem Index durchführen.

Algorithmus

Erwägen LA ist ein lineares Array mit N Elemente und K ist eine positive ganze Zahl, so dass K<=N. Es folgt der Algorithmus zum Suchen eines Elements mit dem Wert ITEM mithilfe der sequentiellen Suche.

1. Start
2. Set J = 0
3. Repeat steps 4 and 5 while J < N
4. IF LA[J] is equal ITEM THEN GOTO STEP 6
5. Set J = J +1
6. PRINT J, ITEM
7. Stop

Beispiel

Es folgt die Implementierung des obigen Algorithmus -

#include <stdio.h>

void main() {
   int LA[] = {1,3,5,7,8};
   int item = 5, n = 5;
   int i = 0, j = 0;
   
   printf("The original array elements are :\n");
	
   for(i = 0; i<n; i++) {
      printf("LA[%d] = %d \n", i, LA[i]);
   }
    
   while( j < n){
      if( LA[j] == item ) {
         break;
      }
		
      j = j + 1;
   }
	
   printf("Found element %d at position %d\n", item, j+1);
}

Wenn wir das obige Programm kompilieren und ausführen, ergibt es das folgende Ergebnis:

Ausgabe

The original array elements are :
LA[0] = 1 
LA[1] = 3 
LA[2] = 5 
LA[3] = 7 
LA[4] = 8 
Found element 5 at position 3

Vorgang aktualisieren

Der Aktualisierungsvorgang bezieht sich auf das Aktualisieren eines vorhandenen Elements aus dem Array an einem bestimmten Index.

Algorithmus

Erwägen LA ist ein lineares Array mit N Elemente und K ist eine positive ganze Zahl, so dass K<=N. Es folgt der Algorithmus zum Aktualisieren eines Elements, das an der k- ^ten Position von LA verfügbar ist .

1. Start
2. Set LA[K-1] = ITEM
3. Stop

Beispiel

Es folgt die Implementierung des obigen Algorithmus -

#include <stdio.h>

void main() {
   int LA[] = {1,3,5,7,8};
   int k = 3, n = 5, item = 10;
   int i, j;
   
   printf("The original array elements are :\n");
	
   for(i = 0; i<n; i++) {
      printf("LA[%d] = %d \n", i, LA[i]);
   }
    
   LA[k-1] = item;

   printf("The array elements after updation :\n");
	
   for(i = 0; i<n; i++) {
      printf("LA[%d] = %d \n", i, LA[i]);
   }
}

Wenn wir das obige Programm kompilieren und ausführen, ergibt es das folgende Ergebnis:

Ausgabe

The original array elements are :
LA[0] = 1 
LA[1] = 3 
LA[2] = 5 
LA[3] = 7 
LA[4] = 8 
The array elements after updation :
LA[0] = 1 
LA[1] = 3 
LA[2] = 10 
LA[3] = 7 
LA[4] = 8