Java模拟面试题

这个牛客的模拟题，现在将遇到的一些知识点分享出来，看看在平时的准备中，我们应该关注那些方面：


1、String类型如何转换成int或int[]类型


将String转换成int的方法如下：
通过#Integer.parseInt(str)方法或者是#Integer.valueOf(str).intValue();
这两种方法的区别在于第一种方法：i=Integer.parseInt(str);//直接使用静态方法，不会产生多余的对象，但会抛出异常
第二种方法：i=Integer.valueOf(str).intValue();//Integer.valueOf(str) 相当于 new Integer(Integer.parseInt(str))，也会抛异常，但会多产生一个对象

将int转换成String的方法如下：
通过#String.valueOf(i);#String s = Integer.toString(i)和#String s = "" + i;
它们的区别：s=i+""; //会产生两个String对象
   s=String.valueOf(i); //直接使用String类的静态方法，只产生一个对象

转换成int[]类型可以通过循环取出每一位的元素，再进行转换。
如 int[] a = new int[s.length()];
  for(int i = 0; i < s.length(); i++){
//先由字符串转换成char,再转换成String,然后Integer
a[i] = Integer.parseInt( String.valueOf(s.charAt(i)));


  }
  //字符串中的数据一定要是数字，否则会出现异常
  s.charAt(i);得到字符串i位置的值，
  String.valueOf(); 转换char类型为字符串
  Integer.parseInt();由String转换成Integer


2、算法估计空间复杂度和时间复杂度


空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。
时间复杂度实际上是估计一个程序，相对于它的输入，它执行多少条指令才能给出答案。
因此一个算法的优劣主要从算法的执行时间和所需要占用的存储空间两个方面衡量。

3、每10分钟运行一次crond任务exam的代码

* * * * *  /home/somedir/scripts.sh


4、线程和进程的关系


http://blog.csdn.net/github_36601823/article/details/61427787


5、哈夫曼树的特点


给定n个权值作为n的叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。
1.权值越大的叶子离根越近，权值越小的叶节点越远离根节点
2.具有n个叶子结点的哈夫曼树共有2n-1个节点
3.哈夫曼树中没有度为1的节点


6、noSql数据库有那些 

Cassandra、Mongodb、CouchDB、Redis、 Riak、Membase、Neo4j 和 HBase 。
具体看http://blog.jobbole.com/1344

7、tcp的拥塞算法


慢启动(Slow start)，拥塞避免(Congestion avoidance)，快速重传(Fast retransmit)，快速恢复(Fast Recovery)
http://blog.csdn.net/github_36601823/article/details/65627669


8、无向图的顶点度之和（顶点n，边数e）


总的度数=2e，e=n(n-1)/2


9、确定平衡树

定义：左右两边至少有1位，左边数每一位相乘等于右边数每位之积
如输入 1221-----1*2=2*1----输出YES
 输入 1236-----1*2*3=6----输出YES

 输入 1224-----没有----输出NO

import java.util.Scanner;
public class newHuiwenShu {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String str = sc.nextLine();
            int k = Print(str);
            if(k ==1){
            	System.out.println("YES");
            }else{
            	System.out.println("NO");
            }
            
        }
    }
    public static int Print(String str){
        int flag = 0;
        int[] arr = new int[str.length()];
        for(int i = 0;i<str.length();i++){
        	arr[i] = str.charAt(i)-48;
        }
        int begin = 0,end = arr.length-1;
        int sum1 =arr[begin],sum2 =arr[end];
        while(begin<end){
            if(sum1<sum2){
                begin++;
                sum1 *= arr[begin];
            }else if(sum1>sum2){
                end--;
                sum2 *= arr[end];
            }else if(sum1==sum2){
                if(end-begin ==1){
                    flag = 1;
                    break;
                }else if(end-begin >=2){
                    begin++;
                    end--;
                    sum1 *= arr[begin];
                    sum2 *= arr[end];
                }
            }
        }
        return flag;
    }
}

10、确定是否是同类字符串
定义A中交换任两个字符可以得到B，交换次数不限。如abc和acb是一类
输入：一个N，输入N个字符串
输出：表示分类的个数

如：输入 4
abcd
abdc
dabc
dcba

输出 1

import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;
public class StringSort{
	public static void main(String[] args){
        HashSet<String> set = new HashSet<>();
        int count = 0;
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        sc.nextLine();
        while(sc.hasNextLine()){
            String str = sc.nextLine();
            char[] arr = str.toCharArray();
            Arrays.sort(arr);
            String str1 = new String(arr);
            if(!set.contains(str1)){
                set.add(str1);
                count++;
            }
            if(num >1){
                num--;
            }else{
                break;
            }
        }
        System.out.println(count);
    }
}