JAVA面试精选【Java算法与编程二】

在面试中，算法题目是必须的，通过算法能够看出一个程序员的编程思维，考察对复杂问题的设计与分析能力，对问题的严谨性都能够体现出来。算法是一系列解决问题的清晰指令，也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。算法常常含有重复的步骤和一些比较或逻辑判断。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。一个算法的好坏，直接影响一个方法调用的性能，进而影响软件的整体性能。　　

6、从类似如下的文本文件中读取出所有的姓名，并打印出重复的姓名和重复的次数，并按重复次数排序：

1,张三,28

2,李四,35

3,张三,28

4,王五,35

5,张三,28

6,李四,35

7,赵六,28

8,田七,35

程序代码如下(答题要博得用人单位的喜欢，包名用该公司，面试前就提前查好该公司的网址，如果查不到，现场问也是可以的。还要加上实现思路的注释)：

package com.huawei.interview;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.TreeSet;
publicclass GetNameTest
{
    /**

     * @paramargs

     */
    public static voidmain(String[] args)
    {
        // TODO Auto-generated method stub
        //InputStream ips =GetNameTest.class.getResourceAsStream("/com/huawei/interview/info.txt");
        //用上一行注释的代码和下一行的代码都可以，因为info.txt与GetNameTest类在同一包下面，所以，可以用下面的相对路径形式
        Map results = new HashMap();
        InputStream ips = GetNameTest.class.getResourceAsStream("info.txt");
        BufferedReader in = newBufferedReader(new InputStreamReader(ips));
        String line = null;
        try
        {
            while((line = in .readLine()) != null)
            {
                dealLine(line, results);
            }
            sortResults(results);
        }
        catch(IOException e)
        {
            // TODO Auto-generated catchblock
            e.printStackTrace();
        }
    }
    static class User
    {
        public String name;
        public Integer value;
        public User(String name, Integervalue)
        {
            this.name = name;
            this.value = value;
        }@
        Override
        public booleanequals(Object obj)
        {
            // TODO Auto-generated methodstub
            //下面的代码没有执行，说明往treeset中增加数据时，不会使用到equals方法。
            boolean result = super.equals(obj);
            System.out.println(result);
            return result;
        }
    }
    private static voidsortResults(Map results)
    {
        // TODO Auto-generated method stub
        TreeSet sortedResults = newTreeSet(new Comparator()
        {
            public intcompare(Object o1, Object o2)
            {
                // TODOAuto-generated method stub
                User user1 = (User) o1;
                User user2 = (User) o2;
                /*如果compareTo返回结果0，则认为两个对象相等，新的对象不会增加到集合中去

                 * 所以，不能直接用下面的代码，否则，那些个数相同的其他姓名就打印不出来。

                 * */
                //returnuser1.value-user2.value;
                //returnuser1.value<user2.value?-1:user1.value==user2.value?0:1;
                if(user1.value < user2.value)
                {
                    return -1;
                }
                else if(user1.value > user2.value)
                {
                    return 1;
                }
                else
                {
                    returnuser1.name.compareTo(user2.name);
                }
            }
        });
        Iterator iterator = results.keySet().iterator();
        while(iterator.hasNext())
        {
            String name = (String) iterator.next();
            Integer value = (Integer) results.get(name);
            if(value > 1)
            {
                sortedResults.add(newUser(name, value));
            }
        }
        printResults(sortedResults);
    }
    private static voidprintResults(TreeSet sortedResults)
    {
        Iterator iterator = sortedResults.iterator();
        while(iterator.hasNext())
        {
            User user = (User) iterator.next();
            System.out.println(user.name + ":" + user.value);
        }
    }
    public static voiddealLine(String line, Map map)
    {
        if(!"".equals(line.trim()))
        {
            String[] results = line.split(",");
            if(results.length == 3)
            {
                String name = results[1];
                Integer value = (Integer) map.get(name);
                if(value == null) value = 0;
                map.put(name, value + 1);
            }
        }
    }
}

7、写一个Singleton出来。

第一种： 饱汉模式
public classSingleTon
{
    private SingleTon()
        {}
        //实例化放在静态代码块里可提高程序的执行效率，但也可能更占用空间 
    private final static SingleTon instance = new SingleTon();
    public static SingleTon getInstance()
    {
        return instance;
    }
}
第二种： 饥汉模式
public classSingleTon
{
    private SingleTon()
    {}
    private static instance = null; //newSingleTon();
    public static synchronized SingleTongetInstance()
    {
        if(instance == null) instance = new SingleTon();
        return instance;
    }
}
第三种： 用枚举
public enum SingleTon
{
    ONE;
}
第三： 更实际的应用( 在什么情况用单例)
public classSequenceGenerator
{
    //下面是该类自身的业务功能代码
    private int count = 0;
    public synchronized int getSequence()
        {
            ++count;
        }
        //下面是把该类变成单例的代码
    private SequenceGenerator()
    {}
    private final static instance = newSequenceGenerator();
    public static SingleTon getInstance()
    {
        return instance;
    }
}
第四：
public class MemoryDao
{
    private HashMap map = new HashMap();
    publicvoid add(Student stu1)
        {
            map.put(SequenceGenerator.getInstance().getSequence(), stu1);
        }
        //把MemoryDao变成单例
}

Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。

一般Singleton模式通常有几种种形式:

第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。

