adjazenzsliste implementieren?!

petedeluxe2k

hab hier ein kleines problem...
und zwar möchte ich eine adjazensliste mit ihren methoden (Kante einfügen und löschen)
implementieren.

dazu hab ich schon folgendes gemacht:
eventuell, kann man das auch mit einem **List lösen, wobei ich da nicht genau weiss, wie ich es machen soll

#include <stdio.h>
#include <stdlib.h>
struct Element
{
int wert;
Element* next;
};

struct List
{
int value;
//List** next;
List* next;
Element* first;
};

void ListElementAdd(struct List* neu, struct List* alt )
{
// l->first = el;
alt->next = neu;
}
void ListElementAdd(struct List* neu, struct Element* alt )
{
// l->first = el;
alt->next = neu;
}

void setValue(struct List* l, int i)
{
l->value = i;
}

void setValue(struct Element* e, int i)
{
e->wert = i;
}

struct List* setList(struct List* l, int val)
{
l = (struct List*)malloc(sizeof(struct List));
l->first = NULL;
l->next = NULL;
l->value = val;
return l;
}

int main(void)
{
/*
List* b;
setList(b,5);
*/

List* a;
a = (struct List*)malloc(sizeof(struct List));
a->value = 5;
a->first = NULL;
a->next = NULL;

system("pause");
return 0;
}

für hilfe wäre ich sehr dankbar

mcr

Ich sehe, du hast da einige Fehler in deinem Code untergebracht.
Du versuchst hier eine einfach verkettete Liste zu implementieren.

Hier mal ein paar Fehler, die du gemacht hast: ich werde hier jetzt nicht
alle aufzählen.

--

struct Element 
{ 
   int wert; 
   Element* next;   // Element kennt er nicht.
   struct Element* next;  // so muesste es heißen.
};

oder du fügst folgende Zeile vorweg ein:

typedef struct Element Element;

--
Siehe auch die Definition von struct List.

--
In C ist es nicht erlaubt, Funktionen zu überladen.

d.h:

void setValue(struct List* l, int i);
void setValue(struct Element* e, int i);

innerhalb einer Datei ist nicht erlaubt.

--
Du verwendest den Struct Element eigentlich gar nicht.
Brauchst du auch nicht, es ist eventuell schöner die Daten von
den Verwaltungsinformationen (next,...) zu trennen. Dafür brauchst du dann
struct Element.

So, nun gebe ich dir mal eine erste Implementierung einer einfach verketteten
Liste, die du dann noch vervollständigen mußt und vor allem auch Sicherheits-
abfragen hinzufügen solltest.

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

typedef struct {
    int wert;
} Element;

typedef struct List {
    struct List* next;
    Element* element;
} List;

void ListElementAdd(List* liste, Element* el) {
    while (liste->next) liste = liste->next;
    if (!liste->element) liste->element = el;
    else {
        List *neu = malloc(sizeof(*neu));
        neu->element = el;
        neu->next    = NULL;
        liste->next  = neu;
    }
}

List *ListCreate(void) {
    List *neu = malloc(sizeof(*neu));
    neu->next    = NULL;
    neu->element = NULL;
    return neu;
}

Element *ElementCreate(void) {
    Element *el = malloc(sizeof(*el));
    el->wert = 0;
    return el;
}

void ElementSetValue(Element *el, int value) {
    el->wert = value;
}

void ElementPrint(Element *el) {
    if (!el) printf("Element leer\n");
    else printf("Wert: %d\n", el->wert);
}

void ListPrint(List *liste) {
    int i = 0;
    printf("======== Ausgabe Liste ========\n");
    while (liste) {
        printf("Liste: %d   ", ++i);
        ElementPrint(liste->element);
        liste = liste->next;
    }
}

int main(void) {
    List* liste = ListCreate();
    Element *el = ElementCreate();

    ElementSetValue(el, 5);
    ListElementAdd(liste, el);

    el = ElementCreate();
    ElementSetValue(el, 10);
    ListElementAdd(liste, el);

    ListPrint(liste);

    return 0;
}

Ach ja, du solltest die Elemente und Liste auch anschließend wieder mit free()
freigeben.

Gruß mcr