[C] dubbele linked list

[Boudewijn]

Hoi mensen

Ben al paar daagjes bezig met een 1e jaars practicum en ik kom er niet uit.
Wat is het geval:

Je moet een dubbele linked list schrijven, en ik ga uit van deze code (thanks wikipedia):

code:

typedef struct element {
        int waarde;
        struct element *volgende;
        struct element *vorige;
} Element;

code:

Element *list_add(Element **p, int i) {
   if(checkValueExistence(*p,i) == 1)   {
        printf("Value %i already exists\n ",i);
        return (NULL);
   }
   
    printf ("%i\n", (*p)->waarde);
   
   Element *n = malloc(sizeof(Element));
   if ( i < (*p)->waarde){
       n->volgende = *p;
        *p = n;
        n->waarde = i;
    }
        
    return n;
}

code:

int main(void) {
    Element *n = NULL;

    list_add(&n, 4);
    list_add(&n, 3);
    list_add(&n, 2);
    list_add(&n, 1);
    list_add(&n, 0);

    return 0;
}

Eclipse+CDT hangt op de 1e printf (buiten de if) in de bovenste code-snippet.
Zonder haakjes gaat ook niet, compiler error.

Hoe los ik dit op?


Ik heb gezocht op code:
http://gathering.tweakers...-A&select_forum=#hitstart
en nog wat van die keywords in google.

[ Voor 4% gewijzigd door Boudewijn op 20-04-2006 01:01 ]

[Grijze Vos]

Hou die typedef, en gooi de rest van die wikipedia code opzij, en probeer zelf eerst eens in pseudo-code te bedenken wat je nu precies wilt doen met welke functie. Je zult iig een toevoeg-functie, een verwijder-functie en een opzoek-functie moeten hebben.

Wat je nu hebt staan klopt namelijk niet veel van.

[JokerLash]

Wat bedoel je eigenlijk met een dubbele linked list (eentje waarin je je vorige en volgende element kan gebruiken ofwat? of bedoel je een linked list waar weer een linked list inzit?)

Edit:
Tevens met de typedef struct wat je nou hebt gemaakt bouw je een oneindige structure omdat je in de struct ook een struct van zichzelf probeert te defineren die op zijn beurt weer een struct van zichzelf bevat enz enz.

[ Voor 40% gewijzigd door JokerLash op 20-04-2006 01:17 ]

[Soultaker]

Sowieso zullen je ze toch wel íets verteld hebben bij je practicum? Of is het gebruikelijk dat jullie zelf je implementatie via internetsites en forums bij elkaar sprokkelen?

Linked lists zijn nou niet bepaald rocket science. Als je er een vraag over hebt verwacht ik dat je minimaal een doordachte uitwerking in pseudo-code hebt

Verder kun je beter wat leren debuggen. Dat het programma blijft 'hangen' op de printf() lijkt me zeer onwaarschijnlijk. Wél zou 'ie daar kunnen crashen. Het eerste wat je dan doet is de printf-statement en het ophalen van de evalueren van z'n argumenten opsplitsen, zodat je tenminste kunt zien wáár het fout gaat:

C:

printf ("p: %i\n", (int)p);
printf ("*p: %i\n", (int)*p);
printf ("(*p)->waarde: %i\n", (*p)->waarde);

Verder ben ik het met Grijze Vos eens: gewoon zelf even nadenken wat je wil en bedenken wat er gebeurd als je je code uitvoert. Je zult dan al snel inzien dat je een NULL-pointer volgt (mits checkValueExistence() is geïmplementeerd zoals ik denk) en dat dat je crash veroorzaakt. Verder klopt je code inderdaad van geen kant ('vorige' wordt nooit geïnitialiseerd om maar één ding te noemen).

JokerLash schreef op donderdag 20 april 2006 @ 01:10:
Wat bedoel je eigenlijk met een dubbele linked list (eentje waarin je je vorige en volgende element kan gebruiken ofwat? of bedoel je een linked list waar weer een linked list inzit?)

