常见机试题分析Java版

1. 操作系统任务分为系统任务和用户任务两种。其中，系统任务的优先级<50，用户任务的优先级>=50且<=255.优先级大于255的为非法任务，应予以剔除。现有一任务队列task[]，长度为n，task中的元素值表示任务的优先级，数值越小，优先级越高。函数scheduler实现如下功能，将task[]种的任务按照系统任务、用户任务依次存放到system_task[]数组和user_task[]数组中，数组中元素的值是任务在task[]数组中的下标，并且优先级高的任务排在前面，优先级相同的任务按照入队顺序排列，数组元素为-1表示结束。例如：task[]={0,30,155,1,80,300,170,40,99} system_task[]=}0,3,1,7,-1} user_task[]={4,8,2,6,-1}。函数接口为void scheduler(int task[],int n,int system_task[],int user_task[])。

思路分析：

（1）先看给定的函数接口，参数为任务队列数组、任务数、系统任务数组和用户队列数组，也就是说在main函数中调用该函数时，这些参数是已经初始化了的。这里系统任务数组和用户队列数组就要注意了，题目中说数组元素为-1表示结束，即数组中并不是所有元素都是任务下标，输出时用一个while循环判断一下不是-1就成。那就好办了，先按照任务数组的长度初始化系统任务数组和用户队列数组，Java会自动为它们赋初值为0，这样就可以传参了。

（2）题目的核心是根据数组元素值的大小排列其下标，艾玛这不就是为HashMap量身定制的么。可以遍历任务队列，将系统任务和用户任务及其下标分别存入HashMap，然后对这两个HashMap分别按照值排序，再取出其键分别存入系统任务数组和用户任务数组，最后两个数组都添个-1就搞定了。

代码如下：

package cn.edu.xidian.crytoll;

import java.util.*;

import java.util.Map.*;

public class Scheduler {

   public static void scheduler(int task[],int n,int system_task[],int user_task[]){

   Map<Integer,Integer> inputsystem = new HashMap<Integer,Integer>();

   Map<Integer,Integer> inputuser = new HashMap<Integer,Integer>();

   for(int i=0;i<n;i++){

   if(task[i]>=0&&task[i]<50) inputsystem.put(i,task[i]);

   else if(task[i]>=50&&task[i]<=255) inputuser.put(i,task[i]);

   }

   Map<Integer, Integer> outputsystem = sortByValue(inputsystem);

   Map<Integer, Integer> outputuser = sortByValue(inputuser);

   Set<Integer> systemset = outputsystem.keySet();

   Set<Integer> userset = outputuser.keySet(); 

   int systemn=0;

   int usern=0;

   for (Integer s:systemset) {

       system_task[systemn]=s;

       systemn++;

   } 

   for (Integer s:userset) {

       user_task[usern]=s;

       usern++;

   }

   system_task[systemn]=-1;

   user_task[usern]=-1;

   int i=0;

   while(system_task[i]!=-1){

   System.out.println(system_task[i]);

   ++i;

   }

   int j=0;

   while(user_task[j]!=-1){

   System.out.println(user_task[j]);

   ++j;

   }

   }

   public static <K, V extends Comparable<V>> Map<K, V> sortByValue(

           Map<K, V> map) {

       List<Entry<K, V>> list = new LinkedList<Entry<K, V>>(map.entrySet());

       Collections.sort(list, new Comparator<Entry<K, V>>() {

           public int compare(Entry<K, V> o1, Entry<K, V> o2) {

               Comparable<V> v1 = o1.getValue();

               V v2 = o2.getValue();

               if (v1 == null) {

                   if (v2 == null) {

                       return 0;

                   } else {

                       return -1;

                   }

               } else {

                   if (v2 == null) {

                       return 1;

                   } else {

                       return v1.compareTo(v2);

                   }

               }

           }

       });

       Map<K, V> result = new LinkedHashMap<K, V>();

       Iterator<Entry<K, V>> it = list.iterator();

       while (it.hasNext()) {

           Entry<K, V> entry = it.next();

           result.put(entry.getKey(), entry.getValue());

       }

       return result;

   }

   public static void main(String[] args){

   int task[]={0,30,155,1,80,300,170,40,99};

   int n=task.length;        

   int system_task[]=new int[n];

   int user_task[]=new int[n];

   scheduler(task,n,system_task,user_task);

   }

}                                               

2. 输入一个表达式，没有括号，数字小于0-9之间，输出计算结果，所有的中间结果化为整形。例如:  输入：3+8×2/9-2。输出：2

思路分析：

（1）输入的表达式是个字符串类型，要获取它的每个运算数和运算符需要用到charAt()方法。然后挨个字符地存入ArrayList，再使用get()方法遍历字符串。

