Как сортировать номера сортировки (по возрастанию/убыванию) путем сортировки пузырьков?

Question

мне нужна помощь по использованию пузырьковой сортировки и сортировки его ли восходящем или нисходящем :(

  int[] number = {12, 5, 6, 14, 18};  

     int[] number = new int[5]; 
     String[] mark = new String[10]; 
     String evenOrOdd = ""; 
     String output = ""; 

     JTextArea textArea = new JTextArea(12,30); 


     for(int i = 0; i < number.length; i++) { 
     number[i] = Integer.parseInt(JOptionPane.showInputDialog("Enter a number")); 

     if (number[i] % 2 == 0) { 
      evenOrOdd = "even"; 
     } 
     else { 
      evenOrOdd = "odd "; 
     } 

     mark[i] = ""; 
     for(int j = 0; j < number[i]; j++) { 
      mark[i] = mark[i] + "*"; 
     } 

     output = output + number[i] + "\t"; 
     output = output + evenOrOdd + "\t"; 
     output = output + mark[i] + "\n"; 
     } 

     textArea.setText("numbers\ttype\tgraph\n" + output); 
     JOptionPane.showMessageDialog(null, 
         textArea, 
            "OUTPUT", 
            JOptionPane.INFORMATION_MESSAGE);  
     System.exit(0); 
    } 
} 

}

код отсутствует пузырь сортировки и я не там, где его поставить. Может кто-то пожалуйста, помогите мне? это не нужно пользователю вводить что-либо,

Answer 1

То, как вы поддерживаете восходящие и нисходящие, чтобы передать Comparator вашему методу sort() и использовать его, чтобы проверить результаты сравнения элементов, как,

public static void bubbleSort(int[] numero, Comparator<Integer> comp) { 
    int n = numero.length; 
    int temp = 0; 
    for (int i = 0; i < n; i++) { 
     for (int j = 1; j < (n - i); j++) { 
      if (comp.compare(numero[j - 1], numero[j]) > 0) { 
       temp = numero[j - 1]; 
       numero[j - 1] = numero[j]; 
       numero[j] = temp; 
      } 
     } 
    } 
} 

По возрастанию считается по умолчанию для Comparable, как Integer. Таким образом, мы можем делегат в compareTo() как,

private static Comparator<Integer> ascending = new Comparator<Integer>() { 
    @Override 
    public int compare(Integer o1, Integer o2) { 
     return o1.compareTo(o2); 
    } 
}; 

Тогда нисходящий обратная восходящих, так делегат и обратное, как

private static Comparator<Integer> descending = new Comparator<Integer>() { 
    @Override 
    public int compare(Integer o1, Integer o2) { 
     return -ascending.compare(o1, o2); 
    } 
}; 

Затем проверить его

public static void main(String arg[]) { 
    int[] arr = { 10, 30, 20 }; 
    System.out.println(Arrays.toString(arr)); 
    bubbleSort(arr, ascending); 
    System.out.println("Ascending: " + Arrays.toString(arr)); 
    bubbleSort(arr, descending); 
    System.out.println("Descending: " + Arrays.toString(arr)); 
} 

Выход is

[10, 30, 20] 
Ascending: [10, 20, 30] 
Descending: [30, 20, 10]