Struktur Zeiger auf Zeiger zuweisungsfrage

[Alex4nder]

Tag Leute, min grade dabei ein Mergesort Programm(einfach verkettete Liste) zu schreiben hab aber Verständnisprobleme mit dem Zeiger auf Zeiger.

In Zeile 34 erzeuge ich einen Zeiger auf Zeiger.
Er ist dafür gedacht sich bis zum Ende der Liste durchzuhangeln damit ich das nächste Element am Ende der neuen Liste einsetzen kann bzw. den Zeiger aus einer der Listen umleite.
Leider komme ich mit dem Handling nicht ganz klar.
Grob gesagt Zeile 47 bis 63.
Mir ist durchaus klar, dass ich einfach einen Zeiger erstellen kann der immer auf das Ende der Liste zeigt. Will es aber mit dem Zeiger auf Zeiger lösen.

typedef struct liste{
	int groesse;
	struct element *erstes;
}list;

typedef struct element {
	double zahl;
	struct element *next;
}ele;

list mergesort(list liste){
	if(liste.groesse <= 1){
		return liste;
	}
	else{
		//neien Element Zeiger erzeugen
		ele *ZeigerAufEle;
		//Den neuen Zeiger auf das Erste Element verweisen
		ZeigerAufEle=liste.erstes;
		//Den neuen Zeiger an die suche Ele übergeben
		ZeigerAufEle=sucheEle(ZeigerAufEle, liste.groesse/2+liste.groesse%2);
		//Listenkopf Recht erzeugen
		list ListeRechst;
		ListeRechst=listinit();
		//An die rechte Liste die Hälfte der liste zuweisen
		ListeRechst.erstes=ZeigerAufEle->next;
		//Größenangabe der rechten liste anpassen
		ListeRechst.groesse=liste.groesse/2;
		//Größenangabe der Linken Liste anpassen, bei ungeraden zahlen ist diese um ein Element größer
		liste.groesse=liste.groesse/2+liste.groesse%2;
		//Die liste in der Mitte auf Null Setzen. Jetzt hat man zwei listen
		ZeigerAufEle->next=NULL;

		ListeRechst=mergesort(ListeRechst);
		liste=mergesort(liste);
		return merge(liste, ListeRechst);
	}
}

list merge(list linke, list rechte){
	list neueListe;
	neueListe=listinit();
	neueListe.groesse=linke.groesse+rechte.groesse;
	ele **ppEle;
	//Speicherreservierung für den Zeiger auf Zeiger
	ppEle=(ele**)malloc(sizeof(ele));
	//solange (linkeListe und rechteListe nicht leer)
	while(linke.erstes!=NULL && rechte.erstes!=NULL){
		//falls (erstes Element der linkeListe <= erstes Element der rechteListe)
		if(linke.erstes->zahl<=rechte.erstes->zahl){
			//dann füge erstes Element linkeListe in die neueListe hinten ein und entferne es aus linkeListe
			//sucht das ende der neuenListe
			if(neueListe.erstes==NULL){
				neueListe.erstes=linke.erstes;
				linke.erstes=linke.erstes->next;
				neueListe.erstes->next=NULL;
				ppEle=&neueListe.erstes;
			}
			else{
				//Ende der neuenListe finden bzw bis zum ende durchhangeln
				while(ppEle!=NULL){
					(*ppEle)=(*ppEle)->next;
				}
				(*ppEle)->next=linke.erstes;
				linke.erstes=linke.erstes->next;
				(*ppEle)->next=NULL;
			}
		}
		else{
			//sonst füge erstes Element rechteListe in die neueListe hinten ein und entferne es aus rechteListe
			while(ppEle!=NULL){
				ppEle=&(*ppEle)->next;
			}
		}
	}
	return neueListe;
}

ele *sucheEle(ele *pEle, int anzahl){
	//ele *pGesucht;
	//pGesucht=(ele*)malloc(sizeof(ele));
	//pGesucht=pEle;
	int i;
	for (i=2; i<=anzahl; i++){
		if(pEle->next !=NULL)
			pEle=pEle->next;
	}
	return pEle;
}

Dakne für die Hilfe.

[mgaeckler]

Servus,

a bisserl confus ist des schon, was Du da machst. Mir ist aufgefallen:

ppEle=(ele**)malloc(sizeof(ele));

Wozu das? Den speicher nutzt du nie wieder, denn:

ppEle=&neueListe.erstes;

Ausserdem willst Du ja 'nen Zeiger auf 'nen Zeiger also so:

ppEle=(ele**)malloc(sizeof(ele *));

Was soll dieser Unfug?

while(ppEle!=NULL){
                ppEle=&(*ppEle)->next;
            }

Schneller geht's so:

ppEle = NULL;

Und das da:

while(ppEle!=NULL){
                    (*ppEle)=(*ppEle)->next;
                }

Solltest Du auch überdenken. Das erzeugt eine Endlosschleife und Du schrottest Dir neueListe.erstes, da ja ppEle immer noch darauf zeigt.

Mach dir mal lieber 'nen neuen Code. Der da ist Müll.

mfg Martin

[Alex4nder]

Ok, dass der Code schlecht ist sehe ich ein.
unabhängig davon hab ich folgendes gesucht.

while(*ppEle!=NULL){
			(ppEle)=&((*ppEle)->next);
}

[mgaeckler]

Alex4nder schrieb:

Ok, dass der Code schlecht ist sehe ich ein.
unabhängig davon hab ich folgendes gesucht.

while(*ppEle!=NULL){
			(ppEle)=&((*ppEle)->next);
}

Nicht gefunden?

Zeile 61-63.

Kenne ich etwa Deinen Code besser wie Du selbst?

mfg Martin