Sortieren aufsteigend



  • Hallo alle zusammen hatte eine frage wie ich genau in C++ aufsteigend sortieren kann ,

    wenn ich z.B ein altes Array gegeben hab im header z.B

    Zahl* eintrag = 0;

    unsigned int maxZahl = 0;

    JETZT will ich es in ein neues Array mit einem index grösser +1 speichern :

    Ich muss ja auf jeden Fall ne for schleife machen um jeden Eintrag zu gucken ob er grösser als der erste 1 ist und dann in den alten kopieren .

    Kann mir jemand erklären wie man das allgemein macht?



  • In C++ verwendest du kein C-Array sondern std::vector. Und um diesen zu sortieren, gibt es std::sort.



  • In C++ wird mit std::sort sortiert.

    Ansonsten sortiere deine Gedanken und formuliere die Frage neu. Ich verstehe kein Wort.



  • wir hatten noch kein vektor.

    Irgendwie aufsteigend sortieren durch kopieren oder bubble sort?



  • Bubblesort arbeitet wie die meisten Sortieralgorithmen in-place, also brauchst Du kein zweites Array.

    Das, was Du laut Deinem ersten Beitrag hast ist kein Array, sondern ein Pointer. Es gilt allgemein: Ein Array ist kein Pointer und ein Pointer ist kein Array.



  • Ah ja genau wie macht man es dann mit Pointer ?
    Das war ja meine frage



  • Speicher mit new oder std::malloc() (je nachdem was euch beigebracht wurde) besorgen und deinen Zeiger darauf zeigen lassen,
    Irgendwie (je nachdem was euch beigebracht wurde) die zu sortierenden Daten in diesen Speicher bringen,
    sortieren mit Bubblesort.



  • Ich poste euch einfach die AUfgabe ist eh nur als Übung gedacht :

     #ifndef CCALENDAR_H_
    #define CCALENDAR_H_
    #include "CJulianDate.h"
    #include "CCalendarEntry.h"
    #include<iostream>
    using namespace std;
    
    class CCalendar{
    private:
        CCalendarEntry* m_entries = 0;
        unsigned int m_numberOfEntries = 0;
    
    public:
        CCalendar();
        ~CCalendar();
        CCalendar& operator+= (const CCalendarEntry& entry);
        void print(const CJulianDate& from);
        void print();
    };
    
    
    
    
    
    #endif /* CCALENDAR_H_ */```
    
    
    
    
     Implementieren Sie die operator+= Methode. In dieser Methode soll bei jedem Aufruf ein neues Array von Kalendereinträgen mit der erforderlichen Größe angelegt werden. In dieses Array sollen die bereits vorhandenen Einträge (falls es schon welche gibt) und der neue Eintrag so kopiert werden, dass sie zeitlich aufsteigend sortiert sind. 
    Das neue Array muss um +1 grösser sein.
    
    
    

    CCalendar& CCalendar::operator+=(const CCalendarEntry& entry) {
    CCalendarEntry *newEntries = new CCalendarEntry[m_numberOfEntries + 1];

    for(unsigned int j = 0; j< m_numberOfEntries+1; i++){
    
        for (unsigned int i = 0; i<m_numberOfEntries; i++){
    
            if(newEntries[j+1] > entry[i] ){
            
                newEntries[j+1]= entry[i];
                entry[i] = newEntries[j+1];
                delete[] newEntries;
    
    
            }
        }
    }
    
    
    if(m_entries != nullptr)
        delete[] m_entries;
    ++m_numberOfEntries;
    m_entries = newEntries;
    return *this;
    

    }```

    Richtig gelöst ?



  • @zalo3 sagte in Sortieren aufsteigend:

    Richtig gelöst?

    Nope.



  • Soll ich hier wie beim bubble sort eine tempöräre Variable erstellen und dort zwischenspeichern usw ?
    Oder geht das auch schöner?



  • @zalo3 sagte in Sortieren aufsteigend:

    if(newEntries[j+1] > entry[i]) {
    

    Überleg Dir mal, welcher Wert in jedem newEntries[0...m_numberOfEntries] steht.



  • Es steht ein Kalendereintrag ?
    Oder auf was willst du hinaus ?



  • @zalo3 sagte in Sortieren aufsteigend:

    Es steht ein Kalendereintrag ?

    Und wo kommt der her/wie entsteht der?



  • CCalendarEntry *newEntries = new CCalendarEntry[m_numberOfEntries + 1];

    das habe ich doch for der Schleife erstellt . Sieht man schlecht . Jetzt erkannt?



  • Oder soll ich den code einfach ganz neu mit Bubblesort starten ?
    Ich habe eine Lösung ,aber ich wollte die AUfgabe anders lösen .



  • @zalo3 sagte in Sortieren aufsteigend:

    CCalendarEntry *newEntries = new CCalendarEntry[m_numberOfEntries + 1];

    das habe ich doch for der Schleife erstellt .

    Mhm. Und welche WERTE hat jedes dieser newEntries[0...m_numberOfEntries]? Und wieviel Sinn macht es die mit entry[i] zu vergleichen?



  • es wird nur in der AUfgabe gesagt ,dass einer number of Entries hat und der andere sozusagen numberofEntries+1 haben soll.

    meine erste Idee war das ich
    newEntries[j+1] > m_entries[i]) . vergleiche ?

    Aber was hat dann entry (const CCalendarEntry& entry) hier für ein Sinn?
    Das verstehe ich dann nicht ?
    Implementieren Sie die operator+= Methode. In dieser Methode soll bei jedem Aufruf ein neues Array von Kalendereinträgen mit der erforderlichen Größe angelegt werden. In dieses Array sollen die bereits vorhandenen Einträge (falls es schon welche gibt) und der neue Eintrag so kopiert werden, dass sie zeitlich aufsteigend sortiert sind.
    Das neue Array muss um +1 grösser sein.

    Ich dachte das als vorhandene Einträge entry gemeint ist?



  • @zalo3 sagte in Sortieren aufsteigend:

    Aber was hat dann entry (const CCalendarEntry& entry) hier für ein Sinn?

    Der Parameter entry ist eine Referenz auf den CCalendarEntry, der zu den bestehenden hinzugefügt werden soll.
    m_entries Zeigt auf die bestehenden CCalendarEntry (oder ein nullptr falls es keine (m_numberOfEntries == 0) gibt), m_numberOfEntries ist deren Anzahl.

    @zalo3 sagte in Sortieren aufsteigend:

    meine erste Idee war das ich
    newEntries[j+1] > m_entries[i]) . vergleiche ?

    Auf die Gefahr hin mich zu wiederholen:

    Welche WERTE hat jedes dieser newEntries[0...m_numberOfEntries]? Und wieviel Sinn macht es die mit egal was zu vergleichen?



  • @swordfish sagte in Sortieren aufsteigend:

    Welche WERTE hat jedes dieser newEntries[0...m_numberOfEntries]? Und wieviel Sinn macht es die mit egal was zu vergleichen?

    Es sind Zahlen von Einträgen und die will man aufsteigend sortieren.

     CCalendar& CCalendar::operator+=(const CCalendarEntry& entry) {
    CCalendarEntry *newEntries = new CCalendarEntry[m_numberOfEntries + 1];
    unsigned int tmp = 0;
    for(unsigned int j = 0; j< m_numberOfEntries+1; i++){
    
        for (unsigned int i = 0; i<m_numberOfEntries; i++){
    
            if(newEntries[j+1] > m_entries[i] ){
            
                 tmp = newEntries[j+1]  ;
                 newEntries[j+1] = m_entries[i];
                  m_entrie[i]   = tmp;
                
    
    
            }
        }
    }
    
    
    if(m_entries != nullptr)
        delete[] m_entries;
    ++m_numberOfEntries;
    m_entries = newEntries;
    return *this;```
    
    Habe es jetzt mit bubblesort probiert zum ersten mal .
    
    Geht das ?


  • richtig swordfish? Noch da ?


Log in to reply