Pointer Tausch

[sheel]

Noch einmal: Was ist der "value" pro Knoten?
Zeig doch einfach einmal die Struktur her...

 

[Jennesta]

deepthroat hat dir doch dein Beispiel geliefert. Wenn das nicht funktioniert, dann machst du irgendwas falsch. Aber wie sollen wir den Fehler finden, wenn du nicht einmal den kompletten Code zeigst, der zum Verständnis eurer Lösung hilft?

 

[Scal]

Den habe ich ja gepostet. Tmp zeigt auf C. Also Temp next zeigt dann ja auf B. Jetzt setze ich Personlist auf temp -> next, also auf B. Danach setze ich Personlist -> next auf temp, das war ja C. Und in der letzen Zeile halt noch das Gleiche. Irgendwo aber verlier ich hier etwas oder es lauft was schief.

Personlist = temp -> next;
Personlist -> next = temp;
Personlist -> next -> next = temp2 -> next;

 

[sheel]

deepthroat hat dir doch dein Beispiel geliefert. Wenn das nicht funktioniert, dann machst du irgendwas falsch.

Ack

Aber wie sollen wir den Fehler finden, wenn du nicht einmal den kompletten Code zeigst, der zum Verständnis eurer Lösung hilft?

Inzwischen haben drei Leute nach mehr Code gefragt,
weil so nicht geholfen werden kann.

 

[Scal]

Das ist die Funktion, sort1 und sort2 sind Werte die ich im Moment ausgeblendet habe.
Die Funktion bekommt PERSON* Person_list. Wir haben ein Struct geschrieben welches immer einen Pointer auf das nächste hat. Das ist der ganze Code der Funktion.
----------------------------

void sort(PERSON* Person_list)
{
PERSON* tmp2 = Person_list;
PERSON* temp = Person_list->next;

if(sort_1 > sort_2)
{
printf("Pointertausch\n");

Personlist = temp -> next;
Personlist -> next = temp;
Personlist -> next -> next = temp2 -> next;
x = 999;
}

 

[Scal]

Neue Idee die leider auch nicht funktioniert hat:

tmp->next = tmp_2->next;
tmp_2->next = tmp;
Person_list = tmp_2;

 

[sheel]

So, noch ein mal:
Wenn du uns nur unzusammenhängende Codeschnipsel zeigst,
in denen nicht einmal ein einzelner Variablenname konsistent bleibt,
statt eventuell einmal eine ganze Datei inkl. der Strukturdefinition...
dann kann dir nicht geholfen werden.

 

[Matthias Reitinger]

Personlist = temp -> next;
Personlist -> next -> next = temp2 -> next;
Personlist -> next = temp;

Wieso funktioniert das nicht? :/

Habt ihr euch das mal auf einem Blatt Papier überlegt? Das Nachvollziehen hätte ich mir in etwa so vorgestellt:

Anfangszustand
==============

Personlist
  |
  V
+-------+      +-------+      +-------+
| C     |  +-->| B     |  +-->| A     |
| next: *--+   | next: *--+   | next: *--> NULL
+-------+      +-------+      +-------+
  ^              ^
  |              |
 temp          temp2


Personlist = temp->next;
========================

               Personlist
                 |
                 V
+-------+      +-------+      +-------+
| C     |  +-->| B     |  +-->| A     |
| next: *--+   | next: *--+   | next: *--> NULL
+-------+      +-------+      +-------+
  ^              ^
  |              |
 temp          temp2


Personlist->next->next = temp2->next;
=====================================

               Personlist
                 |              +--------+
                 V              V        |
+-------+      +-------+      +-------+  |
| C     |  +-->| B     |  +-->| A     |  |
| next: *--+   | next: *--+   | next: *--+
+-------+      +-------+      +-------+
  ^              ^
  |              |
 temp          temp2


Personlist->next = temp;
========================

  +-----------------------+
  |            Personlist |
  |              |        |     +--------+
  V              V        |     V        |
+-------+      +-------+  |   +-------+  |
| C     |  +-->| B     |  |   | A     |  |
| next: *--+   | next: *--+   | next: *--+
+-------+      +-------+      +-------+
  ^              ^
  |              |
 temp          temp2

Wie du siehst, ist das teils ziemlich unsinnig.

Schlussendlich willst du ja auf diese Konfiguration hinaus:

  +-----------------------+
  |            Personlist |
  |              |        |
  V              V        |
+-------+      +-------+  |     +-------+
| C     |      | B     |  | +-->| A     |
| next: *--+   | next: *--+ |   | next: *--> NULL
+-------+  |   +-------+    |   +-------+
           +----------------+

Mein Tipp: den Rechner ausmachen und sich tatsächlich mal mit einem Blatt Papier hinsetzen und sich in Ruhe überlegen, wie man vorgehen will. Einfach nur alle Permutationen direkt im Quellcode ausprobieren ist nicht zielführend.

Grüße
Matthias

 

[Scal]

Struktur:

typedef struct _PERSON_{
char name[20];

struct _PERSON_* next;
struct _FRIEND_* Friend_list;
}PERSON;

void sort(PERSON* Person_list)
{
PERSON* tmp = Person_list;
PERSON* tmp_2 = Person_list->next;


int x = 0;
int sort_1 = 0;
int sort_2 = 0;

while(x < strlen(Person_list->name) && x < strlen(Person_list->next->name))
{
sort_1 = toupper((int) *(Person_list->name+x));
sort_2 = toupper((int) *(Person_list->next->name+x));


if(sort_1 == sort_2)
{
x++;
}

else if(sort_1 > sort_2)
{

tmp->next = tmp_2->next;
tmp_2->next = tmp;
Person_list = tmp_2;
x = 999;
printf("%s\n", Person_list->name);
printf("%s\n", Person_list->next->name);
printf("%s\n", Person_list->next->next->name);




}

else {
printf("Passt\n");
x = 999;}
}
}

 

[Scal]

Also eine Frage, in der Funktion ändert der Code jetzt so wie er soll und vertauscht C mit B. Jedoch wenn ich dann in der main wieder ein printf mache, dann verliert er B und zeigt wieder C an.

Die main ruft nur die Funktion auf.