[Java] object kopieren?

[BeachPatroller]

Ik heb het volgende fragment code

code:

        while (listNode.nextNode != null) {
            if (listNode.isGroterDan(listNode.nextNode))
            {
                Node tempNextNode = listNode.nextNode;
                listNode.nextNode = listNode;
                listNode = tempNextNode;
                swapCount++;
                swapped=true;
            }
            if(swapped)
              listNode = listNode.nextNode;

Ik wil nu NODE(i) omwissellen met NODE(i+1) echter gaat dit fout want:
stel listNode = a en listNode.nextNode =b.
bij
listNode.nextNode = listNode wijzigt listNode.nextNode netjes in a.
Maar de volgende regel, listNode = tempNextNode wordt listNode weer Node b. Dit heeft te maken met de 'pointers' (referenties). Hoe maak ik een copie van een zelfgecreeerd object i.p.v. een referentie naar een object? Ik kan ook met prev aan de gang maar deze oplossing lijkt me eenvoudiger. Ik wil dus een exacte 1 op 1 copie i.p.v. een referentie.

[nnomiS]

Elk object heeft een methode die clone heet.....

maar uuhm je wilt toch ook dat listnode maar b verwijst? je hebt eerst
listNode = a
listNode.nextNode = b
dan wil je toch daarna hebben
listNode = b
listNode.nextNode = a

?

[ Voor 66% gewijzigd door nnomiS op 29-03-2005 04:39 ]

[BeachPatroller]

Ja, dat staat er toch?
listNode.nextNode = listNode

Ik had ook al de search gebruikt maar keek even zonder bril en zag zojuist idd wat over Cloning staan. Thanx, ik ga ff proberen.

[nnomiS]

Opzich gaat het wel goed idd enige wat ik niet snap is waarom je als je 2 items omgedraait hebt gaat kijken of je wat omgedraait hebt en dan nog meer dingen doen. Dan kan je ze net zo goed erboven meteen bijzetten. En volgens mij is het ook niet nodig wat je daarna nog doet. Als het een raar verhaal is srry --> bedtijd

[Verwijderd]

Als 'listNode.nextNode' een pointer is naar de volgende node, kun je dan niet listNode.nextNode.get() gebruiken om het object zelf op te halen?

[Gerco]

Volgens mij gaat er iets helemaal verkeerd hier, (veranderende waardes zijn in elke stap bold):

ListNode: ID=A, NextNode = B
ListNode.NextNode: ID=B, NextNode = C
tempNextNode: leeg.

Java:

tempNextNode = Listnode.NextNode

Resultaat:

ListNode: ID=A, NextNode = B
ListNode.NextNode: ID=B, NextNode = C
tempNextNode: ID=B, NextNode = C

Vervolgens:

Java:

listNode.NextNode = ListNode

ListNode: ID=A, NextNode = A
ListNode.NextNode: ID=A, NextNode = A
tempNextNode: ID=B, NextNode = C

Hier gaat het dus fout, omdat ListNode en ListNode.NextNode nu hetzelfde object zijn, heb je een circulaire referentie gemaakt.

Vervolgens doe je:

Java:

listNode = tempNextNode;

Met als resultaat:

ListNode: ID=B, NextNode = C
ListNode.NextNode: ID=C, NextNode = D
tempNextNode: ID=B, NextNode = C

Omdat je nu B toewijst aan ListNode, ben je A helemaal kwijtgeraakt(tenzij er nog een Node voorzit die een referentie houdt naar A). B heeft namelijk zijn eigen NextNode, C.

[ Voor 15% gewijzigd door Gerco op 29-03-2005 08:41 ]

[BeachPatroller]

Bovenin heb ik listnode wel in een: Node bewaarLaatsteNode = listNode; gezet. Ik probeer even verder. Het klopt dat het fout gaat (heb al menigmaal debugged). Ik kan clone niet gebruiken. Ik moet dus een get maken? Of elke Node van prev voorzien? Het was al laat maar met 2 uur slaap kom ik er wel weer bovenop

Dit is dan het bijna werkende resultaat

code:

    do {
        swapCount = 0;
        swapped = false;
        Node bewaarLaatsteNode = listNode;
        while (listNode.nextNode != null) {
            if (listNode.isGroterDan(listNode.nextNode))
            {
                Node tempNextNode = listNode.nextNode;
                listNode.nextNode = bewaarLaatsteNode;
                listNode = tempNextNode;
                swapCount++;
                swapped=true;
            }
            if(swapped){
                swapped = false;
            }
            else{
                listNode = listNode.nextNode;
            }
              
        }


    } while (swapCount > 0);

   }
}

Echter krijgen alle Nodes de data van node A. Iemand idee wat hier nou echt fout gaat?

[ Voor 96% gewijzigd door BeachPatroller op 29-03-2005 10:07 ]

[Gerco]

