C-Basics (Linked List)

Seite 1 von 2 - Forum: Coding Stuff auf overclockers.at

URL: https://www.overclockers.at/coding-stuff/c-basics_linked_list_202888/page_1 - zur Vollversion wechseln!

hi there.

ich muss für die uni wieder c programmieren und diese hardwarenähe macht mir echt zu schaffen inzwischen. jedenfalls ist die aufgabenstellung, eine implementierung einer einfach verketteten liste zu schreiben. ich scheitere irgendwie schon an der append-funktion.

Code:

void Append(IntList *l, int n)
{ 
  IntList neu = (IntList)malloc(sizeof(elemtype));
  neu->wert=n;
  neu->next=NULL;
  if (*l==NULL) //liste leer
  {
    printf("NEU\n");
    *l=neu;
  }
  else
  {
    while ((*l)->next!=NULL)
    {
      printf("Eins weiter\n");
      *l=((*l)->next);
    }
    (*l)->next=neu;
  }
}

Kannst vielleicht den ganzen Code posten.

Ansonsten hilft dir vielleicht das:
http://openbook.galileocomputing.de...0.htm#Xxx999328

der ganze while block ist wahnsinn, ich check ehrlichgsagt im moment ned mal wieso das überhaupt geht... du setzt da den zeiger, welcher auf den listenanfang zeigen soll, ständig weiter...

probier im else zweig mal folgendes:

Code:

IntList *tmp = l;
while((*tmp)->next != null) {
  *tmp = (*tmp)->next;
}
(*tmp)->next = neu;

Jop, du brauchst eine temporäre Variable, die dir quasi immer den nächsten Knoten referenziert, denn sonst verlierst du am Ende die Referenz auf den Listenkopf.

Warum eigentlich

Code:

(*temp)->next

Code:

temp.next

ja, irgendwas passt da ganz gewaltig ned zam

Zitat von jives

Warum eigentlich

Code:

(*temp)->next

und nicht

Code:

temp.next

?

Ich glaub du denkst einfach zu kompliziert. Das machen alle die von Java oder ähnlichem kommen. C bzw. C++ ist in vielen Belangen viel einfach konstituiert, eben genau wegen der Hardware nähe.
Also du hat ein Objekt (struct nehm ich amal an) mit irgendwelchen Daten und dem Pointer zum nächsten Element. Dann hast du noch den Pointer auf das erste Element und einen auf das neue das du anhängen willst.
Also:
neu ist der Pointer auf das neue Element
l ist der Pointer auf das erste Element
current ist z.B. der Pointer auf das Aktuelle Element (zum Schleifendurchzählen)

Code:

current = l; //Anfang, ist vielleicht besser in der Schleife nicht l zu nehmen um das Erste Element nicht zu verlieren
while ( current->next != NULL ) { // current ist ein Pointer, somit ist die "->" Syntax am einfachsten. Alternativ "(*current).next"
current = current->next  //und zum nächsten gehen
}  //So, jetzt sollten wir in current das letzte Element haben
printf("%i",current->n); //Test, haben wir wirklich das Letzte??
current->next = neu;  //Anhängen vom neuen Element. Beides Pointer, also einfache Zuweisung.

Zitat von aNtraXx

Und da er die Liste ja per maloc erstellt ist sie dynamisch .

mit einer tmp variable hab ichs auch schon versucht gehabt, aber ich probier mal. thx derweil

im anhang die aufgabenstellung. main und 2 andre funktionen waren gegeben.

Zitat von semteX

Code:

IntList *tmp = l;
while((*tmp)->next != null) {
  *tmp = (*tmp)->next;
}
(*tmp)->next = neu;

somit bleibt dein l pointer schön am anfang der kette und du itterierst dennoch durch.

Zitat von semteX

Weiters, nur als Kosmetik: Es ist unschön wenn Liste und Knoten den selben Datentyp haben, weil es das ganze unlustig zum lesen macht. Schöner ist ma haut ein typedef drüber, welcher IntList und IntNode seperat definiert (obwohl sie beide ein und die selbe klasse sind im hintergrund).

Es schaut ungefähr so aus, ja, aber du vermischt doch 2 Dinge miteinander. Du versuchst immer (*tmp)->new zu verwenden, was aber keinen Sinn macht. Also, mit malloc erhältst du die Adresse (Pointer) zu dem neu erstellen Element. Wenn du den Pointer dereferenzierst erhältst du das Element selbst (*tmp). Wenn du dann auf ein Element daraus zugreifen willst kannst du das mit der Punkt Syntax machen (*tmp).new oder aber die Kurzschreibweise mit dem Pfeil tmp->new. Bei dem Pfeil ist eben kein dereferenzieren mehr dabei.
Übrigens ist mir da schon ein Fehler in der ersten Zeile bei deinem Append aufgefallen. Dein neu ist kein Pointer was es aber sein sollte, weil sonst ja der gesamte Sinn von malloc verloren geht.

merkst du dir irgendwo start und ende deiner liste? also zwei pointer auf das erste bzw. das letzte element?

wenn nein, das macht das ganze viel leichter, erstes bzw. letztes element aufrufen, dort den eintrag auf das neue struct setzen und fertig

Zitat von Bowser

Es schaut ungefähr so aus, ja, aber du vermischt doch 2 Dinge miteinander. Du versuchst immer (*tmp)->new zu verwenden, was aber keinen Sinn macht. Also, mit malloc erhältst du die Adresse (Pointer) zu dem neu erstellen Element. Wenn du den Pointer dereferenzierst erhältst du das Element selbst (*tmp). Wenn du dann auf ein Element daraus zugreifen willst kannst du das mit der Punkt Syntax machen (*tmp).new oder aber die Kurzschreibweise mit dem Pfeil tmp->new. Bei dem Pfeil ist eben kein dereferenzieren mehr dabei.
Übrigens ist mir da schon ein Fehler in der ersten Zeile bei deinem Append aufgefallen. Dein neu ist kein Pointer was es aber sein sollte, weil sonst ja der gesamte Sinn von malloc verloren geht.

So schlimm is es nicht. Ich glaub dir fehlt nur der Pointer als echter Datentyp an Wissen und dann würd schon alles rennen.
Wie gesagt, C ist weder kompliziert noch komplex, es ist ja gerade weil doch sehr nahe an der Hardware eher einfach. Java find ich da viel komplexer, weil jede kleine Bibliotheksfunktion in Wirklichkeit ein wahnsinns Aufand ist.

da mein rehcner endlich mal wieder rennt hab ich es noch gschwind ausprogrammiert.

der "fallstrick" hier ist, dass IntList selbst schon ein zeiger ist. du hast somit beim append einen zeiger auf einen zeiger.

Code:

void Append(IntList *l, int n)
{ 
	if(*l == 0) {
		*l = (IntList)malloc(sizeof(elemtype));
		(*l)->next = 0;
		(*l)->wert = n;
	} else {	
		IntList tmp = *l;
		while(tmp->next != 0)
			tmp = tmp->next;
			
		IntList neu = (IntList)malloc(sizeof(elemtype));
		neu->next = 0;
		neu->wert = n;
		tmp->next = neu;
	}

}

overclockers.at v4.thecommunity
© all rights reserved by overclockers.at 2000-2025