Een doubly linked list is er eentje die je zowel voorwaarts als achterwaarts kunt doorlopen (wat handig is, omdat je dan ook voor en na elementen kunt invoegen). Gezien de definitie van Element is de TS daar ook mee bezig.

Tevens met de typedef struct wat je nou hebt gemaakt bouw je een oneindige structure omdat je in de struct ook een struct van zichzelf probeert te defineren die op zijn beurt weer een struct van zichzelf bevat enz enz.

Helemaal niet. Misschien aardig als je zelf eerst C leert voordat je commentaar geeft in topics over deze programmeertaal, want op deze manier helpt het niet echt. Ten overvloede: Element bevat een int (de waarde) en twee pointers naar andere elementen, niet de elementen zelf. De struct heeft dus wel een eindige grootte.

[ Voor 50% gewijzigd door Soultaker op 20-04-2006 01:22 ]

[Boudewijn]

ik weet exact wat ik wil.


ik ben 4e jaars student (ja inform) en kom niet door die kutpointer heen.

Heel simpel.

Ok even from scratch wat gebaggerd:

code:

#include <stdio.h>
#include <stdlib.h>

typedef struct element
{
        int waarde, id; //ID is used to determine where te next value will be placed in the list.
        struct element *volgende;
        struct element *vorige;
} Element;


void addValueToArray(int value); // Encapsulates the whole addition-operation.
int determinePosition(int value, int firstRun); //determines where in the array the 'value' will be placed


struct element root;

int main()
{
        Element *a= &root;

        addValueToArray(1);
        addValueToArray(3);
        addValueToArray(5);
        addValueToArray(9);

        printf("%d\n", root.waarde);
        printf("%d\n", root.volgende->waarde);
        printf("%d\n", root.volgende->volgende->waarde);

        return (0);
}

void addValueToArray(int value)
{
        static int firstRun=0;

        if(firstRun==0)
        {
                root.vorige=NULL;
                root.volgende=NULL;
                root.waarde=value;
                firstRun=1;
                return;
        }

        struct element *current= &root;
        struct element *temp;

        while(current->volgende != NULL )
        {
                        if(current->waarde < value && current->volgende->waarde > value);
                        {
                                        temp=current->volgende;
                                        current->volgende=(Element*) malloc(sizeof(Element));
                                        current->volgende->waarde=value;
                                        current->volgende->volgende=temp;
                                        current->volgende->vorige=current;
                                        current->volgende->volgende->vorige=temp;
                                        return;
                        }

                        current=current->volgende;
        }
        current->volgende=(Element*)malloc(sizeof(Element));
        current->volgende->vorige=current;
        current=current->volgende;
}



int determinePosition(int value, int firstRun)
{
        //there's no array yet.
        if(firstRun)
        {
                return(root.id);
        }

        if(root.waarde >= value ) //insert our value before the root.
        {
                return ( -1 ) ; // use -1  as a special flag.
        }


        Element *current= &root; //needed for scrolling the list.

        // Search through the array until we've found a suitable place to insert the new value.
        //New value will be placed INSIDE the array.
        while(current->volgende != NULL )
        {
                        if(current->waarde < value && current->volgende->waarde > value);
                        {
                        }
        }

        int temp = current->id; // if we don't use temporary variable, we can't destroy current
        free(current);
        //New value will be placed at the END of the array.
        return(temp);
}

Werkt niet... ik ga debuggen.

Wat moet het ding doen:


een linked list en daar op de juiste plek (waarde is volgorde-bepalend) een nieuw record inpleuren.


Ja deze code is van * Boudewijn persoonlijk (vond hem nog op laptop in eerdere poging het op te lossen)

Natuurlijk was er uitleg, dat is 3 jaar geleden en het vak wordt niet meer gegeven.
En sindsdien eigenlijk bijna alleen maar java geprogrammeerd en dit soort onzien niet tegengekomen.

[ Voor 13% gewijzigd door Boudewijn op 20-04-2006 01:39 ]

