一些笔试算法

1.数组中的数分为两组，让给出一个算法，使得两个组的和的差的绝对值最小 

　　数组中的数的取值范围是0<x<100，元素个数也是大于0， 小于100 
　　比如a[]={2,4,5,6,7},得出的两组数｛2，4，6｝和｛5，7｝，abs(sum(a1)-sum(a2))=0；
　　比如｛2，5，6，10｝，abs（sum(2,10)-sum(5,6))=1,所以得出的两组数分别为｛2，10｝和｛5，6｝。

/**
 * 数组中的数分为两组，让给出一个算法，使得两个组的和的差的绝对值最小 
 * 数组中的数的取值范围是0<x<100，元素个数也是大于0， 小于100 
     比如a[]={2,4,5,6,7},得出的两组数｛2，4，6｝和｛5，7｝，abs(sum(a1)-sum(a2))=0；
      比如｛2，5，6，10｝，abs（sum(2,10)-sum(5,6))=1,所以得出的两组数分别为｛2，10｝和｛5，6｝。
 * @author hasee
 *
 */
public class cutArray {
    
    /**
     * isOK[i][v]表示是否可以找到i个数，使得他们之和等于v
     * 动态规划 使用前一个isOK计算后一个
     * if(v>=arr[k] && isOK[i-1][v-arr[k]]) 
     *     isOK[i][v] = true;
     */
    static boolean isOK[][];
    static int sum;
    static{
        isOK = new boolean[20][100];
        isOK[0][0] = true;
        for (boolean[] bs : isOK) {
            for (boolean b : bs) {
                b = false;
            }
        }
    }
    public static void cutBySum(int[] arr){
        for (int i = 0; i < arr.length; i++) {//计算总和
            sum+=arr[i];
        }
        //总和分成两个和，小的那边肯定在(0,sum/2)之间
        //只用计算一边的和，两边的差值 = sum - (onePlus<<2);
        for (int v = 1; v <= sum/2; v++) { 
            //一边的个数最多有length-1个，最少有一个
            for (int i = arr.length-1; i >= 1; i--) { 
                //遍历数组中所有元素
                for (int k = 1; k < arr.length; k++) {
                     if(v>=arr[k] && isOK[i-1][v-arr[k]]) 
                         isOK[i][v] = true;
                }
            }
        }
    }
    
    /**
     * 递归,遍历解决 所有集 2^n
     */
    static List<Integer> list1 = new ArrayList<Integer>();//临时数组1
    static List<Integer> list2 = new ArrayList<Integer>();//临时数组2
    static Integer[] final1;//结果数组1
    static Integer[] final2;//结果数组2
    static int dValue=Integer.MAX_VALUE;//结果差值
    public static void cut(int[] arr, int cur){
        if (cur == arr.length) { //递归边界，数组里所有数都已确定位置
            int a=0,b=0;
            for (Integer i : list1) { //计算和
                a+=i;
            }
            for (Integer i : list2) {//计算和
                b+=i;
            }
            int c = a-b < 0 ? b-a : a-b;
            if(c<dValue){ //生成最后结果数组
                dValue=c;
                final1=(Integer[])list1.toArray(new Integer[list1.size()]);
                final2=(Integer[])list2.toArray(new Integer[list2.size()]);
            }
            return;
        }
        list1.add(arr[cur]);//加入数组1的情况
        cut(arr, cur+1);
        list1.remove((Integer)arr[cur]);//还原
        
        list2.add(arr[cur]);//加入数组2的情况
        cut(arr, cur+1);
        list2.remove((Integer)arr[cur]);//还原
    }
    
    public static void main(String[] args) {
        int[] arr = {1,3,5,8,6,2,9,4,5,1,2,5};
        
        //方法一 2^n
        cut(arr, 0);
        for (int i : final1) {
            System.out.println("final1: "+i);
        }
        for (int i : final2) {
            System.out.println("final2: "+i);
        }
        System.out.println(dValue);
        
        //方法2 n^2*sum
        cutBySum(arr);
        dValue=Integer.MAX_VALUE;
        int onePlus=0;
        for (int i = 0; i < arr.length/2; i++) {
            for (int v = 0; v < sum; v++) {
                if (isOK[i][v]) {
                    int tempDValue = sum - (v<<1);
                    if (tempDValue<dValue) {
                        dValue = tempDValue;
                        onePlus = v;
                    }
                }
            }
        }
        System.out.println(dValue+"d和p"+onePlus);
    }
}

