最近投了风火山林的高级java工程师职位，对于我这种刚毕业的菜鸟来说能挺到第三轮，可能对大家来说还算可以，但我心里面对自己的要求可不是那样的。第三轮是算法题，就是发几个题目给你两天时间做完，实际上我一天就做完了，只是在算法的复杂度上没有考虑，我想这也是被刷下来的原因之一吧 。

题目如下：

这是工具类：
package www.work.service;
import java.util.List;
public interface Work_One {

public List<Integer> exec(int n,Integer[] data)throws Exception;
}

package www.work.service.impl;
import java.util.ArrayList;
import java.util.List;

import www.work.service.Work_One;
import www.work.util.CheckArray;
import www.work.util.Work_OneQuicksort;
/**题目描述：1.    请实现一个函数：凑14；输入很多个整数(1<=数值<=13),
 * 任意两个数相加等于14就可以从数组中删除这两个数，求剩余数(按由小到大排列)；
 * 比如： 输入数组[9,1,9,7,5,13], 输出数组[7,9]
 *
 * @author 陈砚庭
 *
 */
public class Work_OneQSort implements Work_One{
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Work_OneQuicksort q=new Work_OneQuicksort();
        Work_One qSoft=new Work_OneQSort();
        Integer[] data={1,2,13,2,13,1,4,6,5,7,4,7,3};
        q.setData(data);
        q.sort(0, data.length-1);
        q.display();   
        List<Integer> lists=null;
        try {
              if(CheckArray.checkArray(data))
                 lists = qSoft.exec(14, data);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(lists);   
    }
    public List<Integer> exec(int n,Integer[] data)throws Exception{
        if(data==null){
            throw new NullPointerException();
        }
        if(n<0){
            throw new IllegalArgumentException();
        }
        Integer temp=n%2==0? n/2:n/2+1;
        if(data[0]>temp||data[data.length-1]<temp){
            return null;
        }
        for(int i=0;i<data.length;i++){
            if(data[i]>temp){
                data[i]=n;
            }else{
                for(int j=i;j<data.length;j++){
                    if(data[i]+data[j]==n){
                        data[i]=0;
                        data[j]=0;
                    }
                }
            }
        }
        return getResult(n,data);
    }
    /**
     * 把数组中多余的元素剔除掉
     * @param n
     * @param arg0
     * @return
     */
    private List<Integer> getResult(int n,Integer[] arg0){
        List<Integer> lists=new ArrayList<Integer>();
        for(int i=0;i<arg0.length;i++){
            if(!(arg0[i]==0||arg0[i]==n)){
                lists.add(arg0[i]);
            }
        }
        return lists;
    }
}

package www.work.service;
import java.util.List;
public interface Work_Two {

/**
     * 根据一维坐标获取重叠部分
     * @param array
     * @return
     * @throws Exception
     */
    public  List<List<Double>> getSegment(Double[][] array)throws Exception;
}
package www.work.service.impl;

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

import www.work.service.Work_Two;

/**
 * 问题描述：2.    请实现一个函数：线段重叠; 输入多个一维线段,
 * 求出这些线段相交的所有区域(也用线段表示); 
 * 一条线段用两个值表示(x0,x1), 其中x1>x0; 
 *比如： 输入线段数组[(2,4),(1.5,6),(0.5,3.5),(5,7),(7.5,9)], 输出线段数组[(1.5,4),(5,6)]
 * @author 陈砚庭
 *
 */