[Grijze Vos]

Omschrijf het nu eens in pseudocode?

[Soultaker]

Als dit het nivo is van de gemiddelde vierdejaarse Informaticastudent (en ik vrees dat je geen uitzondering bent) dan is het nivo op de Nederlandse universiteiten echt om te huilen.

Meer constructief: in de Java standard library zit ook een goede, simpele doubly linked list implementatie (java.util.LinkedList); het helpt waarschijnlijk om eens te kijken hoe die geïmplementeerd is, zeker als je veel ervaring hebt met Java en die code kunt lezen als pseudo-code. (Nietemin is het een goed idee om eerst zelf te bedenken hoe alles moet werken en de Java-code niet klakkeloos om te zetten in C-code.)

Ik blijf erbij dat je van je code een rommeltje maakt. De hack met 'firstRun' slaat compleet de plank mis: wat als je in je programma twee lijsten wil bijhouden? Gezien de kwaliteit van je code lijkt het me verstandig om het gedoe met op volgorde invoegen van elementen even te laten zitten (de logica daarvoor klopt verder ook van geen kant) en bij de basis te beginnen.

Bedenk je dat een linked list gerepresenteerd wordt als een pointer naar het eerste element; een lege linked list is dus een NULL pointer. Schrijf vervolgens functies die het volgende doen:
• een element voorin een lijst invoegen (accepteert een pointer naar het eerste element - mogelijk NULL, en retourneert een nieuwe pointer naar het eerste element).
• een element in een lijst invoegen, ná het huidige element (accepteert een pointer naar het eerste element én een pointer naar het element waarna ingevoegd moet worden, en retourneert een nieuwe pointer naar het eventuele nieuwe eerste element)
• een element uit de lijst verwijderen.
• een hele linked list vrijgeven.
• een aantal zoekfuncties (exacte waarde vinden, eerste waarde groter dan of gelijk aan gegeven waarde, etcetera.)
Dit zijn elementaire functies en voor je er meer mee kunt doen zul je dit soort functies moeten kunnen schrijven. Test deze functies uitgebreid in alle mogelijke gevallen (denk aan dingen als het eerste of het laatste element verwijderen, of juist het middelste, en de gevallen waarin de lijst leeg is en dus als NULL-pointer wordt gerepresenteerd).

(Overigens is het soms gebruikelijk, zoals de C++ en Java standard libraries doen, om de linked list niet direct als pointer te representeren maar deze pointer te verpakken in een object/struct. In C is dat niet zo nuttig omdat je struct toch geen methoden heeft, maar het kan duidelijkheid scheppen om verschil te maken tussen pointers naar elementen ín een linked list en de pointer naar het eerste element, die die linked list zelf representeert.)

Vervolgens wil je blijkbaar een gesorteerde lijst bijhouden. Als je de boven beschreven functies goed werkend hebt is dat geen punt, omdat je al elementen kunt vinden en ze op de gewenste plek kunt invoegen.

Tenslotte is het onduidelijk of je nu met C of C++ bezig bent. Je zegt C, maar je gebruikt delete. C++ gebruiken is ergens wel handig hier, maar in ieder geval: als je geheugen alloceert met malloc() (en andere allocatiefuncties uit de C library, zoals strdup() etc.) moet je dat vrijgeven met free(); omgekeerd moet je geheugen gealloceerd met new vrijgeven met delete (en new[] met delete[]).

[ Voor 17% gewijzigd door Soultaker op 20-04-2006 02:01 ]

[Boudewijn]

ok even alle duidelijkheid.

1: ik doe hbo (helaas geen uni, wil hierna TU/e doen).
2: C, en net idd die delete bug opgelost
3: ik ga eens vanaf scratch al die functies schrijven.

Thanks voor de tips.

Ik ga eens verder hacken ermee.

Btw: ja het onderwijs is kut in NL.

[Boudewijn]

Ok eea herschreven, er zit nog een bugje in (hij pakt het laatste element niet mee).

C:

