Sortowanie tablicy łańcuchów znaków w odwrotnej kolejności alfabetycznej w Javie

Question

Zostałem za zadanie przekształcenie tego kodu w rodzaj odwrotny, ale z mojego życia nie mogę wymyślić, jak to zrobić. Są to moje rodzaje, najłatwiejsze i metody zamiany. Mam przeczucie, że brakuje mi czegoś oczywistego tutaj, każda pomoc będzie naprawdę doceniona.

public static void sort(String[] arr) 
    { 
     for (int pass = 1; pass < arr.length; pass++) 
     { 
      int largestPos = findLargest(arr, arr.length - pass); 
      if (largestPos != arr.length - pass) 
      { 
       swap(arr, largestPos, arr.length - pass); 
      } 
     } 
    } 

    public static int findLargest(String[] arr, int num) 
    { 
     int largestPos = 0; 
     for (int i = 1; i <= num; i++) 
     { 
      if (arr[i].compareToIgnoreCase(arr[largestPos]) > 0) 
      { 
       largestPos = i; 
      } 
     } 
     return largestPos; 
    } 

    public static void swap(String[] arr, int first, int second) 
    { 
     String temp = arr[first]; 
     arr[first] = arr[second]; 
     arr[second] = temp; 
    } 
} 

Answer 1

możesz użyć Arrays.sort(arr) do sortowania w kolejności alfabetycznej.

, a następnie odwróć go.

Answer 2

można po prostu włączyć findLargest do findSmallest, tak:

public static void sort(String[] arr) { 
    for (int pass = 1; pass < arr.length; pass++) { 
     int largestPos = findSmallest(arr, arr.length - pass); 
     if (largestPos != arr.length - pass) { 
      swap(arr, largestPos, arr.length - pass); 
     } 
    } 
} 

public static int findSmallest(String[] arr, int num) { 
    int largestPos = 0; 
    for (int i = 1; i <= num; i++) { 
     if (arr[i].compareToIgnoreCase(arr[largestPos]) < 0) { 
      largestPos = i; 
     } 
    } 
    return largestPos; 
} 

public static void swap(String[] arr, int first, int second) { 
    String temp = arr[first]; 
    arr[first] = arr[second]; 
    arr[second] = temp; 
} 

Answer 3

public static void sort(String[] arr) { 
    Arrays.sort(arr); 
    for (int i=0; i<arr.length/2; i++) { 
     swap(arr,i,arr.length-1-i); 
    } 
} 

Spróbuj tego, jeśli chcesz. W twojej wersji przesuwasz największy pod koniec tablicy, co prowadzi do porządku alfabetycznego.

wszelki wypadek nalegać na swoim oryginalnym podejściem, zrobiłem kilka drobnych zmian w kodzie:

public static void sort(String[] arr) 
{ 
    for (int pass = 1; pass < arr.length; pass++) 
    { 
     int largestPos = findLargest(arr, pass-1); 
     if (largestPos != pass - 1) 
     { 
      swap(arr, largestPos, pass - 1); 
     } 
    } 
} 

public static int findLargest(String[] arr, int num) 
{ 
    int largestPos = num; 
    for (int i = num+1; i < arr.length; i++) 
    { 
     if (arr[i].compareToIgnoreCase(arr[largestPos]) > 0) 
     { 
      largestPos = i; 
     } 
    } 
    return largestPos; 
} 

najbardziej trywialne jeden chociaż, jak sugeruje Ian Roberts, jest po prostu Arrays.sort(arr, Collections.reverseOrder());.

Answer 4

Myślę, że to jest to, czego potrzebujesz (jeśli nie myślisz o strukturze kolekcji).

public static void main(String args[]) { 


    String [] arr ={"abc","bac","cbc"}; 
      String temp=""; 

    for(int i=0;i<arr.length;i++){ 

     for(int j=i+1;j<arr.length;j++){ 

      if(arr[j].compareTo(arr[i]) > 0){ 

       temp = arr[i] ; 
       arr[i] = arr[j]; 
       arr[j] = temp; 
      } 
     } 

    } 

    for(String val:arr){ 
     System.out.println(val); 
    } 

} 

Wyjście jest

cbc 
bac 
abc 

Answer 5

Nie wyważać otwartych drzwi -

String[] strs = {"a", "b", "d", "c", "e"}; 

Arrays.sort(strs, Collections.reverseOrder(String.CASE_INSENSITIVE_ORDER)); 

System.out.println(Arrays.toString(strs)); 

 
[e, d, c, b, a] 

Answer 6

następczych ARS za odpowiedź:

Można użyć niestandardowego komparator, jeśli wolno używać t on Arrays.Sort metodę ...

Arrays.sort(stringArray, new Comparator<String>() { 
      @Override 
      public int compare(String t, String t1) { 
       return -t.compareToIgnoreCase(t1); //reverse the comparison, while ignoring case 
      } 
     }); 

Answer 7

Więc, najpierw musimy stworzyć tablicę ciągów, a następnie użyć Arrays.sort(String[]);, a następnie użyć for odwrócić tablicę sortowania, aby odwrócić kolejność.

import java.util.Arrays; 

public class SortClass { 
    public static void main(String[] args) { 
     String[] arrayString = new String[5]; 
     arrayString[0] = "Cat"; 
     arrayString[1] = "Apple"; 
     arrayString[2] = "Dog"; 
     arrayString[3] = "Mouse"; 
     arrayString[4] = "kitchen"; 
     Arrays.sort(arrayString); 
     String[] arrReverse = new String[arrayString.length]; 
     for (int i = arrayString.length - 1; i >= 0; i--) { 
      arrReverse[arrayString.length - 1 - i] = arrayString[i]; 

     } 
    } 
}