java面试（编程）题（二分法、笛卡尔积、裴波拉契、死锁）

一、使用二分法查找元素

public int getPos(vector<int> A, int n, int val) {
        if(A.size()==0 || n == 0)//异常处理
            return -1;
        int left = 0, right = n-1, mid = 0;
        while(left <= right){
            mid = (left + right)>>1;  //求中点位置
            if(A[mid]>val)    //当中值大于要查找元素，将最右值赋值为中值-1
                right = mid - 1;
            else if(A[mid]<val)//当中值小于要查找元素，将最左值赋值为中值+1
                left = mid+1;
            else{
                while(A[mid] == val && mid>=0) //到找到第一个查找元素位置时，向前遍历看是否还有查找元素
                    mid--;
                return mid+1;
            }
        }
        return -1;
    }
 }

二、求集合的笛卡尔积

public class TestDescartes{
 
    /**
     * 递归实现dimValue中的笛卡尔积，结果放在result中
     * @param dimValue 原始数据
     * @param result 结果数据
     * @param layer dimValue的层数
     * @param curList 每次笛卡尔积的结果
     */
    private static void recursive (List<List<String>> dimValue, List<List<String>> result, int layer, List<String> curList) {
        if (layer < dimValue.size() - 1) {
            if (dimValue.get(layer).size() == 0) {
                recursive(dimValue, result, layer + 1, curList);
            } else {
                for (int i = 0; i < dimValue.get(layer).size(); i++) {
                    List<String> list = new ArrayList<String>(curList);
                    list.add(dimValue.get(layer).get(i));
                    recursive(dimValue, result, layer + 1, list);
                }
            }
        } else if (layer == dimValue.size() - 1) {
            if (dimValue.get(layer).size() == 0) {
                result.add(curList);
            } else {
                for (int i = 0; i < dimValue.get(layer).size(); i++) {
                    List<String> list = new ArrayList<String>(curList);
                    list.add(dimValue.get(layer).get(i));
                    result.add(list);
                }
            }
        }
    }
 
    /**
     * 循环实现dimValue中的笛卡尔积，结果放在result中
     * @param dimValue 原始数据
     * @param result 结果数据
     */
    private static void circulate (List<List<String>> dimValue, List<List<String>> result) {
        int total = 1;
        for (List<String> list : dimValue) {
            total *= list.size();
        }
        String[] myResult = new String[total];
 
        int itemLoopNum = 1;
        int loopPerItem = 1;
        int now = 1;
        for (List<String> list : dimValue) {
            now *= list.size();
 
            int index = 0;
            int currentSize = list.size();
 
            itemLoopNum = total / now;
            loopPerItem = total / (itemLoopNum * currentSize);
            int myIndex = 0;
 
            for (String string : list) {
                for (int i = 0; i < loopPerItem; i++) {
                    if (myIndex == list.size()) {
                        myIndex = 0;
                    }
 
                    for (int j = 0; j < itemLoopNum; j++) {
                        myResult[index] = (myResult[index] == null? "" : myResult[index] + ",") + list.get(myIndex);
                        index++;
                    }
                    myIndex++;
                }
 
            }
        }
 
        List<String> stringResult = Arrays.asList(myResult);
        for (String string : stringResult) {
            String[] stringArray = string.split(",");
            result.add(Arrays.asList(stringArray));
        }
    }
 
    /**
     * 程序入口
     * @param args
     */
    public static void main (String[] args) {
        List<String> list1 = new ArrayList<String>();
        list1.add("1");
        list1.add("2");
 
        List<String> list2 = new ArrayList<String>();
        list2.add("a");
        list2.add("b");
 
        List<String> list3 = new ArrayList<String>();
        list3.add("3");
        list3.add("4");
        list3.add("5");
 
        List<String> list4 = new ArrayList<String>();
        list4.add("c");
        list4.add("d");
        list4.add("e");
 
        List<List<String>> dimValue = new ArrayList<List<String>>();
        dimValue.add(list1);
        dimValue.add(list2);
        dimValue.add(list3);
        dimValue.add(list4);
 
        List<List<String>> recursiveResult = new ArrayList<List<String>>();
        // 递归实现笛卡尔积
        recursive(dimValue, recursiveResult, 0, new ArrayList<String>());
 
        System.out.println("递归实现笛卡尔乘积: 共 " + recursiveResult.size() + " 个结果");
        for (List<String> list : recursiveResult) {
            for (String string : list) {
                System.out.print(string + " ");
            }
            System.out.println();
        }
 
        List<List<String>> circulateResult = new ArrayList<List<String>>();
        circulate(dimValue, circulateResult);
        System.out.println("循环实现笛卡尔乘积: 共 " + circulateResult.size() + " 个结果");
        for (List<String> list : circulateResult) {
            for (String string : list) {
                System.out.print(string + " ");
            }
            System.out.println();
        }
    }
}

三、用循环实现裴波拉契

public class Fibonacci{
    public static void numbers (int y) {
        int m=1,n=1;
        System.out.print(m+" ");
    for(int i=1;i<=y;i++) {
        System .out.print(n+" ");
        n=n+m;//下一项为前两项的和
        m=n-m;//求当前项并存入变量m中
        }
    }
    
    public static void main (String[] args) {
        numbers(30);
    }
        
}

四、java编写一个死锁

public class DeadlockSample {
    
    //必须有两个可以被加锁的对象才能产生死锁，只有一个不会产生死锁问题
    private final Object obj1 = new Object();
    private final Object obj2 = new Object();
 
    public static void main(String[] args) {
        DeadlockSample test = new DeadlockSample();
        test.testDeadlock();
    }
 
    private void testDeadlock() {
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                calLock_Obj1_First();
            }
        });
        Thread t2 = new Thread(new Runnable() {
            public void run() {
                calLock_Obj2_First();
            }
        });
        t1.start();
        t2.start();
    }
    
    //先synchronized  obj1，再synchronized  obj2
    private void calLock_Obj1_First() {
        synchronized (obj1) {
            System.out.println("calLock_Obj1_First:obj1");
            sleep();
            synchronized (obj2) {
                System.out.println("calLock_Obj1_First:obj2");
                sleep();
            }
        }
    }
    
  //先synchronized  obj2，再synchronized  obj1
    private void calLock_Obj2_First() {
        synchronized (obj2) {
            System.out.println("calLock_Obj2_First:obj2");
            sleep();
            synchronized (obj1) {
                System.out.println("calLock_Obj2_First:obj1");    
                sleep();
            }
        }
    }
    
    /**
     * 为了便于让两个线程分别锁住其中一个对象，
     * 一个线程锁住obj1，然后一直等待obj2，
     * 另一个线程锁住obj2，然后一直等待obj1，
     * 然后就是一直等待，死锁产生
     */
    private void sleep() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}