#include <stdio.h>
#include <stdlib.h>

typedef struct element
{
        int waarde; 
        struct element *volgende;
        struct element *vorige;
} Element;

Element* voegToe(Element *eersteElement,int waarde) ;


/*
1: een element voorin een lijst invoegen (accepteert een pointer naar het eerste element - mogelijk NULL, en retourneert een nieuwe pointer naar het eerste element).
2: een element in een lijst invoegen, n? het huidige element (accepteert een pointer naar het eerste element ?n een pointer naar het element waarna ingevoegd moet worden, en retourneert een nieuwe pointer naar het eventuele nieuwe eerste element)
3: een element uit de lijst verwijderen.
4: een hele linked list vrijgeven.
5: een aantal zoekfuncties (exacte waarde vinden, eerste waarde groter dan of gelijk aan gegeven waarde, etcetera.)
*/


int main()
{
        Element *lijst = NULL; // de lijst is leeg
        lijst = voegToe(lijst, 1);
        lijst = voegToe(lijst, 2);
        lijst = voegToe(lijst, 3);
     
        printf("%i\n", lijst->waarde);
        printf("%i\n", lijst->volgende->waarde);
        printf("%i\n", lijst->volgende->volgende->waarde);
     
        return (0);
}

//1 
Element* voegToe(Element *eersteElement,int waarde) 
{
    if(eersteElement == NULL)
    {
        Element *nieuw = (Element*) malloc(sizeof(Element));
        nieuw->waarde = waarde; 
        return (nieuw);
    }
    
    
    Element *current = eersteElement;
    while(current->volgende!=NULL) // scroll naar het einde van de lijst
    {
        current++;
    }   
    
    Element *nieuw = (Element*) malloc(sizeof(Element));
    nieuw->waarde = waarde; 
    current->volgende = nieuw;
    nieuw->vorige = current;
    
    return (eersteElement); // hoe nuttig is dit? het is toch al je eerste parameter?
}

Opmerking1:
Waarom de lijst returnen na een toevoeging?

Opmerking2:
Ik weet dat het ranzig is zoals ik het aanpak bij een NULL parameter, maar op zich werkt dit prima en is het vrij duidelijk. Ik maak het echter wel netjes.


edit:

ah de fout.
s/current++/current=volgende->current

Reden: je hebt geen array achtige constructie.


edit: 03:28 even geadd:

C:

void freeList(Element *eersteElement)
{
    if (eersteElement == NULL)
    {
        return;
    }
        
    verwijderVolgendeElement(eersteElement);
        
}

void verwijderVolgendeElement(Element *element)
{
    if(element->volgende!=NULL)
    {
        verwijderVolgendeElement(element->volgende);
    }
    free(element);
    return;
}

in main wordt freeList aangeroepen, niet verwijderVolgendeElement.
Opzich kunt je ook gewoon verwijderVolgendeElement aanroepen met als param lijst.


edit: 03.33

C:

Element* zoekWaarde(Element *eersteElement, int waarde)
{
    if (eersteElement == NULL)
    {
        return(NULL); //als er geen lijst is, is er ook geen waarde.    
    }
    Element *current = eersteElement;
    while(current->volgende!=NULL) // scroll naar het einde van de lijst
    {
        if(current->waarde == waarde)
        {
            return(current);
        }   
        
        current = current -> volgende;
    }   
    return(NULL); //return NULL als de waarde niet gevonden wordt
}

wat zou dit nou toch doen

nu ga ik btw maffen.

[ Voor 30% gewijzigd door Boudewijn op 20-04-2006 03:34 ]

[AlanSmithee]

Boudewijn schreef op donderdag 20 april 2006 @ 02:40:

C:

#include <stdio.h>
#include <stdlib.h>

typedef struct element
{
        int waarde; 
        struct element *volgende;
        struct element *vorige;
} Element;

Element* voegToe(Element *eersteElement,int waarde) ;


