C-Programm zum Sortieren eines Arrays mithilfe von Zeigern

C-Programm zum Sortieren eines Arrays mithilfe von Zeigern

Schreiben Sie ein C-Programm, um Elemente in ein Array einzugeben und das Array mithilfe von Zeigern zu sortieren. So sortieren Sie ein Array in aufsteigender oder absteigender Reihenfolge mithilfe von Funktionszeigern in der C-Programmierung. Logik zum Sortieren eines Arrays mithilfe von Zeigern im Programm.

Beispiel

Eingabe

Input array elements: 10 -1 0 4 2 100 15 20 24 -5

Ausgabe

Array in ascending order: -5, -1, 0, 2, 4, 10, 15, 20, 24, 100,
Array in descending order: 100, 24, 20, 15, 10, 4, 2, 0, -1, -5,

Erforderliche Kenntnisse

Grundlegende C-Programmierung, Array, Funktionen, Zeiger, Funktionszeiger

Logik zum Sortieren eines Arrays mithilfe von Zeigern

Unten ist die Schritt-für-Schritt-Beschreibungslogik, um ein Array mit Zeigern zu sortieren.

  1. Größe und Elemente im Array eingeben. Speichern Sie sie in einer Variablen, sagen Sie size und arr .
  2. Zwei Funktionen mit Prototyp int sortAscending(int * num1, int * num2) deklarieren und int sortDescending(int * num1, int * num2) .

    Beide Funktionen werden verwendet, um zwei Elemente zu vergleichen und in aufsteigender oder absteigender Reihenfolge anzuordnen. sortAscending() gibt einen negativen Wert zurück, wenn num1 ist kleiner als num2 , positiver Wert, wenn num1 größer als num2 ist und Null, wenn beide gleich sind.

    Ebenso sortDescending() gibt einen negativen Wert zurück, wenn num1 ist größer als num2 , positiver Wert bei num2 ist größer als num1 und Null, wenn beide gleich sind.

  3. Deklarieren Sie eine weitere Funktion zum Sortieren von Arrays mit dem Prototyp void sort(int * arr, int size, int (* compare)(int *, int *)) .

    Es braucht drei Parameter, wobei der erste Parameter das zu sortierende Array ist, der zweite die Größe des Arrays und der dritte ein Funktionszeiger.

    Hinweis: Der hier übergebene Funktionszeiger entscheidet über die Beziehung zwischen zwei zu sortierenden Elementen. Wenn Sie Elemente in aufsteigender Reihenfolge sortieren möchten, übergeben Sie die Referenz von sortAscending() Funktion, sonst sortDescending() Funktion.

    Um ein Array zu sortieren, habe ich einen grundlegenden Sortieralgorithmus verwendet. Der Algorithmus ist im Vergleich zu anderen modernen Sortieralgorithmen nicht effizient, aber einfach zu verstehen und zu verwenden.

Programm zum Sortieren eines Arrays mit Zeigern

/**
 * C program to sort an array using pointers.
 */

#include <stdio.h>

#define MAX_SIZE 100


/* Function declaration */
void inputArray(int * arr, int size);
void printArray(int * arr, int size);

/* Sort function declaration */
int sortAscending(int * num1, int * num2);
int sortDescending(int * num1, int * num2);

void sort(int * arr, int size, int (* compare)(int *, int *));



int main()
{
    int arr[MAX_SIZE];
    int size;

    /*
     * Input array size and elements.
     */
    printf("Enter array size: ");
    scanf("%d", &size);
    printf("Enter elements in array: ");
    inputArray(arr, size);


    printf("\n\nElements before sorting: ");
    printArray(arr, size);


    // Sort and print sorted array in ascending order.
    printf("\n\nArray in ascending order: ");
    sort(arr, size, sortAscending);
    printArray(arr, size);


    // Sort and print sorted array in descending order.
    printf("\nArray in descending order: ");
    sort(arr, size, sortDescending);
    printArray(arr, size);

    
    return 0;
}



/**
 * Function to take input in array elements.
 * 
 * @arr     Array to store input.
 * @size    Size of the array.
 */
void inputArray(int * arr, int size)
{
    // Pointer to last element of array
    int * arrEnd = (arr + size - 1);


    // (arr++) Input in current array element and move to next element.
    // Till last array element (arr <= arrEnd)
    while(arr <= arrEnd)
        scanf("%d", arr++);
}




/**
 * Function to print all array elements.
 * 
 * @arr     Array to print.
 * @size    Size of the array.
 */
void printArray(int * arr, int size)
{
    // Pointer to last element of array
    int * arrEnd = (arr + size - 1);


    // *(arr++) Print current array element and move to next element.
    // Till last array element (arr <= arrEnd)
    while(arr <= arrEnd)
        printf("%d, ", *(arr++));
}



/**
 * Function to compare two succesive elements.
 * The function returns difference of first and second integer.
 * 
 * @num1    First integer to compare.
 * @num2    Second integer to compare.
 *
 * @return  Difference of num1 and num2.
 */
int sortAscending(int * num1, int * num2)
{
    return (*num1) - (*num2);
}



/**
 * Function to compare two successive elements. 
 * The function returns difference of second and first parameter.
 *
 * @num1    First integer to compare.
 * @num2    Second integer to compare.
 *
 * @return  Difference of num2 and num1.  
 */
int sortDescending(int * num1, int * num2)
{
    return (*num2) - (*num1);
}



/**
 * Function to sort an array in ascending or descending order.
 * This function is used to sort array in both order ascending or
 * descending.
 *
 * @arr     Array to sort.
 * @size    Size of the array.
 * @compare Function pointer returning integer and takes two int * 
 *          parameter. The function is called to get arrangement of
 *          two successive array elements.
 */
void sort(int * arr, int size, int (* compare)(int *, int *))
{
    // Pointer to last array element
    int * arrEnd  = (arr + size - 1);

    // Pointer to current array element
    int * curElem = arr;
    int * elemToSort;


    // Iterate over each array element
    while(curElem <= arrEnd)
    {
        elemToSort = curElem;


        // Compare each successive elements with current element
        // for proper order.
        while(elemToSort <= arrEnd)
        {
            /*
             * Compare if elements are arranged in order 
             * or not. If elements are not arranged in order
             * then swap them.
             */
            if(compare(curElem, elemToSort) > 0)
            {
                *curElem    ^= *elemToSort;
                *elemToSort ^= *curElem;
                *curElem    ^= *elemToSort;
            }

            elemToSort++;
        }

        // Move current element to next element in array.
        curElem++;
    }
}

Ausgabe

Enter array size: 10
Enter elements in array: 10 -1 0 4 2 100 15 20 24 -5


Elements before sorting: 10, -1, 0, 4, 2, 100, 15, 20, 24, -5,

Array in ascending order: -5, -1, 0, 2, 4, 10, 15, 20, 24, 100,
Array in descending order: 100, 24, 20, 15, 10, 4, 2, 0, -1, -5,

Empfohlene Beiträge

  • Index der Übungen zur Array- und Matrixprogrammierung.
  • C-Programm zum Austauschen zweier Zahlen mithilfe von Zeigern.
  • C-Programm zum Eingeben und Drucken von Array-Elementen mithilfe von Zeigern.
  • C-Programm zum Kopieren eines Arrays in ein anderes mithilfe von Zeigern.
  • C-Programm zum Austauschen zweier Arrays mithilfe von Zeigern.
  • C-Programm zum Umkehren von Arrays mithilfe von Zeigern.
  • C-Programm zum Suchen eines Elements in einem Array mithilfe von Zeigern.