（2）四则表达式的运算符分两种优先级，需遍历两次，第一次处理乘法和除法，第二次处理加法和减法。遇到运算符后将其前后两个数的运算结果求出，然后使用add()方法将运算结果插入到前运算数的位置，再连续使用remove()方法将参与此次运算的运算符和两个运算数移除。最后ArrayList中只剩一个元素，即为该表达式的值。使用parseInt()方法将其格式化后返回。

代码如下：

package cn.edu.xidian.crytoll;

import java.util.ArrayList;
import java.util.List;

public class getMyRet {
    public int getMyRet(String str){
        int len=str.length();
        List<String> list=new ArrayList<String>();
        for(int i=0;i<len;i++)
            list.add(str.charAt(i)+"");
        for(int j=0;j<list.size();j++){
            if(list.get(j).equals("×")){
                int ji=Integer.parseInt(list.get(j-1))*Integer.parseInt(list.get(j+1));
                list.add(j-1,ji+"");
                list.remove(j);
                list.remove(j);
                list.remove(j);
                j--;
             }
             else if(list.get(j).equals("/")){
                 int shang=Integer.parseInt(list.get(j-1))/Integer.parseInt(list.get(j+1));
                 list.add(j-1,shang+"");
                 list.remove(j);
                 list.remove(j);
                 list.remove(j);
                 j--;
             }
         }
         for(int k=0;k<list.size();k++){
             if(list.get(k).equals("+")){
                 int he=Integer.parseInt(list.get(k-1))+Integer.parseInt(list.get(k+1));
                 list.add(k-1,he+"");
                 list.remove(k);
                 list.remove(k);
                 list.remove(k);
                 k--;
             }
             if(list.get(k).equals("-")){
                 int cha=Integer.parseInt(list.get(k-1))-Integer.parseInt(list.get(k+1));
                 list.add(k-1,cha+"");
                 list.remove(k);
                 list.remove(k);
                 list.remove(k);
                 k--;
             }
         }
         int sum=Integer.parseInt(list.get(0));
         return sum;
    }
    public static void main(String[] args){
        String input="3+8×2/9-2";
        getMyRet getmyret=new getMyRet();
        System.out.println(getmyret.getMyRet(input));
    }
}

3. 将一个十进制（byte型）转换为二进制，将二进制数前后颠倒，再算出颠倒后对应的十进制数。

思路分析：进制互转的话Java有现成的方法可以调用。十进制转二进制用Integer类的toBinaryString()方法，二进制转十进制用Integer类的valueOf()方法。

代码如下：

package cn.edu.xidian.crytoll;

public class UpperToLower {
    //遍历字符串中的每个字符，如果是小写则直接添加进结果字符串
    //若是A-U的大写字母，将其转换成小写字母后加5，添加进结果字符串
    //若是V-Z的大写字母，将其转换成小写字母后减21，添加进结果字符串
    public String uptolow(String input){
        String output="";
        int len=input.length();
        for(int i=0;i<len;i++){
            if((input.charAt(i)+"").matches("[a-z]")) output=output+input.charAt(i);
            if((input.charAt(i)+"").matches("[A-U]")) output=output+((char)(input.charAt(i)+5)+"").toLowerCase();
            if((input.charAt(i)+"").matches("[V-Z]")) output=output+((char)(input.charAt(i)-21)+"").toLowerCase();
        }
        return output;
    }
    public static void main(String[] args){
        String input="AbCdEfGhIjKlMnOpQrStUvWxYz";
        System.out.println(new UpperToLower().uptolow(input));
    }
}

4. 输入一串数字，将第一个数字作为容量大小，从其它的数字中挑选出之和正好等于第一个数字的数字组合，若存在这样的数字组合其和等于第一个数字的大小，则输出1， 否则输出0。

输入：10，5，3，4，2（大体上是这种形式的）输出：1

思路分析：

（1）先将输入格式化，第一个数字拿出来作为目标和，其余数字存入数组并升序排序

（2）建立两个链表，一个用于存储备选数字，一个用于存储当前纳入选择的数字

（3）将备选数字存入链表，为其设置迭代器，因为是双层循环，故需创建一个迭代器副本

（4）设置已选数字的和并初始化为0，从第一个备选数字开始，清空已有和，比较当前数字数字与其他每个数字的和的情况

（5）若第一个备选数字和目标和相等，则返回1；若第一个备选数字大于目标和，则返回0；若当前备选数字小于目标和，判断当前备选数字和已有和相加是否等于目标和，若等于则直接返回1；若当前备选数字和已有和相加小于目标和，将当前备选数字填入已选列表，更新当前和；若当前备选数字和已有和相加大于目标和，若减去之前插入已选列表的数字正好等于目标和，则返回1；若减去之后小于目标和，则更新当前和及已选列表，跳出循环和下一个数相比；若减去之后还大于目标和，就得不断从已选列表中剔除最新插入的数字并更新当前和，直到当前和小于或等于目标和为止

代码如下：

package cn.edu.xidian.crytoll;

