java - 使用循环java按每个元素中的位数从最大到最小对数组进行排序

Question

我正在尝试按每个元素中的位数从最大到最小对数组进行排序。这在技术上是可行的，但它似乎也按值对数组进行排序。例如，它应该打印 1234 234 700 52 80，而不是打印 1234 700 234 80 52，因为 234 在原始数组中位于 700 之前。

public class Sort {    
    public static void main(String[] args) {        
        //Initialize array     
        int [] arr = new int [] {52, 234, 80, 700, 1234};     
        int temp = 0;    

        //Displaying elements of original array    
        System.out.println("Elements of original array: ");    
        for (int i = 0; i < arr.length; i++) {     
            System.out.print(arr[i] + " ");    
        }    

        //Sort the array in descending order
        //Math function is used to find length of each element    
        for (int i = 0; i < arr.length; i++) {    
            for (int j = i+1; j < arr.length; j++) {     
               if(Math.log10(arr[i]) + 1 < Math.log10(arr[j]) + 1) {    
                   temp = arr[i];    
                   arr[i] = arr[j];    
                   arr[j] = temp;    
               }     
            }     
        }    

        System.out.println();    

        //Displaying elements of array after sorting    
        System.out.println("Elements of array sorted in descending order: ");    
        for (int i = 0; i < arr.length; i++) {     
            System.out.print(arr[i] + " ");    
        }    
    }    
}

Answer 1

查找数字长度的最简单方法是将其转换为 String，然后对其调用方法 length。

int number = 123;
String numberAsString = String.valueOf(number);
int length = numberAsString.length(); // returns 3

但是你也可以通过除法来完成。以下方法接受一个数字并除以 10 的倍数。

• 除以 1(我们的长度至少为 1)
• 除以 10 > 0(长度至少为 2)
• 除以 100 > 0(长度至少为 3)
• ...

变量i用作被除数，变量j用作计数器。 j 计算数字的长度。

一旦 number/i 等于 0，我们就返回计数器值。

public int lengthOfNumber(int number) {
    if (number == 0) {
        return 1;
    }
    for (int i = 1, j = 0; ; i *= 10, j++) {
        if (number / i == 0) {
            return j;
        }
    }
}

有多种方法可以对数组进行排序。以下是一些示例(我使用字符串版本来比较值)。

使用嵌套for循环

public void sortArray(int[] array) {
    for (int i = 0; i < array.length; i++) {
        int swapIndex = -1;
        int maxLength = String.valueOf(array[i]).length();
        for(int j = i + 1; j < array.length; j++) {
            int length2 = String.valueOf(array[j]).length();
            if (maxLength < length2) {
                maxLength = length2;
                swapIndex = j;
            }
        }

        if (swapIndex > -1) {
            int temp = array[i];
            array[i] = array[swapIndex];
            array[swapIndex] = temp;
        }
    }
}

我使用了一个变量swapIndex，它是用-1初始化的。这样我们就可以避免不必要的数组操作。 我们获取外部 for 循环中的第一个元素，并在内部 for 循环中遍历数组的其余部分。如果数组的其余部分中有一个长度更大的数字，我们只会保存一个新的 swapIndex 。如果没有更大长度的数字，则 swapIndex 仍为 -1。如有必要，我们仅在外部 for 循环中进行可能的交换(如果设置了 swapIndex)。

使用Arrays.sort()

如果您想使用Arrays.sort，您需要将数组从基本类型int转换为Integer。

public void sortArray(Integer[] array) {
    Arrays.sort(array, (o1, o2) -> {
        Integer length1 = String.valueOf(o1).length();
        Integer length2 = String.valueOf(o2).length();
        return length2.compareTo(length1);
    });
}

使用递归方法

public void sortArray(int[] array) {
    for (int i = 0; i < array.length - 1; i++) {
        String current = String.valueOf(array[i]);
        String next = String.valueOf(array[i + 1]);

        if (current.length() < next.length()) {
            int temp = array[i];
            array[i] = array[i + 1];
            array[i + 1] = temp;

            // here you do a recursive call
            sortArray(array);
        }
    }
}