如何在没有字符串或数组的情况下按升序排序整数数字?

我试图按升序排序任意长度的整数的数字,而不使用字符串,数组或递归。

例:

Input: 451467 Output: 144567 

我已经想出如何用模数除法得到整数的每个数字:

 int number = 4214; while (number > 0) { IO.println(number % 10); number = number / 10; } 

但我不知道如何在没有数组的情况下订购数字。

不要担心IO类; 这是我们教授给我们的定制课程。

实际上有一个非常简单的算法, 它只使用整数

 int number = 4214173; int sorted = 0; int digits = 10; int sortedDigits = 1; boolean first = true; while (number > 0) { int digit = number % 10; if (!first) { int tmp = sorted; int toDivide = 1; for (int i = 0; i < sortedDigits; i++) { int tmpDigit = tmp % 10; if (digit >= tmpDigit) { sorted = sorted/toDivide*toDivide*10 + digit*toDivide + sorted % toDivide; break; } else if (i == sortedDigits-1) { sorted = digit * digits + sorted; } tmp /= 10; toDivide *= 10; } digits *= 10; sortedDigits += 1; } else { sorted = digit; } first = false; number = number / 10; } System.out.println(sorted); 

它将打印出1123447 。 这个想法很简单:

  1. 你取出你想要排序的数字的当前数字(我们称之为N)
  2. 你浏览已排序的数字中的所有数字(让我们称之为S)
  3. 如果S中的当前数字小于N中的当前数字,则只需将数字插入S中的当前位置。否则,您只需转到S中的下一个数字。

该版本的算法可以在asc命令中进行排序,您只需要更改条件。

另外,我建议你看一下所谓的Radix Sort , 这里的解决方案从基数排序中得到一些想法,我认为基数排序是该解决方案的一般情况。

这是4行,基于while循环的for循环变体,带有一点java 8 spice:

 int number = 4214; List numbers = new LinkedList<>(); // a LinkedList is not backed by an array for (int i = number; i > 0; i /= 10) numbers.add(i % 10); numbers.stream().sorted().forEach(System.out::println); // or for you forEach(IO::println) 

我假设你被允许使用哈希。

 public static void sortDigits(int x) { Map digitCounts = new HashMap<>(); while (x > 0) { int digit = x % 10; Integer currentCount = digitCounts.get(digit); if (currentCount == null) { currentCount = 0; } digitCounts.put(x % 10, currentCount + 1); x = x / 10; } for (int i = 0; i < 10; i++) { Integer count = digitCounts.get(i); if (count == null) { continue; } for (int j = 0; j < digitCounts.get(i); j++) { System.out.print(i); } } } 