　　这里提供了一种思路，当想使用动态规划时，但是Sk 和 Sk-1 的关系不能完全直接关联时，要换一种表示方法，可以尝试使用数组存储找的到还不是找不到！

2.两个数组的交集

　　这个其实就是数据库的join(连接)

　　先来看看ORACLE的做法：

　　*嵌套循环连接(nested loop)

　　1、 Oracle首先选择一张表作为连接的驱动表，这张表也称为外部表（Outer Table）。由驱动表进行驱动连接的表或数据源称为内部表（Inner Table）。 
　　2、 提取驱动表中符合条件的记录，与被驱动表的连接列进行关联查询符合条件的记录。
　　事实就是用驱动表来查询外部表，因为外部表经常有索引，所以查询(使用B树或二分查找)比较快。复杂度为0(nlog(n)+mlog(n))。

  *排序合并连接(merge sort join)
　　排序合并连接的方法非常简单。在排序合并连接中是没有驱动表的概念的，两个互相连接的表按连接列的值先排序，排序完后形成的结果集再互相进行合并连接提取符合条件的记录。相比嵌套循环连接，排序合并连接比较适用于返回大数据量的结果。 　　
　　MSJ其实就是排序后，用两个指针指向两个数组，逐个比较，不算排序，复杂度为0(mlog(m)+nlog(n)+n+m)。
　*哈希连接(Hash Join)
　　当内存能够提供足够的空间时,哈希(HASH)连接是Oracle优化器通常的选择。哈希连接中，优化器根据统计信息，首先选择两个表中的小表，在内存中建立这张表的基于连接键的哈希表;优化器再扫描表连接中的大表，将大表中的数据与哈希表进行比较，如果有相关联的数据，则将数据添加到结果集中。

　　典型的空间换时间的做法，对小表建立HASH，然后大表直接对照HASH，就能找到交集，算法复杂度为O(m+n)。　　
　　算法实现：

/**
 * 求两个数组的交集
 * @author jslee
 *
 */
public class Intersection {

    public static int[] result=new int[1000];
    static{
        for (int i =0; i<result.length; i++) {
            result[i]=Integer.MAX_VALUE;
        }
    }
    public static void main(String[] args) {
        int[] a = {5,7,9,3,176,7,4};
        int[] b = {8,7,1,3,14,56,23};
        interByHJ(a,b);
        for (int i = 0; i < result.length; i++) {
            if(result[i]==Integer.MAX_VALUE)
                return;
            System.out.println(result[i]);
        }
    }
    
    //嵌套循环连接(nested loop)
    public static void interByNL(int[] a, int[] b) {
        if (a==null || b==null) 
            return;
        int[] bigArr,smallArr;
        //选择大表(外部表)排序，小表做驱动表
        if (b.length > a.length) {
            bigArr=b;
            smallArr=a;
        }else {
            bigArr=a;
            smallArr=b;
        }
        Arrays.sort(bigArr);
        int number=0;
        for (int i = 0; i < smallArr.length; i++) {
            if(binaryFind(bigArr,smallArr[i])){
                result[number++]=smallArr[i];
            }
        }
    }
    
    //排序合并连接(merge sort join)
    public static void interByMSJ(int[] a, int[] b) {
        if (a==null || b==null) 
            return;
        Arrays.sort(a);
        Arrays.sort(b);
        int i=0,j=0;
        int number=0;
        while (i<a.length && j<b.length) {
            if (a[i]>b[j])
                j++;
            else if (a[i]<b[j]) 
                i++;
            else{
                result[number++]=a[i];
                i++;j++;
            }
        }
    }
    
    //哈希连接(Hash Join)
    public static void interByHJ(int[] a, int[] b) {
        if (a==null || b==null) 
            return;
        int[] bigArr,smallArr;
        //选择小表做Hash表
        if (b.length > a.length) {
            bigArr=b;
            smallArr=a;
        }else {
            bigArr=a;
            smallArr=b;
        }
        boolean[] hash = new boolean[1000];
        for (int i : smallArr) 
            hash[i]=true;
        int number=0;
        for (int i : bigArr) {
            if (hash[i]==true) {
                result[number++]=i;
            }
        }
    }
    