Je denkt over je list als een Array, maar het is geen array. Het is een linked list van objecten en dat is iets heel anders. Je probeert de objecten fysiek om te draaien in het geheugen, maar dat is helemaal niet nodig. Dit is wat je zou kunnen doen:

Voor: A - B - C - D

code:

     /----\
Na: A   B  C ... D
         \/

A wijst dus nu naar C en C wijst naar B (en B wijst naar D, maar dat tekent lastig in ascii), logisch is de volgorde dus nu:

A - C - B - D

De locatie van de objecten in het geheugen is niet veranderd, alleen hun plaats in de lijst. De locatie in het geheugen is ook helemaal niet relevant. Ik hoop dat je hiermee wat verder komt.

[ Voor 12% gewijzigd door Gerco op 29-03-2005 10:55 ]

[Daos]

Gerco schreef op dinsdag 29 maart 2005 @ 10:50:
Je denkt over je list als een Array, maar het is geen array. Het is een linked list van objecten en dat is iets heel anders. Je probeert de objecten fysiek om te draaien in het geheugen, maar dat is helemaal niet nodig. Dit is wat je zou kunnen doen:

Voor: A - B - C - D

code:

     /----\
Na: A   B  C ... D
         \/

A wijst dus nu naar C en C wijst naar B (en B wijst naar D, maar dat tekent lastig in ascii), logisch is de volgorde dus nu:

A - C - B - D

De locatie van de objecten in het geheugen is niet veranderd, alleen hun plaats in de lijst. De locatie in het geheugen is ook helemaal niet relevant. Ik hoop dat je hiermee wat verder komt.

Simpel tekeningetje werkt altijd.


Je kan dat zo implementeren:

Java:

/*
A = bewaarLaatsteNode
B = listNode
C = tempNextNode = listNode.next
D = tempNextNode.next =  listNode.next.next
*/

// verwijzing A naar C
bewaarLaatsteNode.next = listnode.next; 
// verwijzing B naar D
listnode.next = listnode.next.next;
// verwijzing C naar B
bewaarLaatsteNode.next.next = listnode;

Het bewaren van de laatste node moet je doen net voordat je een nieuwe listnode maakt.
"bewaarLaatsteNode = listNode;" moet dus net voor "listNode = listNode.nextNode;" aan het eind van je loop. Bij de eerste keer is hij null.

[BeachPatroller]

Thanx! kom net uit het ziekenhuis, weer proberen.

[BeachPatroller]

Het gaat echter om een onbekend aantal Nodes, met de huidige techniek krijg ik de volgorde voor de eerste 3 wel goed. Maar steeds wanneer listNode = listNode.next plaatsvindt gaan de Nodes die ervoor staan verloren. Ik denk toch dat ik met een indexnummer aan de gang moet.

[Daos]

Alles is al genoemd om het werkend te krijgen.

Het duurt bij mijn PC erg lang voordat JBuilder is opgestart, daarom maar even in C.

C:

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

typedef struct {
    int value;
    void *next;
} node;


#define len 5
node *buildList() {
    int values[len] = {4, 2, 3, 5, 1};

    node *start;
    node *current;
    node *next;

    int i;

    start = malloc(sizeof(node));

    current = start;
    next = start;
    for (i = 0; i < len - 1; i++) {
        (*current).value = values[i];
        next = malloc(sizeof(node));
        (*current).next = next;
        current = next;
    }
    (*next).value = values[len - 1];
    (*next).next = 0;

    return start;
}

void printList(node *l) {
    node *n;

    while (l) {
        n = (*l).next;
        printf("%d\n", (*l).value);
        l = n;
    }

}

void freeList(node *l) {
    node *n;

    while(l) {
        n = (*l).next;
        free(l);
        l = n;
    }
}


int main() {
    node *start = buildList();

    node *bewaarLaatsteNode;
    node *listNode;
    int swapped = 1;


    printf("before:\n");
    printList(start);

    while (swapped) {
        swapped = 0;
        bewaarLaatsteNode = 0;
        listNode = start;

        while ((*listNode).next) {
            if ((*listNode).value > (*((node *)(*listNode).next)).value) {
                if (bewaarLaatsteNode == 0) {
                    start = (*listNode).next;
                    (*listNode).next = (*((node *)(*listNode).next)).next;
                    (*start).next = listNode;
                }
                else {
                    (*bewaarLaatsteNode).next = (*listNode).next;
                    (*listNode).next = (*((node *)(*listNode).next)).next;
                    (*((node *)(*bewaarLaatsteNode).next)).next = listNode;
                }

                swapped = 1;
            }

            bewaarLaatsteNode = listNode;
            listNode = (*listNode).next;
        }

    }
    printf("after:\n");
    printList(start);

    freeList(start);
}

[ Voor 6% gewijzigd door Daos op 30-03-2005 19:37 ]