Doppel verkettete Liste - Suche realisieren

[profun]

Hallo Liebe C-Coders! Ich habe vielleicht Grundkenntnisslücken oder Missverständnisse mit der dynamischen Daten-Strukturen in C. Ich habe die folgende Aufgabe:

"Die folgende Vereinbarung beschreibt das Knotenelement einer doppeltverketteten linearen Liste zur
Behandlung von Messdaten. Die Komponente "Messwert" repräsentiert den ganzzahligen Messwert,
die Komponente "Anz" gibt an, wie häufig dieser aufgetreten ist.
struct elem_t
{
int Messwert;
int Anz;
struct elem *next;
struct elem *prev;
};

Zu Realisieren ist eine Funktion, mit der man untersucht, ob ein Knotenelement mit gleichem Messwert existiert, die Anzahl erhöht und den Zeiger auf diesen Knoten zurückliefert.
Übergabeparameter sind der Messwert und der Zeiger auf das erste Listenelement (Wurzel). Der Prototyp der Funktion lautet:
struct elem *LstSuchInc(struct elem *wrz, int ulWert);"


So meine Frage: Wie sucht man in der doppel verkettete Liste nach schon existierten Element und wie beschreibt man wie häufig dieses Element aufgetreten ist?
Hier ist meine doppel verkettete liste mit einfachen ein/ausgaben funktionen: http://pastebin.com/adexbkcq

Bitte um Hilfsschritte!
Grüße,
profun

 

[Arch]

Du hast doch schon diesen Part in deinem Program so wie ich das sehen:

while(ptr != NULL){
        printf("MESSWERT %d\n", ptr->Messwert);
        ptr=ptr->next;
}

Anstatt den Messwert auszugeben prüfst du einfach ob der Messwert dem zu suchendem Wert entspricht. Falls ja erhöhst du die Anzahl (Anz) um eins und weist dem Zeiger die Adresse des übereinstimmenden Elements zu (so habe ich es zumindest verstanden).

//EDIT: Ach ne, du gibst das gefundene Element einfach zurück.... das ist ja die Wurzel die übergeben wird .
Mein C ist schon ein wenig eingerostet, falls ich Fehler habe könnt ihr mich gerne korrigieren:

struct elem *LstSuchInc(struct elem *wrz, int ulWert){
	struct elem *currentElement = wrz;
	while (currentElement != NULL) {
		if (currentElement->Messwert == ulWert) {
			currentElement->Anz += 1;
			return currentElement;
		}
		currentElement = currentElement->next;
	}
}

So habe ich das verstanden. Dabei wird die Liste nur vorwärts durchlaufen, wenn die Wurzel aber auch das letzte Element sein kann, muss der Code noch ein wenig angepasst werden .

 

[profun]

Danke für ihre Antwort, Arch! Das geht genau richtig, wenn auch currentElemet = root. Schade aber, gibt es noch ein Problem:
Na habe ich eine Funktion für hinzufügen eines Elements am Ende der Liste. Na aber, funktioniert sie nicht, und warum, weiss ich nicht....
Hier ist die Funktion: http://pastebin.com/cf85xNYT
Und wie muss das in main() implementiert werden, um richtig zu laufen?Ideen?

 

[Arch]

Gleich angewöhnen, else wird in den meisten Fällen nicht benötigt und sollte dann weggelassen werden
Du übergibst der Funktion doch das neue Element und das letzte Element in der Liste, deshalb ist das ja relativ einfach. Vielleicht solltest du dich grundlegen nochmal mit einer Programmiersprache beschäftigen um dich besser in solche Probleme reindenken zu können. Ich will dir ja hier nicht deine ganzen Aufgaben vorprogrammieren

void LstInsert(struct elem *neu, struct elem *last){
    neu->next = NULL;
    neu->prev = last;
    last->next = neu;
}

 

[ixs]

Ehrlich gestanden schreibe ich den Post ohne ihn erst völlig durchgedacht zu haben. Doch es gibt noch die Möglichkeiten mit Arrays und Vectoren an das Problem herran zu gehen. Vom Sinn her ändert sich aber an Arch's Lösung überhaupt nichts.

 

[profun]

Gleich angewöhnen, else wird in den meisten Fällen nicht benötigt und sollte dann weggelassen werden
Du übergibst der Funktion doch das neue Element und das letzte Element in der Liste, deshalb ist das ja relativ einfach. Vielleicht solltest du dich grundlegen nochmal mit einer Programmiersprache beschäftigen um dich besser in solche Probleme reindenken zu können. Ich will dir ja hier nicht deine ganzen Aufgaben vorprogrammieren

void LstInsert(struct elem *neu, struct elem *last){
    neu->next = NULL;
    neu->prev = last;
    last->next = neu;
}

Wenn ich richtig verstanden habe, soll etwas solches existieren:

....
	ptr=root;
	while(ptr!=NULL){
		ptr=ptr->next;
		}
		if(ptr->next==NULL){
			last=ptr;
			neu=malloc(sizeof(struct elem));
			neu=last->next;
			neu->prev=last;
			last->next=neu;
			neu->next=NULL;
			}
...

 

[Arch]

Ok

neu=malloc(sizeof(struct elem));
neu=last->next;

Auf welchen Nachfolger zeigt bei einer Liste das letzte Element? Und warum setzt du den Zeiger zwei mal hintereinander? Was soll das malloc hier deiner Meinung nach tun, also welche Adresse soll da geliefert werden?

Oben schreibst du noch du verwendest diesen Methodenkopf:

void LstInsert(struct elem *neu, struct elem *last)

Warum nimmst du dann um das letzte Element zu suchen eine Schleife? Das wurde doch der Funktion übergeben?