    //二分查找
    public static boolean binaryFind(int[] arr, int k) {
        int i=0,j=arr.length-1;
        int mid = 0;
        while(i<j){
            mid = i+((j-i)>>>1);
            if (arr[mid]>k) 
                j=mid-1;
            else if (arr[mid]<k)
                i=mid+1;
            else
                return true;
        }
        if (arr[i]!=k) 
            return false;
        else
            return true;
    }

}

3.子数组和最大值

　　1).分治法：分成前半段和后半段，然后最大值则是以下三种情况的最大值：

　　*(start,mid-1)的最大子数组和

　　*(mid+1,end)的最大子数组和

　　*跨过前半和后半数组的子数组，也就是说包含 mid 的值。

　　前两个递归求，第三个只需遍历一遍数组即可求组。

　　2).动态规划 -> 递归

　　start[i] ：arr[i] - arr[end] 的包含arr[i]的最大子数组和

　　all[i] ：arr[i] - arr[end] 的最大子数组和

　　因为子数据具有连续性，所以构建一个新变量 start[i] 来动态规划！

　　start[i] = max(arr[i], arr[i]+start[i+1]);

　　all[i] = max(start[i], all[i+1]);

　　由于只需算出最大的值，所以直接优化成两个变量即可。

    public static int max(int a,int b){
        return a>b ? a : b;
    }
    public static int subMaxByBinary(int[] arr, int start, int end){
        if (arr==null) 
            return -1;
        if (end == start) 
            return arr[end];
        int mid = start+(end-start>>>1);
        int midSum=arr[mid];
        int tempSum=arr[mid];
        for (int i = mid-1; i >= start; i--) {
            tempSum += arr[i];
            if (tempSum > midSum) 
                midSum = tempSum;
        }
        tempSum=midSum;
        for (int i = mid+1; i <= end; i++) {
            tempSum += arr[i];
            if (tempSum > midSum) 
                midSum = tempSum;
        }
        return max(max(subMaxByBinary(arr,start,mid-1),
                subMaxByBinary(arr,mid+1,end)),midSum);
    }
    
    public static int subMaxByDP(int[] arr){
        if (arr==null) 
            return -1;
        int start = arr[arr.length-1];
        int all = start;
        for (int i = arr.length-2; i >= 0; i--) {
            start = max(arr[i],arr[i]+start);
            all = max(start, all);
        }
        return all;
    }

4.最大出现次数的数(超过一半)

　　方法有多种：*排序后选，*快速排序的思路，*数组特点

　　这里选得利用数组特点的方法：

    public static int findMax(int[] arr) {
        if (arr == null) 
            return Integer.MIN_VALUE;
        //使用两个变量记录当前存活的数字， 和 出现的次数
        int num=arr[0],time=1;
        //超过一半的数字肯定要比其它数字的总和多
        //所以最后存活的肯定是那个数字
        for (int i = 1; i < arr.length; i++) {
            /*if (time==0) {  //前面判断和后面判断一样的效果
                num = arr[i];
                time = 1;
            }*/
            if (arr[i]==num)  //次数加1
                time++;
            else
                time--;    //不一样次数减1，所以其它数肯定减不过那个数
            if (time==-1) { //time次数为负时，此时应该更换当前数字
                num = arr[i];
                time = 1;
            }
        }
        return num;
    }

5.约瑟夫环问题

　　约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。

　　eg：n = 9，k = 1，m = 5【解答】出局人的顺序为5，1，7，4，3，6，9，2，8。

　　1).直接先是用boolean数组来模拟整个游戏过程

    public static void countJos(int n, int m,int k) {
        boolean[] result = new boolean[n+1];//排列的最后值,为了下标加1，好处理
        int remain=n;        //剩下的总数
        int count=0,index=k;
        while(true){
            if (index==n+1)     //越界了
                index=1;
            if (result[index]) { //已被选过 就跳过了
                index++;
                continue;
            }
            if (remain==1) {  //最后一个了。
                System.out.println(index);
                break;
            }
            ++count;    
            if (count == m) {     //数到要求了
                count=0;
                result[index] = true; //标记它为已被选状态
                System.out.println(index);//打印 
                remain--;
            }
            index++;
        }
    }

　　2).数学策略

 递推公式