public class Singleton
{
    private Singleton()
        {}
        //在自己内部定义自己一个实例，是不是很奇怪？
        //注意这是private只供内部调用
    private staticSingleton instance = new Singleton();
    //这里提供了一个供外部访问本class的静态方法，可以直接访问　　
    public staticSingleton getInstance()
    {
        return instance;
    }
}

   第二种形式:

public class Singleton
{
    private static Singleton instance = null;
    public static synchronized Singleton getInstance()
    {
        //这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　
        //使用时生成实例，提高了效率！
        if(instance == null) instance＝ new Singleton();
        return instance;
    }
}

其他形式:

定义一个类，它的构造函数为private的，所有方法为static的。

一般认为第一种形式要更加安全些

8、递归算法题1

一个整数，大于0，不用循环和本地变量，按照n，2n，4n，8n的顺序递增，当值大于5000时，把值按照指定顺序输出来。
例：n=1237
则输出为：
1237，
2474，
4948，
9896，
9896，
4948，
2474，
1237，

提示：写程序时，先致谢按递增方式的代码，写好递增的以后，再增加考虑递减部分。

    public static void doubleNum(int n)
    {
        System.out.println(n);
        if(n <= 5000) doubleNum(n * 2);
        System.out.println(n);
    }

Gaibaota(N) = Gaibaota(N-1) + n

9、递归算法题2

第1个人10，第2个比第1个人大2岁，依次递推，请用递归方式计算出第8个人多大？

package cn.itcast;
import java.util.Date;
publicclass A1
{
    public static voidmain(String[] args)
    {
        System.out.println(computeAge(8));
    }
    public static int computeAge(intn)
    {
        if(n == 1) return 10;
        returncomputeAge(n - 1) + 2;
    }
}
public static voidtoBinary(int n, StringBuffer result)
{
    if(n / 2 != 0) toBinary(n / 2, result);
    result.append(n % 2);
}

10 、排序都有哪几种方法？请列举。用 JAVA 实现一个快速排序。

 本人只研究过冒泡排序、选择排序和快速排序，下面是快速排序的代码：

public class QuickSort
{
    /**
     * 快速排序
     * @param strDate
     * @param left
     * @param right
     */
    public void quickSort(String[] strDate, int left, int right)
        {
            String middle, tempDate;
            int i, j;
            i = left;
            j = right;
            middle = strDate[(i + j) / 2];
            do {
                while(strDate[i].compareTo(middle) < 0 && i < right) i++; //找出左边比中间值大的数
                while(strDate[j].compareTo(middle) > 0 && j > left) j--; //找出右边比中间值小的数
                if(i <= j)
                { //将左边大的数和右边小的数进行替换
                    tempDate = strDate[i];
                    strDate[i] = strDate[j];
                    strDate[j] = tempDate;
                    i++;
                    j--;
                }
            } while (i <= j); //当两者交错时停止
            if(i < right)
            {
                quickSort(strDate, i, right); //从
            }
            if(j > left)
            {
                quickSort(strDate, left, j);
            }
        }
        /**
         * @param args
         */
    public static void main(String[] args)
    {
        String[] strVoid = newString[]
        {
            "11", "66", "22", "0", "55", "22", "0", "32"
        };
        QuickSort sort = new QuickSort();
        sort.quickSort(strVoid, 0, strVoid.length - 1);
        for(int i = 0; i < strVoid.length; i++)
        {
            System.out.println(strVoid[i] + " ");
        }
    }
}

11、有数组a[n]，用java代码将数组元素顺序颠倒

//用下面的也可以

//for(inti=0,int j=a.length-1;i<j;i++,j--)是否等效于for(int i=0;i<a.length/2;i++)呢？

importjava.util.Arrays;
public classSwapDemo
{
    public static void main(String[] args)
    {
        int[] a = new int[]
        {
            (int)(Math.random() * 1000), (int)(Math.random() * 1000), (int)(Math.random() * 1000), (int)(Math.random() * 1000), (int)(Math.random() * 1000)
        };
        System.out.println(a);
        System.out.println(Arrays.toString(a));
        swap(a);
        System.out.println(Arrays.toString(a));
    }
    public static void swap(int a[])
    {
        int len = a.length;
        for(int i = 0; i < len / 2; i++)
        {
            int tmp = a[i];
            a[i] = a[len - 1 - i];
            a[len - 1 - i] = tmp;
        }
    }
}

12 ．金额转换，阿拉伯数字的金额转换成中国传统的形式如：(￥ 1011 )－ > (一千零一拾一元整)输出。

去零的代码：returnsb.reverse().toString().replaceAll("零[拾佰仟]","零").replaceAll("零+万","万").replaceAll("零+元","元").replaceAll("零+","零");

public class RenMingBi
{
    /**

     * @param args add by zxx ,Nov 29, 2008

     */
    private static finalchar[] data = new char[]
    {
        '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'
    };
    private static finalchar[] units = new char[]
    {
        '元', '拾', '佰', '仟', '万', '拾', '佰', '仟', '亿'
    };
    public static voidmain(String[] args)
    {
        // TODOAuto-generated method stub
        System.out.println(convert(135689123));
    }
    public static Stringconvert(int money)
    {
        StringBuffersbf = new StringBuffer();
        int unit = 0;
        while(money != 0)
        {
            sbf.insert(0, units[unit++]);
            intnumber = money % 10;
            sbf.insert(0, data[number]);
            money /= 10;
        }
        returnsbf.toString();
    }
}