java上机面试题，算法

题目：{“aa”,“ab”,“abc”,“bc”,“bac”,“cab”,“abc”,“123”,“321”,“1”} 数组，找出字符中相同字符为一组，进行分组，比如abc和cab就是一组

今天说阿里有面试题就是上面，小G就抛转引玉的写了下，别喷， 思路： 第一： 使用素数，把字符对应不一样的素数，素数：只有1和本身可以整除的数，然后进行相乘，最后判断结果是否相同，相同就为相同元素组成字符串 第二： 1、先思考下输出是什么的数据结构 2、然后进行比较数组中字符中是否都包相同字符，得出结论就是，把数组中的字符串转化字符进行排序进行比对 3、string转化为char,然后排序，这样防止一个个遍历，就出现复杂度O(n^2)，如果排序后，在进行比较就是0(1),因为中间需要charAt有多少就需要遍历多少，所以这个地方我们家一个缓存tem

public class SomeTest {
          
   
    public static ScheduledThreadPoolExecutor executorService=new ScheduledThreadPoolExecutor(2);
    public static void main(String[] args) {
          
   
        SomeTest someTest=new SomeTest();
       String[] dataS={
          
   "aa","ab","abc","bc","bac","cab","abc","123","321","1"};

        List<String> listB= Arrays.asList(dataS);

        List<List<String>> result= someTest.setArrayList(listB);
        System.out.println(result.toString());


    }
    //分组
    public volatile List <List<String>> tem=new ArrayList<List<String>>();
    //排序获得缓存
    public volatile HashMap<Integer,String> temp=new HashMap<>();
    //["abc","cab","cad"]
    public List<List<String>> setArrayList(List<String> lists){
          
   
        tem.add(Collections.singletonList(lists.get(0)));
        if(lists.size()==0||lists.size()==1){
          
   
            return tem;
        }
        for(int i=1;i<lists.size();i++){
          
   
            //遍历加入新的组后注解比较，因为这个是一直增加，这个如果后面不加break；可重后想前加载，比如j=tem.size;j<0;j--
            for(int j=0;j<tem.size();j++){
          
   
                String data=lists.get(i);
                //比较
                if(!isSome(data,tem.get(j).get(0),j)){
          
   
                    if(tem.size()==j+1){
          
   
                        List<String> addNew=new ArrayList<String>();
                        addNew.add(data);
                        tem.add(addNew);
                        //不直接break就會出現，新增的重新變量一下tem
                        break;
                    }
                }else {
          
   
                    List<String> set=tem.get(j);
                    if(set==null){
          
   
                        System.out.println("异常");
                        continue;
                    }
                    set.add(lists.get(i));
                    break;
                }

            }

        }

        return tem;
    }
    //比较
    public Boolean isSome(String str,String someStr,int index){
          
   
        if(str.length()!=someStr.length()){
          
   
            return  false;
        }
        if(str.equals(someStr)){
          
   
            return true;
        }
        String someStrSort=temp.get(index);
        if(null==someStrSort){
          
   
            someStrSort= sort(someStr);
            temp.put(index,someStr);
        }
        String strSort=sort(str);
        System.out.println(String.format("%s 和 %s 比较",someStrSort,strSort));
        return someStrSort.toUpperCase().equals(strSort.toUpperCase());
    }
     //字符串排序
    public static  String sort(String someStr){
          
   
        someStr=someStr.toUpperCase();
        char [] temA =new char[someStr.length()];
        for(int i=0;i<someStr.length();i++){
          
   
            temA[i]=someStr.charAt(i);
        }
        Arrays.sort(temA);
        return String.valueOf(temA);

    }


}

打印：

AA 和 AB 比较
aa 和 BC 比较
AB 和 BC 比较
ABC 和 ABC 比较
abc 和 ABC 比较
abc 和 123 比较
abc 和 123 比较
123 和 123 比较
[[aa], [ab], [abc, bac, cab, abc], [bc], [123, 321], [1]]