f[1]=0;
f[i]=(f[i-1]+m)%i;  (i>1)
　递推后最后一个为最后留下的值。

    public static void countJosBymath(int n, int m) {
        int s=0;
        for (int i=2; i<=n; i++)
            s=(s+m)%i;
        s++;
        System.out.println("最后一个为"+s);
    }

　　这种有重复子问题的问题，一定要往递归和数学方向想！。

6.字符串剔除

　　两个字符串A、B。从A中剔除存在于B中的字符。比如A=“hello world”,B="er"，那么剔除之后A变为"hllowold"。空间复杂度要求是O(1)，时间复杂度越优越好。

　　位Hash映射的方法：

    /**
     * 两个字符串A、B。从A中剔除存在于B中的字符。
     * 比如A=“hello world”,B="er"，那么剔除之后A变为"hllowold"。
     * 空间复杂度要求是O(1)，时间复杂度越优越好。
     * @param str1
     * @param str2
     * @return
     */
    public static String elimChar(String str1, String str2) {
        long[] hash=new long[2]; //两个long构成的128的位图空间
        for (int i = 0; i < str2.length(); i++) { //hash映射
            byte b = (byte) str2.charAt(i);
            if (b<=64)                 //java的默认运算是int
                hash[0] |= (long)1<<b;//注意1必须强制转换为long
            else
                hash[1] |= (long)1<<(b-64);
        }
        
        int index=0;    //使用一个index记录现有多少元素
        char[] arr = new char[str1.length()];//结果数组
        for (int i = 0; i < str1.length(); i++) {//计算是否有包含
            byte b = (byte) str1.charAt(i);
            if (b<=64) {
                if (((hash[0]>>>b)&1) == 0) { //注意为无符号位移
                    arr[index] = str1.charAt(i);
                    index++;
                }
            }
            else{
                if (((hash[1]>>>(b-64))&1) == 0) {
                    arr[index] = str1.charAt(i);
                    index++;
                }
            }
        }
        return new String(arr);
    }

7.trie树

　　Trie树，即字典树，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较，查询效率比哈希表高。

　　建立+查询在trie中是可以同时执行的(可以看到，建树和查询极其相似)，建立的过程也就可以成为查询的过程。

　　关于节点，如果只有26个字母，可以使用一个26的长度的数组来表示子节点(类似Hash)。

/*
 * trie树  建树，查找的实现
 */
public class Trie {
    //树节点
    public class Node{
        public char key; //char值
        public List<Node> next = new ArrayList<Node>();//儿子们
        public int time = 1; //此值为此节点重复次数
        public Node(char key) {
            this.key = key;        
        }
    }
    //建树
    public Node buildTrie(String[] strArr, Node preRoot) {
        Node root = preRoot; //可以使用preRoot来扩建树
        if(root == null)    //也可以新建树根节点，根节点为127
            root = new Node((char)127);
        for (String str : strArr) {
            Node node = root;    //循环中的当前节点
            for (int i = 0; i < str.length(); i++) {
                char c = str.charAt(i);
                boolean bool = true;    //此值为是否树中已有节点
                for (Node iter : node.next) {//遍历当前节点儿子
                    if (iter.key == c) {//节点已存在，不用新建节点
                        node = iter;
                        node.time++;//增加重复值
                        bool = false;
                        break;
                    }
                }
                if (bool) {//新建节点
                    Node temp = node;
                    node = new Node(c);
                    temp.next.add(node);//添加为当前节点的儿子
                }
            }
        }
        return root;
    }
    //深度遍历
    public void depthLook(Node node){
        if (node == null) return;
        if (node.key != (char)127) //不为根节点，打印
            System.out.print(node.key);
        if (node.next.size() == 0) { //没儿子了，为叶节点，打印换行
            System.out.println();
            return;
        }
        for (Node iter : node.next) {//递归
            depthLook(iter);
        }
    }
    //查找
    public boolean findStr(String str, Node root){
        Node node = root;
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            boolean bool = true;//此值为是否树中已有节点
            for (Node iter : node.next) {
                if (iter.key == c) {
                    node = iter;
                    bool = false;
                    break;
                }
            }
            if (bool) {//如果没有节点，直接返回没找到
                return false;
            }
        }
        return true;
    }
    public static void main(String[] args) {
        Trie tr = new Trie();
        String[] strArr = {"hello","goodbye","happy","yesterday"};
        Node root = tr.buildTrie(strArr,null);
        tr.depthLook(root);
        boolean bool = tr.findStr("happya", root);
        System.out.println(bool ? "找的到" : "没找到啊");
    }
}

