proggen.org

Code: Alles auswählen

#include <stdio.h>

        int main(void)
        {
            int zaeler =0;
            const int big = 10;
            int arr[big];
            int newar[big];
            int anzahl = 0;

            int a = 0,b = 0;
            int temp = 0;
            
            // Arrays deklarieren
            arr[0] = 345;
            arr[1] = 435;
            arr[2] = 150;
            arr[3] = 45;
            arr[4] = 16;
            arr[5] = 3070;
            arr[6] = 165;
            arr[7] = 453;
            arr[8] = 166;
            arr[9] = 300;
                
            while(zaeler < big)
            {
                a = 0;
                b = big;
                // b ist ein komischer Wert, der anscheinend zum Teil nicht gebrauch wird
                    while (a < big)
                    {
                        if(temp == 0)
                        {
                            if (arr[a] > arr[b])
                            {
                                b = a;
                            }
                        }
                        else
                        {
                        if (arr[a] > arr[b] && arr[a] < temp)
                            {
                                b = a;
                            }
                        }
                        a++;
                    }

                    newar[anzahl] = arr[b];
                    anzahl++;
                    temp = arr[b];
                    zaeler++;
            }

            zaeler = 0;
            while(zaeler < big)
            {
            printf("%d\n",newar[zaeler]);
            
            zaeler++;
            }
            
            return 0;
        }

Code: Alles auswählen

      if (arr[a] > arr[b] && arr[a] < temp)

Code: Alles auswählen

b = big;

Code: Alles auswählen

arr[big]

Code: Alles auswählen

if (arr[a] > arr[b] && arr[a] < temp)

Code: Alles auswählen

if(arr[b] == temp)

Code: Alles auswählen

#include <stdio.h>
#include <limits.h>

int main(int argc, char** argv)
{
  /*****************************************************************************
   * Eingabe - Feld, welches sortiert werden soll
  */
  const int SIZE = 10;
  int eingabe[SIZE];
  eingabe[0] = 345;
  eingabe[1] = 435;
  eingabe[2] = 16;
  eingabe[3] = 18;
  eingabe[4] = 17;
  eingabe[5] = 3070;
  eingabe[6] = 165;
  eingabe[7] = 453;
  eingabe[8] = 166;
  eingabe[9] = 300;
  
  
  /*****************************************************************************
   * Sortieren
  */
  // Platz fuer das fertig sortierte Feld, wir sortieren NICHT in situ!
  int ausgabe[SIZE];
  
  // Wo in ausgabe muessen wir als naechstes etwas ablegen?
  int platzier_iterator = 0;
  
  // Wir speichern uns, welchen Wert wir zuletzt in ausgabe geschrieben haben
  // und wo (Index) wir diesen Wert in eingabe (!!) gefunden hatten!
  // Fuer den ersten Durchgang brauchen wir einen Wert, der groesser ist, als
  // alles, was in eingabe steht. Also nehmen wir INT_MAX!
  int zuletzt_platziert_index = -1;
  int zuletzt_platziert_wert = INT_MAX;
  
  // Wir platzieren nach einander die Werte in ausgabe
  while (platzier_iterator < SIZE)
  {
    /* Zu erst suchen wir den Wert, welcher (ohne die schon platzierten Werte)
     * in eingabe am groessten ist!
    */
    
    // Wo suchen wir als naechstes in eingabe?
    int such_iterator = 0;
    
    // Wir speichern uns, welchen Wert wir schon gefunden haben, der unsere
    // Anforderungen erfuellen koennte. Wir speichern uns auch, wo wir diesen
    // Wert im eingabe gefunden haben.
    int gesucht_index = 0;
    int gesucht_wert = INT_MIN;
    
    // Die eigentliche Suche
    while (such_iterator < SIZE)
    {
      // Wir haben einen Wert, der kleiner/gleich als der zuletzt platzierte
      // Wert ist. Diese Ueberpruefung ist notwendig, um schon platzierte Werte
      // aus der Suche auszuschliessen!
      if (eingabe[such_iterator] <= zuletzt_platziert_wert)
      {
        // Nicht den zuletzt platzierten Wert nehmen, das ist ein Ansatz, der
        // manchmal Abhilfe schafft, aber eben nicht immer!!!
        if (such_iterator != zuletzt_platziert_index)
        {
          // Wir haben einen Wert gefunden, der groesser als unser bisheriger
          // Wert ist. Den merken wir uns!
          if (eingabe[such_iterator] > gesucht_wert)
          {
            // Wir merken uns den Wert und auch den Ort, an dem wir ihn gefunden
            // haben!
            gesucht_index = such_iterator;
            gesucht_wert = eingabe[such_iterator];
          }
        }
      }
      // Weitersuchen!
      such_iterator++;
    }
    
    
    /* Wir haben den gesuchten Wert gefunden und platzieren ihn nun an der
     * richtigen Stelle!
    */
    
    // Platzieren!
    ausgabe[platzier_iterator] = eingabe[gesucht_index];
    
    // Und wir muessen auch im naechsten Durchgang noch wissen, welchen Wert wir
    // hier gerade platziert haben! Und auch, von wo!
    zuletzt_platziert_wert = eingabe[gesucht_index];
    zuletzt_platziert_index = gesucht_index;
    
    // Weiter, um den naechsten Wert zu platzieren!
    platzier_iterator++;
  }
  
  
  /*****************************************************************************
   * Ausgabe des fertig sortierten Feldes
  */
  printf("(");
  int print_iterator = 0;
  while (print_iterator < SIZE)
  {
    printf(" %d ", ausgabe[print_iterator]);
    print_iterator++;
  }
  printf(")\n");
  return 0;
}

Code: Alles auswählen

#include <stdio.h>

        int main(void)
        {
            int counter = 0; // Äußerer Zähler
            const int value = 10; // feste Arraygröße
            int arr[value]; // ungeordnetes Array
            int newarr[value]; // geordnetes Array

            int fast = 0; // innerer Durchlauf - also schneller
            int low = 0; // zugewiesener Wert - langsamer
            int temp = 0; // Zwischenzähler für newarr

            arr[0] = 345;
            arr[1] = 300;
            arr[2] = 300;
            arr[3] = 4556;
            arr[4] = 165;
            arr[5] = 3070;
            arr[6] = 453;
            arr[7] = 3070;
            arr[8] = 166;
            arr[9] = 300;

                while(counter < value)
                {
                        fast = counter; // Die Variablen "fast" und "low" lassen denn letzten
                        low = counter;  // größten Wert aus.
                        while(fast < value)
                        {
                            if(arr[fast] >= arr[low])
                            {
                                low = fast; // "low" wird der Wert vom "fast" zugewiesen
                            }
                            fast++;
                        }
                        newarr[temp] = arr[low];
                        arr[low] = arr[counter]; // Der Wert von Anfang nimmt den Platz vom größten Arraywert ein
                        temp++;
                        counter++;
                }

            counter = 0;
            while(counter < value)
            {
            printf("%d\n",newarr[counter]);
            counter++;
            }
            return 0;
        }