/*
1: een element voorin een lijst invoegen (accepteert een pointer naar het eerste element - mogelijk NULL, en retourneert een nieuwe pointer naar het eerste element).
2: een element in een lijst invoegen, n? het huidige element (accepteert een pointer naar het eerste element ?n een pointer naar het element waarna ingevoegd moet worden, en retourneert een nieuwe pointer naar het eventuele nieuwe eerste element)
3: een element uit de lijst verwijderen.
4: een hele linked list vrijgeven.
5: een aantal zoekfuncties (exacte waarde vinden, eerste waarde groter dan of gelijk aan gegeven waarde, etcetera.)
*/


int main()
{
        Element *lijst = NULL; // de lijst is leeg
        lijst = voegToe(lijst, 1);
        lijst = voegToe(lijst, 2);
        lijst = voegToe(lijst, 3);
     
        printf("%i\n", lijst->waarde);
        printf("%i\n", lijst->volgende->waarde);
        printf("%i\n", lijst->volgende->volgende->waarde);
     
        return (0);
}

//1 
Element* voegToe(Element *eersteElement,int waarde) 
{
    if(eersteElement == NULL)
    {
        Element *nieuw = (Element*) malloc(sizeof(Element));
        nieuw->waarde = waarde; 
        return (nieuw);
    }
    
    
    Element *current = eersteElement;
    while(current->volgende!=NULL) // scroll naar het einde van de lijst
    {
        current++;
    }   
    
    Element *nieuw = (Element*) malloc(sizeof(Element));
    nieuw->waarde = waarde; 
    current->volgende = nieuw;
    nieuw->vorige = current;
    
    return (eersteElement); // hoe nuttig is dit? het is toch al je eerste parameter?
}

In de voegToe(...) functie heb je, als het een nieuwe lijst is, dat je een nieuw element aanmaakt en die returnt. Dit aanmaken doe je met malloc(...), een functie die het geheugen dat het terug geeft niet cleared of vult met '0'. Je zet alleen niet de member "volgende" van dat element op NULL.

Dat kan in een volgende aanroep naar voegToe(...) voor problemen zorgen, omdat je naar het einde van de lijst zoekt door de member "volgende" te vergelijken met NULL.

Ik ga er van uit dat je het wel getest hebt en denk dat het werkte omdat in debug modus anders met het geheugen wordt omgegaan. Ik verwacht persoonlijk dat hij in release modus zal crashen vanwege een access violation.

[Boudewijn]

bedankt voor de tip, die neem ik mee.

Ja de zaak is getest, zowel een debug als een release build in Eclipse werkten.
Ook gewoon in de commandline gcc aanroepen en dan a.out uitvoeren werkte prima..

[Zoijar]

[snip]

[ Voor 99% gewijzigd door Zoijar op 20-04-2006 12:58 . Reden: laat maar ]

[farlane]

Mensen mensen, die jongen komt hier met een vraag die hij eigenlijk had moeten weten, maar is het nou nodig om zo een 'want ben jij slecht en wij verschrikkelijk goed' gesprek hier te houden?

[ Voor 5% gewijzigd door farlane op 20-04-2006 12:12 ]

[Boudewijn]

farlane schreef op donderdag 20 april 2006 @ 12:12:
Mensen mensen, die jongen komt hier met een vraag die hij eigenlijk had moeten weten, maar is het nou nodig om zo een 'want ben jij slecht en wij verschrikkelijk goed' gesprek hier te houden?

ach ja ze zullen wel iets te compenseren hebben

idd erg irritant, maar ik lees er wel overheen.

[Verwijderd]

Dat blok commentaar dat bovenin staat, is dat de opdracht? Daarin staat namelijk dat je een element voorin de lijst moet invoegen, je loopt nu helemaal naar achteren...

[Zoijar]

[snip]

[ Voor 99% gewijzigd door Zoijar op 20-04-2006 12:58 . Reden: nevermind ]

[Verwijderd]

[snip] (dat lijkt me wel zo aardig dan)

