einfach verkettete liste, listen ende ermitteln



  • hehoo,
    ich mache derzeit ein fernstudium und hänge bei diesem thema gerade etwas fest.

    ich einen vorgegebenen code bekommen, wo eine einfache verkettete liste ist und meine aufgabe ist nun, das listen ende zu finden und zu speichern, damit neue elemente direkt nach dem listenende eingefügt werden können, anstatt die liste immer neu zu durchlaufen.

    hier die aufgabenstellung:
    Erweitern Sie die zweite Version der einfach verketteten Liste so, dass das Listenende
    beim Anhängen nicht immer wieder neu ermittelt werden muss, sondern neue Elemente direkt am Ende der Liste angehängt werden können.

    also ich habe diesen code und ich bin nicht sicher, ob das so richtig ist, deswegen würde ich gerne hören, was ich falsch mache oder vielleicht ist das ja auch richtig:

    using System;
    namespace Cshp05d_05_02
    {
        class Listenelement
        {
            public string daten;
            Listenelement naechster;
    
            public void SetDaten(string datenNeu)
            {
                daten = datenNeu;
            }
            public Listenelement Anhaengen(string datenNeu)
            {
                if (naechster == null)
                {
                    naechster = new Listenelement();
                    naechster.SetDaten(datenNeu);
                }
                else
                    naechster.Anhaengen(datenNeu);
                return naechster;
            }
            public void Ausgeben()
            {
                Console.WriteLine(daten);
                if (naechster != null)
                    naechster.Ausgeben();
            }
        }
        class Program
        {
            static void Main(string[] args)
            {
                Listenelement listenAnfang = new Listenelement();
                Listenelement listenEnde = new Listenelement();
                listenEnde = listenAnfang;
                int zaehler = 1;
                listenAnfang.SetDaten("Element " + zaehler);
    
                for (int element = 0; element < 10; element++)
                {
                    if (listenEnde == listenAnfang)
                    {
                        listenEnde = listenAnfang.Anhaengen("Element " + ++zaehler);
                    }
                    else
                    {
                        listenEnde = listenEnde.Anhaengen("Element " + ++zaehler);
                    }
                }
                listenAnfang.Ausgeben();
                listenEnde.Ausgeben();
            }
        }
    }
    


  • @Arti sagte in einfach verkettete liste, listen ende ermitteln:

    PS: keine ahnung wieso die formatierung hier so fehlerhaft ist, sorry dafür

    Schreib' in eine Zeile vor Deinem Code ```csharp und in eine Zeile nach Deinem Code ```. Alternativ markiere Deinen Code, wähle C# im Dropdown über dem Eingabefeld aus und klicke auf das </> rechts neben dem Dropdown.

    Du kannst Deine Beiträge auch noch nachträglich bearbeiten. Den Menüpunkt "Bearbeiten" findest Du in dem Drei-Punkte-Menü rechts unter Deinen Beiträgen.



  • also ich bin anfänger und denke ich habe eine lösung gefunden, bin mir aber auch nicht sicher.
    zumindest scheint es zu funktionieren:

    /*##########################################
    Einsendeaufgabe 5.2
    ############################################ */
    using System;
    namespace Cshp05d_05_02
    {
        class ListElement
        {
            public string data;
            ListElement next;
            public void SetData(string datenNeu)
            {
                data = datenNeu;
            }
            public ListElement Add(string dataNew)
            {
                if (next == null)
                {
                    next = new ListElement();
                    next.SetData(dataNew);
                }
                else
                    next.Add(dataNew);
                // ich gebe hier das letzte ListenElement zurück, so habe ich immer eine aktuelle Position für das letzte Element
                return next;
            }
            public void output()
            {
                Console.WriteLine(data);
                if (next != null)
                    next.output();
            }
        }
        class Program
        {
            static void Main(string[] args)
            {
                ListElement listStart = new ListElement();
                ListElement listEnd = null;
                listEnd = listStart;
                int counter = 1;
                listStart.SetData("Element " + counter);
    
                for (int element = 0; element < 10; element++)
                {
                    if (listEnd == listStart)
                    {
                        listEnd = listStart.Add("Element " + ++counter);
                    }
                    else
                    {
                        // sobald wir einmal ein Ende gefunden haben, wird ab dem Ende weiter gemacht
                        listEnd = listEnd.Add("Element " + ++counter);
                    }
                }
                listStart.output();
                listEnd.output();
            }
        }
    }
    


  • @Arti sagte in einfach verkettete liste, listen ende ermitteln:

                ListElement listStart = new ListElement();
                ListElement listEnd = null;
    

    Warum ist das keine Datenstruktur List?


Log in to reply