如何在不使用数组,字符串或排序API的情况下对数字进行排序? 好吧,您可以按照以下简单步骤对数字进行排序(如果读取的内容太多,请参阅下面的调试输出以了解排序是如何完成的):

  1. 使用(数字=数字%10)获取数字的最后一位数字
  2. 除以最后一位数后的数字(数字/ = 10)
  3. 循环数字的数字(没有数字)并检查数字是否最小
  4. 如果找到新的较小数字,则替换数字=最小数字并继续查看直到结束
  5. 在循环结束时,您找到了最小的数字,存储它(store =(store * 10)+ digit
  6. 现在你知道这是最小的数字,从数字中删除这个数字并继续将上述步骤应用于余数,每次找到一个较小的数字,然后将其添加到商店并从数字中删除数字(如果数字重复,然后将它们全部删除并将它们添加到商店)

我在main方法和一个函数中提供了两个while循环的代码。 该函数什么都不做,但是,构建一个新的整数,不包括传递给的数字,例如我传递函数451567和1,函数返回45567(以任何顺序,无关紧要)。 如果此函数通过451567和5,那么它会找到5位数字并将它们添加到存储并返回没有5位数的数字(这样可以避免额外处理)。

调试,知道如何对整数进行排序:

最后一位是:7的数字:451567
子块是45156
子块是4515
子块是451
Subchunk是45
Subchunk是4
451567中的小数字为1
店铺是:1
从451567中删除1
减少的数量是:76554
最后一位是:数字中的4:76554
子块是7655
Subchunk是765
Subchunk是76
Subchunk是7
76554中的数字为4
店铺是:14
从76554删除4
减少的数量是:5567
最后一位是:7的数字:5567
子块是556
Subchunk是55
子块是5
5567的数字是5
店铺是:145
从5567中删除5
找到重复的最小数字5。 店铺是:145
重复的最小数字5添加到商店。 更新的商店是:1455
减少的数量是:76
最后一位是:数字6:76
Subchunk是7
76中的数字是6
商店是:14556
从76中删除6
减少的数量是:7
最后一位是:数字7:7
7中的数字是7
店铺是:145567
从7中删除7
减少的数量是:0
升序451567是145567

示例代码如下:

 //stores our sorted number static int store = 0; public static void main(String []args){ int number = 451567; int original = number; while (number > 0) { //digit by digit - get last most digit int digit = number % 10; System.out.println("Last digit is : " + digit + " of number : " + number); //get the whole number minus the last most digit int temp = number / 10; //loop through number minus the last digit to compare while(temp > 0) { System.out.println("Subchunk is " + temp); //get the last digit of this sub-number int t = temp % 10; //compare and find the lowest //for sorting descending change condition to t > digit if(t < digit) digit = t; //divide the number and keep loop until the smallest is found temp = temp / 10; } System.out.println("Smalled digit in " + number + " is " + digit); //add the smallest digit to store store = (store * 10) + digit; System.out.println("Store is : " + store); //we found the smallest digit, we will remove that from number and find the //next smallest digit and keep doing this until we find all the smallest //digit in sub chunks of number, and keep adding the smallest digits to //store number = getReducedNumber(number, digit); } System.out.println("Ascending order of " + original + " is " + store); } /* * A simple method that constructs a new number, excluding the digit that was found * to be smallest and added to the store. The new number gets returned so that * smallest digit in the returned new number be found. */ public static int getReducedNumber(int number, int digit) { System.out.println("Remove " + digit + " from " + number); int newNumber = 0; //flag to make sure we do not exclude repeated digits, in case there is 44 boolean repeatFlag = false; while(number > 0) { int t = number % 10; //assume in loop one we found 1 as smallest, then we will not add one to the new number at all if(t != digit) { newNumber = (newNumber * 10) + t; } else if(t == digit) { if(repeatFlag) { System.out.println("Repeated min digit " + t + "found. Store is : " + store); store = (store * 10) + t; System.out.println("Repeated min digit " + t + "added to store. Updated store is : " + store); //we found another value that is equal to digit, add it straight to store, it is //guaranteed to be minimum } else { //skip the digit because its added to the store, in main method, set flag so // if there is repeated digit then this method add them directly to store repeatFlag = true; } } number /= 10; } System.out.println("Reduced number is : " + newNumber); return newNumber; } } 

我的算法:

 int ascending(int a) { int b = a; int i = 1; int length = (int)Math.log10(a) + 1; // getting the number of digits for (int j = 0; j < length - 1; j++) { b = a; i = 1; while (b > 9) { int s = b % 10; // getting the last digit int r = (b % 100) / 10; // getting the second last digit if (s < r) { a = a + s * i * 10 - s * i - r * i * 10 + r * i; // switching the digits } b = a; i = i * 10; b = b / i; // removing the last digit from the number } } return a; } 

添加一个非常简单的算法,不需要任何数据结构或花哨的数学,就像其他人一样。

 int number = 65356; for (int i = 0; i <= 9; i++) { // the possible elements are known, 0 to 9 int tempNumber = number; while (tempNumber > 0) { int digit = tempNumber % 10; IO.print(digit); tempNumber = number / 10; } } 

用语言:
1.在数字中每0打印一个0。
2.在数字中每1打印1。

这是一个简单的解决方案:

  public class SortDigits { public static void main(String[] args) { sortDigits(3413657); } public static void sortDigits(int num) { System.out.println("Number : " + num); String number = Integer.toString(num); int len = number.length(); // get length of the number int[] digits = new int[len]; int i = 0; while (num != 0) { int digit = num % 10; digits[i++] = digit; // get all the digits num = num / 10; } System.out.println("Digit before sorting: "); for (int j : digits) { System.out.print(j + ","); } sort(digits); System.out.println("\nDigit After sorting: "); for (int j : digits) { System.out.print(j + ","); } } //simple bubble sort public static void sort(int[] arr) { for (int i = 0; i < arr.length - 1; i++) for (int j = i + 1; j < arr.length; j++) { if (arr[i] > arr[j]) { int tmp = arr[j]; arr[j] = arr[i]; arr[i] = tmp; } } } } 
 class SortDigits { public static void main(String[] args) { int inp=57437821; int len=Integer.toString(inp).length(); int[] arr=new int[len]; for(int i=0;i