Voraussetzung: Arrays in C

Ein gezacktes Array ist ein Array von Arrays , bei dem Mitglieds-Arrays unterschiedliche Größen haben können, dh wir können ein 2-D-Array erstellen, jedoch mit einer variablen Anzahl von Spalten in jeder Zeile. Diese Art von Arrays werden auch als gezackte Arrays bezeichnet.

Beispiel:

arr[][] = { {0, 1, 2},
            {6, 4},
            {1, 7, 6, 8, 9},
            {5} 
          };

Im Folgenden sind die Methoden zum Implementieren des gezackten Arrays in C aufgeführt:

  1. Verwendung eines Arrays und eines Zeigers ( Static Jagged Array)
    • Deklarieren Sie zuerst 1-D-Arrays mit der Anzahl der Zeilen, die Sie benötigen,
    • Die Größe jedes Arrays (Array für die Elemente in der Zeile) ist die Anzahl der Spalten (oder Elemente) in der Zeile,
    • Deklarieren Sie dann ein 1-D-Array von Zeigern, das die Adressen der Zeilen enthält.
    • Die Größe des 1-D-Arrays ist die Anzahl der Zeilen, die Sie im gezackten Array haben möchten.

    Unten ist die Implementierung des obigen Ansatzes:
    Beispiel:




    // C program to show the
    // implementation of Jagged Arrays
      
    #include <stdio.h>
    #include <stdlib.h>
      
    int main()
    {
      
        int row0[4] = { 1, 2, 3, 4 };
        int row1[2] = { 5, 6 };
      
        int* jagged[2] = { row0, row1 };
      
        // Array to hold the size of each row
        int Size[2] = { 4, 2 }, k = 0;
      
        // To display elements of Jagged array
        for (int i = 0; i < 2; i++) {
      
            // pointer to hold the address of the row
            int* ptr = jagged[i];
      
            for (int j = 0; j < Size[k]; j++) {
                printf("%d ", *ptr);
      
                // move the pointer to the
                // next element in the row
                ptr++;
            }
      
            printf("\n");
            k++;
      
            // move the pointer to the next row
            jagged[i]++;
        }
      
        return 0;
    }
    Ausgabe:
    1 2 3 4
5 6
  2. Verwenden eines Arrays von Zeigern (Dynamic Jagged Array)
    • Deklarieren Sie ein Array von Zeigern (gezacktes Array),
    • Die Größe dieses Arrays entspricht der Anzahl der Zeilen, die im Jagged-Array erforderlich sind
    • Weisen Sie dann für jeden Zeiger im Array Speicher für die Anzahl der Elemente zu, die Sie in dieser Zeile haben möchten.

    Unten ist die Implementierung des obigen Ansatzes:
    Beispiel:




    // C program to show the
    // implementation of Jagged Arrays
      
    #include <stdio.h>
    #include <stdlib.h>
      
    int main()
    {
        // 2 Rows
        int* jagged[2];
      
        // Allocate memory for elements in row 0
        jagged[0] = malloc(sizeof(int) * 1);
      
        // Allocate memory for elements in row 1
        jagged[1] = malloc(sizeof(int) * 3);
      
        // Array to hold the size of each row
        int Size[2] = { 1, 3 }, k = 0, number = 100;
      
        // User enters the numbers
        for (int i = 0; i < 2; i++) {
      
            int* p = jagged[i];
      
            for (int j = 0; j < Size[k]; j++) {
                *p = number++;
      
                // move the pointer
                p++;
            }
            k++;
        }
      
        k = 0;
      
        // Display elements in Jagged array
        for (int i = 0; i < 2; i++) {
      
            int* p = jagged[i];
            for (int j = 0; j < Size[k]; j++) {
      
                printf("%d ", *p);
                // move the pointer to the next element
                p++;
            }
            printf("\n");
            k++;
            // move the pointer to the next row
            jagged[i]++;
        }
      
        return 0;
    }
    Ausgabe:
    100
101 102 103

Falls Sie an Live-Kursen mit Experten teilnehmen möchten , beziehen Sie sich bitte auf DSA Live-Kurse für Berufstätige und Competitive Programming Live for Students .