verkette Liste- kleinstes Element hinten anhängen

[Sund0se]

Hi Leute, hätte ne Frage zu einer Schulaufgabe:

wir müssen in einer verketteten Liste das kleinste Element suchen und es ans Ende der Liste anhängen und dann einfach das Element aus der Liste löschen (Zeiger umhängen) und dass mit allen nicht sortierten Elementen, sodass es dann eine sortierte Liste wird.
Unser Lehrer will, dass wir nicht die Daten kopieren, sondern die Zeiger umhängen oder so und ich habe 0 Ahnung wie ich das machen soll.

Also ich würds ja so ähnlich machen: ende->next->daten = zeiger-auf-kleinstes-Elem->daten... aber das wäre ja daten kopieren!

brauche dringend hilfe, denn es handelt sich um eine wichtige Note!

Hier der Quellcode:

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

// Elementstruktur
struct Elem
{
	int data;
	struct Elem* next;	// Zeiger auf das nächste Element
	struct Elem* prev;	// Zeiger auf das vorherige Element
};

// Typdefinition
typedef struct Elem ElemT;

// Startzeiger
ElemT *root;

//*********** Prototypen ***************
ElemT *einfuegen(ElemT* liste,ElemT* elem); // einhängen am Ende der Liste
ElemT* aushaengen(ElemT* liste,ElemT* prev,ElemT* elem); // Zeiger elem nur aushängen nicht löschen
ElemT* randomListGeneratorSimple(int anzahl, int bereich);
void printList(ElemT* liste);
ElemT* Sort(ElemT* liste);

/**************************************************/
/*              Hauptprogramm                     */
/**************************************************/
int main ( void )
{
	int anzahl = 0, bereich = 0;
	printf("Anzahl: ");
	scanf("%d", &anzahl);
	printf("\nBereich: ");
	scanf("%d", &bereich);
	root = randomListGeneratorSimple(anzahl, bereich);
	printf("\n\n\nUnsortiert:\n\n");
	printList(root);
	Sort(root);
	system("PAUSE");
	return 0;
}
/*************************************************/
/*  Sortieren der Daten                          */
/*************************************************/
ElemT* Sort(ElemT* root)
{
	ElemT* ende, *ptr = root;

	/* Ende der Liste suchen */
	while( ptr->next != NULL )
		ptr = ptr->next;
	ende = ptr;
	/* Kleinstes Element suchen */
//...
//...
//...
        	einfuegen(root, ptr);
}
/*************************************************/
/*  Sortieren der Daten                          */
/*************************************************/
ElemT* einfuegen(ElemT* root, ElemT* ptr)
{

}

/******************************************************************************/
/*  Generierung der Liste										              */
/******************************************************************************/
ElemT* randomListGeneratorSimple(int anzahl, int bereich)
{
	struct Elem* ptr;
	struct Elem* prev;
	srand(time(0));

	for(int i=0;i<anzahl;i++)
	{
		ptr=(struct Elem*) malloc(sizeof(struct Elem));
	    ptr->data=rand()%bereich+1;
		if (i==0)
			root=ptr;
		else
			prev->next=ptr;
		prev=ptr;
	}
	ptr->next=NULL;
	return root;
}

/*************************************************/
/*  Ausgabe der Daten					         */
/*************************************************/
void printList(ElemT* root)
{
   ElemT *temp;
   temp=root;

	if (temp) //Bedeutung: temp!=NULL 
	{
		printf("--------- \n");
		printf("|Daten   |\n");
		printf("---------\n");

		while(temp!=NULL)
		{
			printf("%3d\n",temp->data);
			temp=temp->next;
		} 
	}
	else
		printf("\n\n->Keine Daten vorhanden!\n");  
}

[rüdiger]

Sund0se schrieb:

Also ich würds ja so ähnlich machen: ende->next->daten = zeiger-auf-kleinstes-Elem->daten... aber das wäre ja daten kopieren!

ende->next = zeiger-auf-kleinstes-Elem
zeiger-auf-Elem-vor-kleinstem-Elem->next = zeiger-auf-kleinstes-Elem->next