Overigens, als jij het somber inziet met het niveau van het nederlands informatica onderwijs, dan open je daar maar een algemeen topic over. Dan hoeft niemand zich aangesproken te voelen.

[ Voor 58% gewijzigd door Verwijderd op 20-04-2006 13:07 ]

[Boudewijn]

Verwijderd schreef op donderdag 20 april 2006 @ 12:51:
Dat blok commentaar dat bovenin staat, is dat de opdracht? Daarin staat namelijk dat je een element voorin de lijst moet invoegen, je loopt nu helemaal naar achteren...

is dat niet duidelijk uit de draad?

nee opdracht is:

voeg op de juiste plek een nieuw element toe.
juist : tussen 2 andere waarden zodat het element kleiner is dan waarde erna en groter dan die ervoor.
elke waarde moet uniek zijn.

Maar lees even hierboven naar de tekst van soultaker als je wil weten hoe dat zit met die nummertjes.

[Verwijderd]

Boudewijn schreef op donderdag 20 april 2006 @ 13:05:
[...]

is dat niet duidelijk uit de draad?

nee opdracht is:

voeg op de juiste plek een nieuw element toe.
juist : tussen 2 andere waarden zodat het element kleiner is dan waarde erna en groter dan die ervoor.
elke waarde moet uniek zijn.

Maar lees even hierboven naar de tekst van soultaker als je wil weten hoe dat zit met die nummertjes.

Ah sorry te vluchtig gelezen, laat maar hangen...

[Zoijar]

Verwijderd schreef op donderdag 20 april 2006 @ 13:05:
Overigens, als jij het somber inziet met het niveau van het nederlands informatica onderwijs, dan open je daar maar een algemeen topic over. Dan hoeft niemand zich aangesproken te voelen.

offtopic:
Ja, dat dacht ik ook al. En dat heb ik wel eens gedaan, althans iemand anders had het geopend. Er zijn in principe twee kampen, en die gaan elkaars mening toch niet ondersteunen. Net zoiets als linux en windows, of ati en nvidia

[Soultaker]

Boudewijn schreef op donderdag 20 april 2006 @ 02:40:
Opmerking1:
Waarom de lijst returnen na een toevoeging?

Als je de lijst representeert als pointer naar het eerste element, dan kan die pointer veranderen als je iets aan begin toevoegt. Bij een lege lijst is die pointer bijvoorbeeld NULL, maar zodra je een element toevoegt, wordt dat een pointer naar het eerste element. Hetzelfde geldt voor het verwijderen van een element: als je het eerste element verwijdert, dan is de pointer daarna niet meer geldig.

In de situatie die ik schetste ga ik er dan ook vanuit dat de aanroepende code dat protocol volgt en dus elke keer de return value als representatie van de lijst gebruikt:

C:

Element *lijst = NULL;
lijst = add_in_front(lijst, 123);  // lijst: 123 -> NULL
lijst = add_in_front(lijst, 345);  // lijst: 345 -> 123 -> NULL
lijst = remove_in_front(lijst);    // lijst: 123 -> NULL
lijst = remove_in_front(lijst);    // lijst: NULL

Je kunt dit iets makkelijker maken door de linked list zelf apart te representeren, zoals de Java en C++ standard libraries doen, dan wordt het zoiets:

C:

typedef struct Element { 
    struct Element* volgende, vorige;
    int waarde;
} Element;

typedef struct LinkedList {
    struct Element *eerste;
};

{
    LinkedList ll = { NULL };
    add_in_front(&ll, 123);
    .. etc.
}

Dan moet je add_in_front zelf die assignments aan 'eerste' doen, om bij te houden wat het eerste element is. Voor de caller is het wat simpeler omdat 'ie alleen maar een pointer naar de lijst hoeft mee te geven.

Overigens ziet je 'zoekWaarde' functie er wel goed uit.

Boudewijn schreef op donderdag 20 april 2006 @ 12:19:
ach ja ze zullen wel iets te compenseren hebben

idd erg irritant, maar ik lees er wel overheen.