public class Work_TwoSegment implements Work_Two {

/**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        // TODO Auto-generated method stub
        Double[][] array={{2.0,4.0},{1.5,6.0},{0.5,3.5},{5.0,7.0},{7.5,9.0}};
        Double[][] arrayInt={{2.0,4.0},{4.0,6.0},{6.0,7.0},{7.0,7.0},{7.5,9.0}};
        Double temp[][]={{1.5,6.0},{2.4,7.8}};
        Work_Two two=new Work_TwoSegment();
        System.out.println(two.getSegment(array));
    }

public List<List<Double>> getSegment(Double[][] array) throws Exception {

if (array == null) {
            throw new NullPointerException();
        }

//将二维数组转化为一维数组
        Double[] temp = new Double[array.length * 2];
        int[] count = new int[array.length * 2];//存放点的基数的数组，基数越大代表该点被包含的区间越多
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                temp[i * array[i].length + j] = array[i][j];
            }
        }
        Arrays.sort(temp);
        Double x = 0.0;
        Double y = 0.0;
        for (int i = 0; i < array.length; i++) {
            x = array[i][0];
            for (int j = 1; j < array[i].length; j++) {
                y = array[i][j];
                for (int k = 0; k < temp.length; k++) {
                    if (temp[k] >= x && temp[k] < y)
                        ++count[k];
                }
            }
        }
        List<List<Double>> resultList = new LinkedList<List<Double>>();
        List<Double> list = null;
        int flag = 0;
        for (int i = 0; i < count.length; i++) {
            if (count[i] > 1 && flag == 0) {
                flag = 1;
                list = new LinkedList<Double>();
                list.add(temp[i]);
            } else if (count[i] == 1 && flag == 1) {
                flag = 0;
                list.add(temp[i]);
                resultList.add(list);
                list = null;
            }
        }
        return resultList;
    }

}

package www.work.service;
import java.util.ArrayList;
public interface Work_Three {
    public  ArrayList<ArrayList<Integer>> getLongest(Integer[] array) throws Exception;
}
package www.work.service.impl;
import java.util.ArrayList;
import java.util.Arrays;
import www.work.service.Work_Three;
import www.work.util.CheckArray;
/**
 * 题目描述：3.    请实现一个函数：最长顺子；输入很多个整数(1<=数值<=13)，
 * 返回其中可能组成的最长的一个顺子(顺子中数的个数代表顺的长度)；
 * 其中数字1也可以代表14； 顺子包括单顺\双顺\3顺；单顺的定义是连续5个及以上连续的数，
 * 比如1,2,3,4,5、3,4,5,6,7,8和10,11,12,13,1等；双顺的定义是连续3个及以上连续的对(对:两个相同的数被称为对),
 * 比如1,1,2,2,3,3、4,4,5,5,6,6,7,7和11,11,12,12,13,13,1,1等;3顺的定义是连续2个及以上连续的3张(3张:3个相同的数被称为3张),
 * 比如1,1,1,2,2,2、3,3,3,4,4,4,5,5,5,6,6,6和13,13,13,1,1,1等等;
 *比如：输入数组[1,5,2,3,4,4,5,9,6,7,2,3,3,4], 输出数组[2,2,3,3,4,4,5,5]
 * @author 陈砚庭
 *
 */
public class Work_ThreeSequence implements Work_Three{
    private int[] tempCount=null;
    public static void main(String[] args) {
        Work_Three longest=new Work_ThreeSequence();
        Integer[] array = { 1, 5, 2, 3, 4, 4, 5, 9, 6, 7, 2, 3, 3, 4 ,1,13,13,13,11,11,11,12,12,12,1,2};
        try {
           if(CheckArray.checkArray(array))
               System.out.println(longest.getLongest(array));
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public  ArrayList<ArrayList<Integer>> getLongest(Integer[] array)throws Exception{
        if(array==null){
            throw new NullPointerException();
        }
        Arrays.sort(array);//对数组进行排序
        ArrayList<ArrayList<Integer>> listOne=null;
        ArrayList<ArrayList<Integer>> listTwo=null;
        ArrayList<ArrayList<Integer>> listThree=null;
        try{
             listOne = getLongest(array, 1);
             listTwo = getLongest(array, 2);
             listThree= getLongest(array, 3);
            int list1Length=listOne.get(0).size();
            int list2Length=listTwo.get(0).size();
            int list3Length=listThree.get(0).size();
            if(list2Length>list1Length){
                listOne=listTwo;
            }
            if(list3Length>list1Length){
                listOne=listThree;
            }
        }catch(Exception e){
            throw new NullPointerException();
        }
        return listOne;
    }
    /**
     * 获得数组中的顺子
     * @param array
     * @param count
     * @return
     */
    private  ArrayList<ArrayList<Integer>> getLongest(Integer[] array, int count) throws NullPointerException,IllegalArgumentException{
        if(array==null){
            throw new NullPointerException();
        }
        if(count<1){
            throw new IllegalArgumentException();
        }
         tempCount=new int[14];
         //取得每个数字在数组中出现的个数
         for(int i=0;i<array.length;i++){
             tempCount[array[i]]++;
         }
        ArrayList<Integer> longest = new ArrayList<Integer>();//记录最长的顺子
        ArrayList<Integer> temp = new ArrayList<Integer>();//记录当前的顺子
        ArrayList<ArrayList<Integer>> longests=new ArrayList<ArrayList<Integer>>();//记录最长的顺子，不分大小
        for (int i = 0; i < array.length;i+=tempCount[array[i]]) {
            int start = array[i];
            if (getCount(start, count)) {
                for (int j = 0; j < count; j++) {
                    temp.add(start);
                }
            } else {
                continue;
            }
            while (start <= 13) {
                if (getCount(start + 1, count)) {
                    for (int j = 0; j < count; j++) {
                        if (start + 1 == 14) {
                            temp.add(1);
                        } else {
                            temp.add(start + 1);
                        }
                    }
                } else {
                    break;
                }
                start++;
            }
            if (temp.size()>longest.size()) {
                longest = (ArrayList<Integer>) temp.clone();
                longests.clear();
                longests.add(longest);
            }else if(temp.size()==longest.size()){
                if(!temp.equals(longest)){
                    longests.add(temp);
                }
            }
            temp = new ArrayList<Integer>();
        }
        return longests;
    }
    /**
     * 在数组中查找n是否出现count次
     * @param n  寻找的次数
     * @param count 出现的次数
     * @return
     */
    private  boolean getCount(int n, int count) {
        if (n == 14) {
            n = 1;
        }
        if(tempCount[n]>=count){
            return true;
        }else{
            return false;
        }
    }
}

package www.work.util;
public class Work_FourArrayFile {
    private int index = 0;// 数组长度
    private String[] files = null;
    public synchronized void add(String file) {
        index++;
        String[] tempFiles = new String[index];
        if (files == null) {
            tempFiles[0] = file;
        } else {
            tempFiles[tempFiles.length - 1] = file;
            System.arraycopy(files, 0, tempFiles, 0, files.length);
        }
        files = tempFiles.clone();
    }
    public synchronized void remove(String file) {
        if (index < 0) {
            throw new IllegalArgumentException();
        }
        index--;
        String[] tempFiles = new String[index];
        int indexTemp = 0;
        for (int i = 0; i < files.length; i++) {
            if (files[i] == file) {
                indexTemp = i + 1;
                continue;
            }
        }
        if (indexTemp != 0) {
            if (indexTemp != 1) {
                System.arraycopy(files, 0, tempFiles, 0, indexTemp - 1);
            }
            if (indexTemp != files.length) {
                System.arraycopy(files, indexTemp, tempFiles, indexTemp - 1,
                        files.length - indexTemp);
            }
            files = tempFiles.clone();
        }
    }
    public int getIndex() {
        return index;
    }

public String[] getFiles() {
        return files;
    }
    /*
     * public void clear() { files=null; }
     */
    public static void main(String... args) {
        Work_FourArrayFile work_FourArrayFile = new Work_FourArrayFile();
        int[] temp = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        int[] index = new int[9];
        System.arraycopy(temp, 1, index, 0, 9);
        for (int i = 0; i < index.length; i++) {
            System.out.println(index[i]);
        }
        work_FourArrayFile.add(100 + "");
        work_FourArrayFile.add(101 + "");
        work_FourArrayFile.add(102 + "");
        work_FourArrayFile.add(103 + "");
        work_FourArrayFile.add(104 + "");
        work_FourArrayFile.add(105 + "");
        work_FourArrayFile.add(106 + "");
        work_FourArrayFile.add(107 + "");
        work_FourArrayFile.add(108 + "");
        work_FourArrayFile.add(109 + "");
        for (String i : work_FourArrayFile.getFiles())
            System.out.print(i + "\t");
        System.out.println();
        work_FourArrayFile.remove(100 + "");
        for (String i : work_FourArrayFile.getFiles())
            System.out.print(i + "\t");
        System.out.println();
        work_FourArrayFile.remove(101 + "");
        for (String i : work_FourArrayFile.getFiles())
            System.out.print(i + "\t");
        System.out.println();
        work_FourArrayFile.remove(102 + "");
        for (String i : work_FourArrayFile.getFiles())
            System.out.print(i + "\t");
        System.out.println();
        work_FourArrayFile.remove(103 + "");
        for (String i : work_FourArrayFile.getFiles())
            System.out.print(i + "\t");
        System.out.println();
        work_FourArrayFile.remove(104 + "");
        for (String i : work_FourArrayFile.getFiles())
            System.out.print(i + "\t");
        System.out.println();
        work_FourArrayFile.remove(105 + "");
        for (String i : work_FourArrayFile.getFiles())
            System.out.print(i + "\t");
        work_FourArrayFile.remove(106 + "");
        for (String i : work_FourArrayFile.getFiles())
            System.out.print(i + "\t");
        System.out.println();
        work_FourArrayFile.remove(107 + "");
        for (String i : work_FourArrayFile.getFiles())
            System.out.print(i + "\t");
        System.out.println();
        work_FourArrayFile.remove(108 + "");
        for (String i : work_FourArrayFile.getFiles())
            System.out.print(i + "\t");
        System.out.println();
        work_FourArrayFile.remove(109 + "");
        for (String i : work_FourArrayFile.getFiles())
            System.out.print(i + "\t");
        System.out.println("sdfd");
    }
}
package www.work.util;

import java.util.HashMap;
import java.util.Map;
public class Work_Fourutil {
    private Work_Fourutil(){}
    private static Map<String, Long> maps = new HashMap<String, Long>();
    public  static void put(String arg0,Long arg1){
        maps.put(arg0, arg1);
    }
    public static Map<String, Long> getMaps() {
        return maps;
    }
}
package www.work.service;
import java.util.Map;
public interface Work_Four {
    /**
     * 从指定目录下读取文件
     * @param path
     * @return
     * @throws Exception
     */
    public Map<String, Long> readProject(String path)throws Exception;
}
package www.work.service.impl;
import java.util.Map;
import www.work.service.Work_Four;
import www.work.util.Work_FourArrayFile;
import www.work.util.Work_Fourutil;
/**
 * 4.请设计一个程序：使用多线程，统计程序源代码行数；源代码是可以编译通过的合法的代码， 统计其物理总行数、其中的空行行数、其中含有有效代码的行数、
 * 其中含有注释内容的行数；(要求必须利用多线程编程， 如果代码框架能更容易的扩展到支持多种语言的源代码行数统计，将获得更高的评价。)
 *
 * @author Administrator
 *
 */
public class Work_FourImpl implements Work_Four {
    private Work_FourThreadFileImpl filesArray = null;
    private Work_FourThreadLineIpml lineArray = null;
    private boolean flag = false;
    public static void main(String... args) throws Exception {
        Work_Four w = new Work_FourImpl();
        String path = "D:\\java\\test\\src\\main\\java\\www\\work\\impl";
        Work_FourArrayFile wf_file=new Work_FourArrayFile();
        Map<String, Long> maps = w.readProject(path);
        for (String map : maps.keySet()) {
            System.out.println(map + "=" + maps.get(map));
        }
    }
    public Map<String, Long> readProject(String path) throws Exception {
        // TODO Auto-generated method stub
        exec(path);
        while(filesArray.getWf_product().isLineflag()){ 
        }
        end();
        return Work_Fourutil.getMaps();
    }
    private void end(){
        Work_Fourutil.put("空格行", filesArray.getWf_product().getBlank_Lines());
        Work_Fourutil.put("有效代码行", filesArray.getWf_product().getCode_Lines());
        Work_Fourutil.put("注释行", filesArray.getWf_product().getComment_Lines());
        Work_Fourutil.put("物理行", (filesArray.getWf_product().getBlank_Lines()+filesArray.getWf_product().getCode_Lines()+filesArray.getWf_product().getComment_Lines()));
    }
    private void exec(String path) {
        Work_FourArrayFile wf_file=new Work_FourArrayFile();
        Work_FourProduct wf_product=new Work_FourProduct(path,".java",wf_file);
        //获取文件目录的线程
        filesArray=new Work_FourThreadFileImpl(wf_product);
        Thread thread1 = new Thread(filesArray);
        //统计文件的线程
        lineArray = new Work_FourThreadLineIpml(wf_product);
        Thread thread2 = new Thread(lineArray);
        thread1.start();
        thread2.start();
    }
}
package www.work.service.impl;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import www.work.util.Work_FourArrayFile;
public class Work_FourProduct {
    private Work_FourArrayFile wf=null;
    private  boolean fileflag = true;// 标志位,判断获得文件路径的线程是否运行完成
    private  boolean lineflag = true； 
    public boolean isFileflag() {
        return fileflag;
    }
    public void setFileflag(boolean fileflag) {
        this.fileflag = fileflag;
    }
    private String path=null;//要遍历的文件路径
    private String suffix=null;//文件后缀
    private  long code_Lines = 0; // 可执行代码行数
    private  long comment_Lines = 0; // 注释行数
    private  long blank_Lines = 0; // 空格行数
    public long getCode_Lines() {
        return code_Lines;
    }
    public long getComment_Lines() {
        return comment_Lines;
    }
    public long getBlank_Lines() {
        return blank_Lines;
    }
    public Work_FourProduct(String path,String suffix,Work_FourArrayFile wf) {
        super();
        this.path = path;
        this.suffix=suffix;
        this.wf=wf;
    }
    public Work_FourArrayFile getWf() {
        return wf;
    }
    public boolean isLineflag() {
        return lineflag;
    }
    public void setLineflag(boolean lineflag) {
        this.lineflag = lineflag;
    }
    public synchronized void execSetWf() throws Exception{
        while(true){
            if(wf.getIndex()>0){
                this.wait();
            }else{
                break;
            }
        }
         readsFile(path,suffix);
         this.notify();
    }
    private  void  readsFile(String path,String suffix) throws Exception {
        // TODO Auto-generated method stub
        File f = new File(path);
        File[] ff = f.listFiles();
        for (File child : ff) {
            if (child.isDirectory()) {
                readsFile(child.getPath(),suffix);
            } else if (child.getName().matches(".*\\"+suffix+"$")) {
                wf.add(child.getPath());
            }
        }
    }
    public synchronized void execGetWf() throws InterruptedException{
        while(true){
            if(wf.getIndex()<=0){
                this.wait();
            }else{
                exec();
                this.notify();
                break;
            }
        } 
    }
    private void exec() {
        String[] files = wf.getFiles();
        if (files != null&&files.length>0) {
            for (String f : files) {
                try {
                    readFileLines(new File(f));
                    wf.remove(f);
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
    private void readFileLines(File f) throws Exception {
        BufferedReader br = null;
        boolean tempFlag = false;
        try {
            br = new BufferedReader(new FileReader(f));
            String line = "";
            while ((line = br.readLine()) != null) {
                line = line.trim(); // 除去注释前的空格
                if (line.matches("^[ ]*$")) { // 匹配空行
                    blank_Lines++;
                } else if (line.startsWith("//")) {
                    comment_Lines++;
                } else if (line.startsWith("/*") && !line.endsWith("*/")) {
                    comment_Lines++;
                    tempFlag = true;
                } else if (line.startsWith("/*") && line.endsWith("*/")) {
                    comment_Lines++;
                } else if (tempFlag == true) {
                    comment_Lines++;
                    if (line.endsWith("*/")) {
                        tempFlag = false;
                    }
                } else {
                    code_Lines++;
                }
            }
        } catch (FileNotFoundException e) {
            throw e;
        } catch (IOException e) {
            throw e;
        } finally {
            if (br != null) {
                try {
                    br.close();
                    br = null;
                } catch (IOException e) {
                    throw e;
                }
            }
        }
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
    }
}
package www.work.service.impl;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import www.work.util.Work_FourArrayFile;
/**
 * 此类用于读取指定目录下的java源文件
 * @author 陈砚庭
 *
 */
public class Work_FourThreadFileImpl implements Runnable {
    public static void main(String ...args){
        String path="D:\\java\\test\\src\\main\\java\\www\\work\\impl";
        Work_FourArrayFile wf_file=new Work_FourArrayFile();
        Work_FourProduct wf_product=new Work_FourProduct(path,".java",wf_file);
        Work_FourThreadFileImpl w=new Work_FourThreadFileImpl(wf_product);
        Thread t=new Thread(w);
        t.start();
        //System.out.println(Work_FourArrayFile.getFiles());
    }
    public Work_FourProduct getWf_product() {
        return wf_product;
    }
    private Work_FourProduct wf_product=null;
    public Work_FourThreadFileImpl(Work_FourProduct wf_product) {
        super();
        this.wf_product=wf_product;
    }
    public void run() {
        // TODO Auto-generated method stub
        while(wf_product.isFileflag()){
            try {
                wf_product.execSetWf();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally{
                wf_product.setFileflag(false);
                System.out.println("Work_FourThreadFileImpl线程执行完毕！！！！");
            }
        }
    }
}
package www.work.service.impl;
/**
 * 此线程类用于保存行数
 *
 * @author Administrator
 *
 */
public class Work_FourThreadLineIpml implements Runnable {
    private Work_FourProduct wf_product = null;
    public Work_FourThreadLineIpml(Work_FourProduct wf_product) {
        this.wf_product = wf_product;
    }
    public void run() {
        // TODO Auto-generated method stub
        while (wf_product.isLineflag()) {
            try {
                wf_product.execGetWf();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally{
                wf_product.setLineflag(false);
                System.out.println("Work_FourThreadLineIpml线程执行完毕！！！！");
            }  
        }
    }
}

通过这次的面试，明显的知道了自己的不足，以后要多往算法复杂度方面去思考问题，上面的方法都是可以改进的。