使用 if else 语句对数组进行排序

Question

所以，我正在使用 java 进行一个项目，在该项目中我必须输入一个字符串并计算字符串中字符的频率。然后，我必须将字符分为四类：文本、空格、数字和符号。我正在寻找一种方法来做到这一点。为了计算字符串中的频率，这是我目前所拥有的：

    char[] charArray = userSort.toCharArray();
        char tempChar;
        for (int i = 0; i < charArray.length; i++) {
            for (int j = 0; j < charArray.length; j++) {
                if (charArray[i] < charArray[j]) {
                    tempChar = charArray[i];
                    charArray[i] = charArray[j];
                    charArray[j] = tempChar;]

我也有关于如何使用 if-else 语句对这些语句进行排序和打印的概念。

 int whiteSpace = 0;
            int textual = 0;
            int numerical = 0;
            int symbols = 0;

        if() {
            whiteSpace++;
        }

        else if (){
            textual++;
            }

        else if (){
            numerical++;
        }
        else {
            symbols++;
        }
            System.out.println("Textual Character count: " + textual);
            System.out.println("Numerical Character count: " + numerical);
            System.out.println("Whitespace Character count: " + whiteSpace);
            System.out.println("Symbol character count: " + symbols);

我只是不确定我使用 if else 语句将其保留在特定类别中。我也不确定如何将两个代码组合在一起。任何帮助表示赞赏，谢谢。

另外，我不能使用内置 java 排序函数或类似的东西。

Answer 1

这里是您的起点，使用地图存储计数：

import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;

public class TestCount {

    public static void main( String[] args ) {

        String myString = "abc abc abc abc aaabbbccc 0000 *&% a";
        int whiteSpace = 0;
        int textual = 0;
        int numerical = 0;
        int symbols = 0;

        char[] data = myString.toCharArray();
        Arrays.sort( data );

        Map<Character, Integer> countMap = new LinkedHashMap<>();
        for ( char c : data ) {
            if ( countMap.containsKey( c ) ) {
                countMap.put( c, countMap.get( c ) + 1 );
            } else {
                countMap.put( c, 1 );
            }
        }

        for ( Map.Entry<Character, Integer> e : countMap.entrySet() ) {

            char key = e.getKey();
            System.out.printf( "%c -> %d occurences\n", e.getKey(), e.getValue() );

            if ( ( key >= 'a' && key <= 'z' ) || ( key >= 'A' && key <= 'Z' ) ) {
                textual += e.getValue();
            } else if ( key >= '0' && key <= '9' ) {
                numerical += e.getValue();
            } else if ( key == ' ' ) {
                whiteSpace += e.getValue();
            } else {
                symbols += e.getValue();
            }

        }

        System.out.printf( "%d are textual characters\n", textual );
        System.out.printf( "%d are numerical characters\n", numerical );
        System.out.printf( "%d are whitespace characters\n", whiteSpace );
        System.out.printf( "%d are symbol characters\n", symbols );

    }

}

编辑：

这是一个简单而肮脏的解决方案，没有使用排序和地图等内置功能。它将字符代码（表示字符的整数）映射到数组位置。由于字符是有序的，数据数组的最后一个字符是代码较大的字符，将是最后一个有效的数组位置。

public class TestCount {

    public static void main( String[] args ) {

        String myString = "abc abc abc abc aaabbbccc 0000 *&% a";
        int whiteSpace = 0;
        int textual = 0;
        int numerical = 0;
        int symbols = 0;

        char[] data = myString.toCharArray();
        mySort( data );

        // a counting array. it will waste a lot of space, but it will work
        int[] countArray = new int[ (int) data[data.length-1] + 1 ];

        for ( char c : data ) {
            countArray[ (int) c ]++;
        }

        char lastChar = '\0';
        for ( char c : data ) {

            if ( c != lastChar ) {
                System.out.printf( "%c -> %d occurences\n", c, countArray[ (int) c ] );
            }

            if ( ( c >= 'a' && c <= 'z' ) || ( c >= 'A' && c <= 'Z' ) ) {
                textual++;
            } else if ( c >= '0' && c <= '9' ) {
                numerical++;
            } else if ( c == ' ' ) {
                whiteSpace++;
            } else {
                symbols++;
            }

            lastChar = c;

        }

        System.out.printf( "%d are textual characters\n", textual );
        System.out.printf( "%d are numerical characters\n", numerical );
        System.out.printf( "%d are whitespace characters\n", whiteSpace );
        System.out.printf( "%d are symbol characters\n", symbols );

    }

    public static void mySort( char[] array ) {
        for ( int i = 0; i < array.length; i++ ) {
            for ( int j = 0; j < array.length-1; j++ ) {
                if ( array[j] > array[j+1] ) {
                    char t = array[j];
                    array[j] = array[j+1];
                    array[j+1] = t;
                }
            }
        }
    }

}

编辑 2： 一种更节省空间的方法：

public class TestCount {

    public static void main( String[] args ) {

        String myString = "abc abc abc abc aaabbbccc 0000 *&% a";
        int whiteSpace = 0;
        int textual = 0;
        int numerical = 0;
        int symbols = 0;

        char[] data = myString.toCharArray();
        mySort( data );

        // a counting array. it will waste a lot of space, but it will work
        int[] countArray = new int[ (int) data[data.length-1] + 1 - (int) data[0]  ];

        for ( char c : data ) {
            countArray[ map(data[0], c) ]++;
        }

        char lastChar = '\0';
        for ( char c : data ) {

            if ( c != lastChar ) {
                System.out.printf( "%c -> %d occurence(s)\n", c, countArray[ map(data[0], c)  ] );
            }

            if ( c >= 'A' && c <= 'z' ) {
                textual++;
            } else if ( c >= '0' && c <= '9' ) {
                numerical++;
            } else if ( c == ' ' ) {
                whiteSpace++;
            } else {
                symbols++;
            }

            lastChar = c;

        }

        System.out.printf( "%d are textual characters\n", textual );
        System.out.printf( "%d are numerical characters\n", numerical );
        System.out.printf( "%d are whitespace characters\n", whiteSpace );
        System.out.printf( "%d are symbol characters\n", symbols );

    }

    public static int map( char leftBoundary, char charToMap ) {
        return (int) charToMap - (int) leftBoundary;
    }

    public static void mySort( char[] array ) {
        for ( int i = 0; i < array.length; i++ ) {
            for ( int j = 0; j < array.length-1; j++ ) {
                if ( array[j] > array[j+1] ) {
                    char t = array[j];
                    array[j] = array[j+1];
                    array[j+1] = t;
                }
            }
        }
    }

}

Answer 2

您可以使用 HashMap 来计算字符的频率，其中字符本身就是键，并在找到该值时递增该值。你当前的算法是 O(n^2) 因为你在另一个里面有一个 for 但是如果你在 O(n) 上使用 hashmap dicrease

例如。

    String text = "Hello world";
    HashMap<Character, Integer> chars = new HashMap<>();
    for(int i = 0; i < text.length(); i++){

        //Get the current char
        char letter = text.charAt(i);

        //If the hashmap has the key is a new ocurrence
        if(chars.containsKey(letter)){
            chars.put(letter, chars.get(letter) + 1);
        }else{
            chars.put(letter, 1);
        }
    }

然后你必须对键进行分类。

    for(char tempChar : chars.keySet()){
        //Sort the current char by type
    }

您有两次时间复杂度为 O(n) 的迭代。所以最后是O(n)，没有O(n^2)。

您当前的算法不适用于大量数据。

检查这个以了解原因。 Big-O Algorithm Complexity

问候。

Answer 3

它应该像遍历你的 charArray 然后使用这些 if/else 一样简单。 为了知道一个元素是什么，你应该使用 ascii 分配表https://www.dotnetperls.com/ascii-java

   for (int i = 0; i < charArray.length; i++) {
       int asciiValue = int(charValue);

       if(asciiValue == 11 || (asciiValue >= 28 && asciiValue <= 31) {
           whiteSpace++;
       }
   }

对文本（65 - 90 和 97 - 122）、数字（48 - 57）和符号应用相同