Nou, je topic-start kwam nogal over als 'ik heb een huiswerkopdracht maar ik ben te lui om het lesmateriaal door te nemen en zelf aan de slag te gaan'. Daarbij leek je code zonder nadenken gekopieerd van internet -- tja, dan lok je reacties zoals die van mij uit.

De meeste mensen hier zijn best bereid te helpen, maar hebben geen zin om het huiswerk van anderen te doen. Het nakijken van code op fouten en het typen van suggesties kost best veel moeite en tijd, en ik weet in ieder geval dat ikzelf geen zin heb om die moeite te doen als de poster zelf niet laat blijken minstens zoveel moeite te doen om zijn probleem op te lossen.

[ Voor 12% gewijzigd door Soultaker op 20-04-2006 14:40 ]

[Boudewijn]

Nou, je topic-start kwam nogal over als 'ik heb een huiswerkopdracht maar ik ben te lui om het lesmateriaal door te nemen en zelf aan de slag te gaan'. Daarbij leek je code zonder nadenken gekopieerd van internet -- tja, dan lok je reacties zoals die van mij uit.

De meeste mensen hier zijn best bereid te helpen, maar hebben geen zin om het huiswerk van anderen te doen. Het nakijken van code op fouten en het typen van suggesties kost best veel moeite en tijd, en ik weet in ieder geval dat ikzelf geen zin heb om die moeite te doen als de poster zelf niet laat blijken minstens zoveel moeite te doen om zijn probleem op te lossen.

logisch dat je niet andermans huiswerk wilt maken.
(ik heb nog niet zoveel posts, maar dat was al wel duidelijk bij mij aangekomen).

Mja ik zag het gisteren gewoon even niet zitten; het moet binnenkort af omdat ze dan de administratie niet meer kunnen updaten ofzo
Ik was gewoon uber gefrustreerd, en moest even ergens mijn ei kwijt kunnen;)

Als je de lijst representeert als pointer naar het eerste element, dan kan die pointer veranderen als je iets aan begin toevoegt. Bij een lege lijst is die pointer bijvoorbeeld NULL, maar zodra je een element toevoegt, wordt dat een pointer naar het eerste element. Hetzelfde geldt voor het verwijderen van een element: als je het eerste element verwijdert, dan is de pointer daarna niet meer geldig.

Dat doe ik toch, Soultaker?

Op zich werkt de code zoals hij er nu voorstaat.Toegevoegd:

C:

Element* insertElementNa(Element *eersteElement, Element *insertNa, int waarde)
// eersteElement    = de lijst
// insertNa         = het element WAARNA we moeten inserten, bij NULL als eerste element van  de lijst inserten.
{
    if (insertNa == NULL)
    {
        Element *nieuw = (Element*) malloc(sizeof(Element));
        nieuw->waarde = waarde;    
        nieuw->volgende = eersteElement;
        nieuw->vorige = NULL;
        eersteElement->vorige=nieuw;
        return (nieuw);
    }
    
    Element *nieuw = (Element*) malloc(sizeof(Element));
    nieuw->waarde = waarde;    
    nieuw->volgende = insertNa->volgende;
    insertNa->volgende->vorige = nieuw;
        
    insertNa->volgende= nieuw;
    nieuw->vorige = insertNa;
     
    return(eersteElement);
}

[Soultaker]

Boudewijn schreef op donderdag 20 april 2006 @ 16:05:
Dat doe ik toch, Soultaker?

Yep, nu wel; ik reageerde slechts op de vraag die je erbij stelde (waar is het nuttig voor?).

Op zich werkt de code zoals hij er nu voorstaat.Toegevoegd:

C:

Element* insertElementNa(Element *eersteElement, Element *insertNa, int waarde)
..

Ziet er goed uit!

[Boudewijn]

Thanks man.

Ik weet dat het er erg lame uitzag btw, en daaorm waardeer ik je uitleg ook des te meer.
De rest schrijf ik straks even.

[Piels]

Hier staat precies wat jij zoekt:

Linked Lists