8.字符串的模拟加减法

　　1).题目描述（50分）： 

　　通过键盘输入100以内正整数的加、减运算式，请编写一个程序输出运算结果字符串。

　　输入字符串的格式为：“操作数1 运算符 操作数2”，“操作数”与“运算符”之间以一个空格隔开。

 　　补充说明：

　　1. 操作数为正整数，不需要考虑计算结果溢出的情况。

　　2. 若输入算式格式错误，输出结果为“0”。

　　要求实现函数： 

　　void arithmetic(const char *pInputStr, long lInputLen, char *pOutputStr);

　　【输入】 pInputStr：  输入字符串

        　　 lInputLen：  输入字符串长度         

　　【输出】 pOutputStr： 输出字符串，空间已经开辟好，与输入字符串等长；

　　【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出

　　2).当看到这个道题，第一反应很简单。。可是就是这种字符串的题，反而容易出错，主要是数组的越界检查。

 　　注意代码中的错误注释。

package arithmetic;

/**
 * 通过键盘输入100以内正整数的加、减运算式，请编写一个程序输出运算结果字符串。
    输入字符串的格式为：“操作数1 运算符 操作数2”，“操作数”与“运算符”之间以一个空格隔开。
    补充说明：
    1. 操作数为正整数，不需要考虑计算结果溢出的情况。
    2. 若输入算式格式错误，输出结果为“0”。
    要求实现函数： 
    void arithmetic(const char *pInputStr, long lInputLen, char *pOutputStr);
    【输入】 pInputStr：  输入字符串
         lInputLen：  输入字符串长度         
    【输出】 pOutputStr： 输出字符串，空间已经开辟好，与输入字符串等长；
    【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出
    示例 
    输入：“4 + 7”  输出：“11”
    输入：“4 - 7”  输出：“-3”
    输入：“9 ++ 7”  输出：“0” 注：格式错误
 * @author hasee
 *
 */
public class Arithmetic {

    public static void main(String[] args) {
        char[] in = "9 ++ 7".toCharArray();
        char[] out = new char[5];
        arith(in, out);
        for (char c : out) {
            System.out.print(c);
        }
        System.out.println();
    }
    
    public static void arith(char[] in, char[] out){
        try {    //错误！！没有考虑每一步都有可能数组越界
            if (in==null||out==null) 
                return;
            int index=0;
            int a,b;
            char sign;
            //计算a，各种检查
            if (in[index]<'0'||in[index]>'9') {
                out[0] = '0';
                return;
            }
            a = in[index++] - '0';
            if (in[index]!=' ') {
                if (in[index]<'0'||in[index]>'9') {
                    out[0] = '0';
                    return;
                }
                a = a*10 + in[index++]-'0';
            }
            //空格
            if (in[index] != ' ') {
                out[0] = '0';
                return;
            }
            index++;
            //sign符号
            if (in[index] != '+' && in[index] != '-') {
                out[0] = '0';
                return;
            }
            sign = in[index++];
            //空格
            if (in[index] != ' ') {
                out[0] = '0';
                return;
            }
            index++;
            //b数字计算，各种检查
            if (in[index]<'0'||in[index]>'9') {
                out[0] = '0';
                return;
            }
            
            b = in[index] - '0';
            //错误！ 没有考虑数组过界,这种情况越界不算错误，10以下的时候
            if (in.length-1 > index) {  
                index++;
                if (in[index]!=' ') {
                    if (in[index]<'0'||in[index]>'9') {
                        out[0] = '0';
                        return;
                    }
                    b = b*10 + in[index]-'0';
                }
            }
            
            //计算最终结果
            int c;
            if (sign == '+') 
                c = a+b;
            else
                c = a-b;   
            //错误！！没有考虑String.valueOf(c).toCharArray()返回的新对象，
            //out为临时指针，函数完了就销毁。
            char[] temp = String.valueOf(c).toCharArray();  
            for (int i = 0; i < temp.length; i++) {
                out[i] = temp[i];
            }
            return;
        } catch (ArrayIndexOutOfBoundsException e) {
            out[0] = '0';
            return;
        }
    }
    
    
}

参考：编程之美