import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class IsEqual {
    public int isequal(String input){
        //将输入存入字符串型数组
        String[] all=input.split(",");
        //获取第一个数字作为目标和
        int needsum=Integer.parseInt(all[0]);
        //将备选数字存入整型数组
        int[] member=new int[all.length-1];
        for(int i=0;i<member.length;i++) member[i]=Integer.parseInt(all[i+1]);
        //对备选数字数组排序
        Arrays.sort(member);
        //建立两个链表，一个存储备选数字，一个存储当前纳入选择的数字
        List<Integer> list=new LinkedList<Integer>();
        List<Integer> content=new LinkedList<Integer>();
        //将备选数字存入链表，为其设置迭代器，因为是双层循环，故需创建一个迭代器副本
        for(int i=0;i<member.length;i++) list.add(member[i]);
        Iterator it=list.iterator();
        Iterator it0=it;
        //设置已选数字的和并初始化为0
        int sum=0;
        //从第一个备选数字开始，比较每一个数字与其他每个数字的和的情况
        while(it.hasNext()){
            it0=it;
            sum=0;
            while(it0.hasNext()){
                int temp=(int)it0.next();
                //若第一个备选数字和目标和相等，则返回1
                if(temp==needsum) return 1;
                //若第一个备选数字大于目标和，则返回0
                    if(temp>needsum) return 0;
                    //若当前备选数字小于目标和
                    if(temp<needsum){
                        //判断当前备选数字和已有和相加是否等于目标和，若等于则直接返回1
                        if(temp+sum==needsum) return 1;
                        //若当前备选数字和已有和相加小于目标和，将当前备选数字填入已选列表，更新当前和
                        if(temp+sum<needsum){
                            content.add(temp);
                            sum=sum+temp;
                        }
                        //若当前备选数字和已有和相加大于目标和，
                        else if(temp+sum>needsum){
                            while(content.size()>1){
                                //若减去之前插入已选列表的数字正好等于目标和，则返回1
                                if(temp+sum-content.get(content.size()-1)==needsum) return 1;
                                //若减去之后小于目标和，则更新当前和，已选列表，跳出循环和下一个数相比
                                if(temp+sum-content.get(content.size()-1)<needsum){
                                    sum=sum-content.get(content.size()-1)+temp;
                                    content.remove(content.size()-1);
                                    content.add(temp);
                                    break;
                                }
                                //若减去之后还大于目标和，就得不断从已选列表中剔除最新插入的数字并更新当前和，直到当前和小于或等于目标和为止
                                else if(temp+sum-content.get(content.size()-1)>needsum){
                                    sum=sum-content.get(content.size()-1);
                                    content.remove(content.size()-1);
                                }
                            }
                        }
                    }
            }
        }
        return 0;
    }
    public static void main(String[] args){
        String input="10,5,3,4,2";
        System.out.println(new IsEqual().isequal(input));
    }
}

5. 在给定字符串中找出单词（ “单词”由大写字母和小写字母字符构成，其他非字母字符视为单词的间隔，如空格、问号、数字等等；另外单个字母不算单词）；找到单词后，按照长度进行降序排序，（排序时如果长度相同，则按出现的顺序进行排列），然后输出到一个新的字符串中；如果某个单词重复出现多次，则只输出一次；如果整个输入的字符串中没有找到单词，请输出空串。输出的单词之间使用一个“空格”隔开，最后一个单词后不加空格。

思路分析：

（1）将单词门存入字符串型数组

（2）对inputs进行稳定的冒泡降序排序

（3）将长度大于一的单词加入结果字符串

代码如下：

package cn.edu.xidian.crytoll;

import java.util.HashMap;
import java.util.Map;

public class MyWord {
    public String myword(String input,String output){
        int len=input.length();
        String temp="";
        //将单词门存入字符串型数组
        for(int i=0;i<len;i++){
            if((input.charAt(i)+"").matches("[a-zA-Z]")) temp=temp+input.charAt(i);
            if(!(input.charAt(i)+"").matches("[a-zA-Z]")) temp=temp+" ";
        }
        String[] inputs=temp.split("\\s+");
        //对inputs进行稳定的冒泡降序排序
        for(int i=0;i<inputs.length-1;i++){
            for(int j=0;j<inputs.length-i-1;j++){
                if(inputs[j].length()<inputs[j+1].length()){
                    String tempstr=inputs[j];
                    inputs[j]=inputs[j+1];
                    inputs[j+1]=tempstr;
                }
            }
        }
        //将长度大于一的单词加入结果字符串
        for(int i=0;i<inputs.length;i++){
            if(inputs[i].length()>1&&output.indexOf(inputs[i])<0) output=output+inputs[i]+" ";
        }
        return output;
    }
    public static void main(String[] args){
        String input="DING Zhongli, academician of the Chinese Academy of Sciences (CAS) and a test";
        String output="";
        System.out.println(new MyWord().myword(input, output));
    }
}