web-dev-qa-db-ja.com

文字列または配列なしで整数の数字を昇順で並べ替える方法は？

文字列、配列、または再帰を使用せずに、任意の長さの整数の数字を昇順で並べ替えようとしています。

例：

Input: 451467
Output: 144567

モジュラス除算を使用して整数の各桁を取得する方法はすでにわかっています。

int number = 4214;

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

しかし、配列なしで数字を順序付ける方法がわかりません。

IOクラスを心配しないでください。それは、教授が私たちに与えたカスタムクラスです。

javasortingmodulo
9
klayveR

実際には、整数のみを使用する非常に単純なアルゴリズムがあります：

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の次の数字に移動します。

そのバージョンのアルゴリズムは、昇順と昇順の両方でソートできます。条件を変更するだけです。

また、いわゆる Radix Sort 、解決策 here を参照することをお勧めします。基数ソートからいくつかのアイデアを取ります。そのソリューションのために。

6
Timofey

これは4行で、小さなJava 8スパイスのあるwhileループのforループバリアントに基づいています。

int number = 4214;

List<Integer> 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)
9
Bohemian

ハッシュの使用が許可されていると思います。

public static void sortDigits(int x) {
    Map<Integer, Integer> 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);
        }
    }
}
3
tharindu_DG

それを行う私のアルゴリズム：

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;
}
2
Abbas

配列、文字列、または並べ替えAPIを使用せずに数値を並べ替える方法は？さて、次の簡単な手順で数値を並べ替えることができます（読みにくい場合は、以下のデバッグ出力を参照して、並べ替えの方法を理解してください）。

  1. （数字=数字％10）を使用して、数字の最後の数字を取得します
  2. 最後の桁がなくなるように数値を除算します（数値/ = 10）
  3. 数字の数字（数字がない）をループし、数字が最小かどうかを確認します
  4. 新しい小さい数字が見つかった場合は、数字=最小の数字を置き換え、最後まで探し続けます
  5. ループの終わりに最小の数字を見つけて、それを保存します（store =（store * 10）+ digit
  6. これが最小の数字であることがわかったので、数字からこの数字を削除し、上記の手順を残りの数字に適用し続け、小さい数字が見つかるたびにストアに追加し、数字から数字を削除します（数字が数字で繰り返される場合、それらをすべて削除して、ストアに追加します）

Mainメソッドで2つのwhileループと1つの関数を含むコードを提供しました。関数は何もしませんが、渡される数字を除く新しい整数を作成します。たとえば、関数451567と1を渡すと、関数は45567を返します（順序は関係ありません）。この関数に451567と5が渡された場合、5桁の数字が両方とも検出され、5桁のない数字を格納および返すために追加されます（これにより、余分な処理が回避されます）。

デバッグ、整数のソート方法を知るには：

最後の桁は：数字の7：451567
サブチャンクは45156です
サブチャンクは4515
サブチャンクは451
サブチャンクは45
サブチャンクは4
451567の数字は1です
ストア：1
451567から1を削除
削減数：76554
最後の桁は：番号の4：76554
サブチャンクは7655です
サブチャンクは765です
サブチャンクは76
サブチャンクは7
76554の小数桁は4です
ストア：14
76554から4を削除
削減数：5567
最後の桁は：番号の7：5567
サブチャンクは556
サブチャンクは55
サブチャンクは5
5567の数字は5です
ストアは145
5567から5を削除
繰り返される最小桁5が見つかりました。ストアは145
最小桁5を繰り返してストアに追加しました。更新されたストア：1455
削減数：76
最後の桁は：数字の6：76
サブチャンクは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 b e 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; 
     }
}
2
Raf

他のようにデータ構造や派手な数学を必要としない非常に単純なアルゴリズムを追加します。

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を出力します。
...

1
Raimund Krämer
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<len;i++)
        {
            arr[i]=inp%10;
            inp=inp/10;
        }
        Arrays.sort(arr);
        int num=0;
        for(int i=0;i<len;i++)
        {
            num=(num*10)+arr[i];
        }
        System.out.println(num);
    }    
}
0
Arun Singh

簡単な解決策は次のとおりです。

    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;
                    }
                }
        }
    }
0
Pushparaj Dhole