Warum gibt er die Liste rückwärts aus!

[Bierhumpen]

Warum gibt er die liste falschrum aus... er gibt sie absteigend aus... aber es soll aufsteigend ausgegeben werden?!

public class Node 
{
   Node link;
   Object data;

   Node(Object d, Node n) 
   {
      data = d; link = n;  
   }
}

import java.util.*;

class Lotto{

    
    static Node convertAndSort(int [] arr){
        Arrays.sort(arr);
        Node list = null;
        
        for (int i=0; i<arr.length; i++){
            list = new Node (new Integer (arr[i]), list);
        }
        
        return list;
            
    }
    
    
    static void printList(Node n){   
      while (n != null){
        System.out.print(n.data+" "); n = n.link; }
      System.out.println();
    }
    
    
    static void playIt(){
        
    }
    
    
    public static void main (String [] args) throws Exception{
    
        int [] a = {1,3,5,6,4,4};
        printList(convertAndSort(a));
        
    }
}

 

[bygones]

hä ? warum erstellst du in convertAndSort eine Instanz von Node und überschreibst die immer ?

 

[Oskar]

Deine Methode

static Node convertAndSort(int [] arr){
        Arrays.sort(arr);
        Node list = null;
       
        for (int i=0; i<arr.length; i++){
            list = new Node (new Integer (arr[i]), list);
        }
       
        return list;
           
    }

Gibt am Ende eine Referenz auf das letze Objekt zurück !?
Und dann durchläufst du die Methode von Hinten nach vorne bis es kein vorheriges Objekt mehr gibt.

Um das zu erreichen was du willst müsste sie so aussehen:

static Node convertAndSort(int [] arr){
        Arrays.sort(arr);
        Node currNode = null;
       
        for (int i=arr.length-1; i=>0; i--){
            currNode = new Node (new Integer (arr[i]), currNode);
        }
       
        return currNode;
           
    }

Du musst die for-Schleife umdrehen, damit er dir das erste Element zurückgibt und beim größten der Nachfolgewert null ist.

hm hoffe das stimmt so.

 

[Bierhumpen]

hmm wird damit nicht das problem umgangen anstatt behoben?!

 

[SlaterB]

sogesehen werden Probleme ja immer umgangen statt behoben

Arrays.sort(array) ist nun mal ein einzelner Befehl, der kann nicht wisse wie du es gerne hättest,
der kann nur aufwärts oder abwärts sortieren,

wenn er es andersrum machen würde dann könntest du
> Warum gibt er die liste falschrum aus... er gibt sie absteigend aus
das hier schreiben:
> Warum gibt er die liste falschrum aus... er gibt sie aufsteigend aus

und die Situation wäre nicht anders,
du musst dein Programm also immer den Gegebenheiten anpassen,
z.B. nach dem sort das Array umdrehen, notfalls per Hand in einer Schleife,
kommt aber praktisch auf das gleiche heraus

oder beim sort einen Comparator mitgeben der für deine Anforderungen richtig sortiert

 

[Oskar]

Dann stellt sich die Frage wie deine Liste aussehen soll. ???:L

Ich bin davon ausgegangen, dass du sie von ersten (kleinsten) Element bis zum letzten Element durchgehen und jeweils den Wert auslesen willst der als nächstes kommt.

Oder hast du anderes vor? :roll:

 

[Bierhumpen]

okay.
also Arrays.sort sortiert doch von klein nach groß oder wird das auf eine bestimmte art und weise bestimmt dass er es ab- oder aufsteigend macht?!

ich bin davon ausgegangen dass Arrays.sort von klein nach groß sortiert, und wollte es auch in dieser reihenfolge in die liste schreiben.

 

[Guest]

Nicht die Sortierung ist das Problem, sondern deine komische Verkettung.
Was du da in der Schleife machst, ist LIFO (Last In, First Out).

 

[Bierhumpen]

hmmm okay... kann mir so ungefähr vorstellen was du damit meinst. wie dreh ich dass denn dann um?! ausser mit i=arr.length-1 zu beginnen?!
stimmt es denn das sort von klein nach groß sortiert?!

 

[Guest]

hmmm okay... kann mir so ungefähr vorstellen was du damit meinst. wie dreh ich dass denn dann um?! ausser mit i=arr.length-1 zu beginnen?!

public class Node
{
  Node next;
  Object data;

  Node(Object d, Node previous)
  {
     data = d;
     if(previous!=null)
       previous.next = this;
  }
}

...

static Node convertAndSort(int [] arr)
{
  Arrays.sort(arr);

  Node first = new Node(new Integer(arr[0]), null);
  Node node = first;
  for (int i=1; i<arr.length; i++)
  {
    node = new Node(new Integer(arr[i]), node);
  }
  return first;
}

stimmt es denn das sort von klein nach groß sortiert?!

Ja. Es sei denn, du verwendest einen Comparator...

 

[Bierhumpen]

hmm ganz nett.. allerdings soll die Node.java nicht verändert werden

ach ist ja auch schnurz. die methode heisst convertandsort, und das tut sie ja...

gelöst [close]

 

[L-ectron-X]

Wenn ein Beitrag für dich erledigt ist, markiere ihn mit dem Häkchen.

 

[Bierhumpen]

ach da okay alles klar.. ich dachte es können nur admins/moderatoren.... wer suchet der findet...