java笔试算法题及答案.docx
《java笔试算法题及答案.docx》由会员分享，可在线阅读，更多相关《java笔试算法题及答案.docx（23页珍藏版）》请在冰点文库上搜索。
java笔试算法题及答案
1．现在输入n个数字，以逗号，分开；然后可选择升或者降序排序
我的评论：
本题的splitStringByComma（String）方法纯属多余，可以用String的split方法一句话代替，且可读性也更强，下面的一段话源自JDK1.6API，StringTokenizer类已不再提倡使用，保留仅为旧代码。
StringTokenizer是出于兼容性的原因而被保留的遗留类（虽然在新代码中并不鼓励使用它）。
建议所有寻求此功能的人使用String的split方法或java.util.regex包。
importjava.util.*;
publicclassbycomma{
publicstaticString[]splitStringByComma（Stringsource）{
if（source==null||source.trim（）.equals（""））
returnnull;
StringTokenizercommaToker=newStringTokenizer（source,","）;
String[]result=newString[commaToker.countTokens（）];
inti=0;
while（commaToker.hasMoreTokens（））{
result[i]=commaToker.nextToken（）;
i++;
}
returnresult;
}
publicstaticvoidmain（Stringargs[]）{
String[]s=splitStringByComma（"5,8,7,4,3,9,1"）;
int[]ii=newint[s.length];
for（inti=0;iii[i]=Integer.parseInt（s[i]）;
}
Arrays.sort（ii）;
//asc
for（inti=0;iSystem.out.println（ii[i]）;
}
//desc
for（inti=（s.length-1）;i>=0;i--）{
System.out.println（ii[i]）;
}
}
}
2.编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。
但是要保证汉字不被截半个，如"我ABC"4，应该截为"我AB"，输入"我ABC汉DEF"，6，应该输出为"我ABC"而不是"我ABC+汉的半个"。
代码：
publicstaticbooleanisLetter（charc）{
intk=0X80;
returnc/k==0?
true:
false;
}
publicstaticintlengths（StringstrSrc）{
if（strSrc==null）{
return0;
}
intlen=0;
char[]strChar=strSrc.toCharArray（）;
for（inti=0;ilen++;
if（!
isLetter（strChar[i]））len++;
}
returnlen;
}
publicstaticStringsubString（Stringorigin,intlen）{
if（origin==null||origin.equals（""）||len<1）{
return"";
}
if（len>lengths（origin））{
returnorigin;
}
byte[]strByte=newbyte[len];
System.arraycopy（origin.getBytes（）,0,strByte,0,len）;
intcount=0;
for（inti=0;iintvalue=（int）strByte[i];
if（value<0）count++;
}
if（count%2!
=0）{
//len=（len==1）?
++len:
--len;
--len;
}
returnnewString（strByte,0,len）;
}
publicstaticvoidmain（String[]args）{
System.out.println（""+subString（"我ABC汉DEF",6））;
}
3、排序都有哪几种方法？
请列举。
用JAVA实现一个快速排序。
排序的方法有：
插入排序（直接插入排序、希尔排序），交换排序（冒泡排序、快速排序），选择排序（直接选择排序、堆排序），归并排序，分配排序（箱排序、基数排序）
快速排序的伪代码。
//使用快速排序方法对a[0:
n-1]排序从a[0:
n-1]中选择一个元素作为mIddle，该元素为支点把余下的元素分割为两段left和rIght，使得left中的元素都小于等于支点，而right中的元素都大于等于支点递归地使用快速排序方法对left进行排序递归地使用快速排序方法对right进行排序所得结果为left+mIddle+rIght
//以下为java程序实现的快速排序算法：
publicstaticvoidsort（int[]data）{
quickSort（data,0,data.length-1）;
}
publicstaticvoidquickSort（int[]data,intlow,inthigh）{
intpivotIndex=（low+high）/2;
swap（data,pivotIndex,high）;
intk=partition（data,low-1,high,data[high]）;
swap（data,k,high）;
if（（k-low）>1）partition（data,low,k-1）;
if（（high-k）>1）partition（data,k+1,high）;
}
publicstaticintpartition（int[]dataintlow,inthigh,intpivot）{
do{
while（data[++low]while（high!
=0&&data[--high]>pivot）;
swap（data,low,high）;
}
while（lowswap（data,low,high）;
returnlow;
}
publicstaticvoidswap（int[]dataintlow,inthigh）{
inttmp=data[low];
data[low]=data[high];
data[high]=tmp;
}
publicstaticvoidmain（String[]args）{
int[]data=newint[]{89,32,425,32,78,1,53,92};
sort（data）;
}
4.试用递归的方法写一下计算菲波那契数列的通项f（n）,已知f1=1,f2=1,以后每项都是前两项的和。
..............
publicstaticlongfibonacci（longm）{
if（m==0||m==1）returnm;
elsereturnfibonacci（m-1）+fibonacci（m-2）;
}
5.写一个Singleton出来。
Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
我的评论：
第一种形式是饿汉式单例类，第二种是懒汉式单例类；可以如此速记，饿汉式太饿了，所以迫不及待在内部new出一个实例，而懒汉式太懒了，所以知道应用时才检查有没有实例存在，如不存在才new一个实例出来。
一般Singleton模式通常有几种种形式:
第一种形式:
定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。
PublicclassSingleton{
privateSingleton（）{}
//在自己内部定义自己一个实例，是不是很奇怪？
//注意这是private只供内部调用
privatestaticSingletoninstance=newSingleton（）;
//这里提供了一个供外部访问本class的静态方法，可以直接访问
publicstaticSingletongetInstance（）{
returninstance;
}
}
第二种形式:
publicclassSingleton{
privatestaticSingletoninstance=null;
publicstaticsynchronizedSingletongetInstance（）{
//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次
//使用时生成实例，提高了效率！
if（instance==null）
instance＝newSingleton（）;
returninstance;
}
}
其他形式:
定义一个类，它的构造函数为private的，所有方法为static的。
一般认为第一种形式要更加安全些
6、创建一个静态方法，给它传入一个对象，请循环的打印出该对象所在类的类名和所实现的方法名（华为笔试最后一道编程）
importjava.lang.reflect.*;
publicclassTest{
publicstaticvoidtest（Objectobj）{
Classclazz=obj.getClass（）;
//System.out.println（"类名:
"+clazz.getName（））;
Method[]ms=clazz.getDeclaredMethods（）;
longlen=Array.getLength（ms）;
for（inti=0;iSystem.out.println（"类名:
"+clazz.getName（）+"方法名:
"+ms[i].getName（））;
}
}
classA{
publicvoidb（）{}
publicvoidc（）{}
publicvoidd（）{}
publicvoide（）{}
}
publicstaticvoidmain（String[]args）{
Testt=newTest（）;
Test.Aa=t.newA（）;
test（a）;
}
}
7、假设字符串类似这样的aba和aab就相等，现在随便给你二组字符串，请编程比较他们看是否相等
BufferedReaderbr=newBufferedReader（newInputStreamReader（System.in））;
Strings=null;
try{
s=br.readLine（）;
}catch（IOExceptione）{
e.printStackTrace（）;
}
StringTokenizerst=newStringTokenizer（s）;
Strings1=st.nextToken（）;
Strings2=st.nextToken（）;
byte[]sa1=s1.getBytes（）;
byte[]sb2=s2.getBytes（）;
Arrays.sort（sa1）;
Arrays.sort（sb2）;
Stringss1=newString（sa1）;
Stringss2=newString（sb2）;
if（ss1.equals（ss2））
System.out.println（"equal"）;
else
System.out.println（"notequal"）;
8、给你一组字符串如：
iu7i8hy4jnb2，让你编程输出里面的数字：
7842
用正规表达式：
"iu7i8hy4jnb2".replaceAll（"[^\\d]",""）;
9、给你一组字符串让你把它倒叙输出
publicstaticStringflashBack（Stringorigin）{
Stringresult="";
for（inti=origin.length（）;i>0;i--）{
Stringtmp=origin.substring（i-1,i）;
result+=tmp;
}
returnresult;
}
10、给你一组字符如{1，3，4，7，2，1，1，5，2}，让你输出里面出现次数最多且数值最大的一个，出现几次
publicvoidfun4（）{
int[]a={4,1,2,4,5,1,1,1,5,1,3,4,5};
Arrays.sort（a）;
for（inti=0;iSystem.out.print（a[i]+""）;
}
System.out.println（）;
intmaxNumber=a[a.length-1],maxCount=1;
intcurNumber=a[a.length-1],curCount=1;
for（inti=a.length-1;i>0;i--）{
curNumber=a[i];
if（a[i]==a[i-1]）{
curCount++;
}else{
System.out.println（"i="+i+",curCount="+curCount+",maxCount="+maxCount+",maxNumber="+maxNumber）;
if（curCount>maxCount）{
maxCount=curCount;
maxNumber=curNumber;
}
curCount=1;
}
}
if（curCount>maxCount）{
maxCount=curCount;
//maxNumber=curNumber;
}
System.out.println（"curCount="+curCount+",maxCount="+maxCount+",maxNumber="+maxNumber）;
}
11、求两个数的公约数，M，N
intdivisor=1;
for（inti=2;i<=b;i++）{
if（a%i==0&&b%i==0）{
divisor=i;
}
}
System.out.println（a+"和"+b+"的最大公约数是:
"+divisor）;
}
12、实现数组复制
我的理解：
这是深复制，数组a，b不再有关联
publicvoidfun8（）{
int[]a={1,2,3,4,56,7,8};
int[]b=（int[]）a.clone（）;
Conica.print（a）;
Conica.print（b）;
b[0]=100;
Conica.print（a）;
Conica.print（b）;
}
13、冒泡排序的实现
publicvoidfun9（）{
int[]a={1,5,2,6,8,74,1,25,69,8};
Conica.print（a）;
for（inti=0;ifor（intj=0;jif（a[j]>a[j+1]）{
inttemp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
Conica.print（a）;
}
14、编程显示某一文件目录下的文件名
publicvoidfun10（）{
Filefile=newFile（"G:
\\03月份"）;
if（file.exists（））{
if（file.isDirectory（））{
String[]files=file.list（）;
Conica.println（files）;
}
}
}
15、从键盘输入4个十进制数字字符，将其转换为4位时间之数并显示出来
16、编程实现统计文本文件中某个单词的出现频率，并输出统计结果
用HashMap来解决
假设单词不存在跨行的,每个单词用,.;分割
publicstaticvoidcountNum（）throwsIOException{
BufferedReaderbr=null;
try{
br=newBufferedReader（newFileReader（"c:
//file.txt"））;
Mapmap=newHashMap（）;
for（Strings=br.readLine（）;s!
=null;s=br.readLine（））{
StringTokenizerst=newStringTokenizer（s,",.;"）;
while（st.hasMoreTokens（））{
Stringtemp=st.nextToken（）;
if（map.containsKey（temp））{
map.put（temp,newInteger（（Integer）map.get（temp）+1））;
}else{
map.put（temp,newInteger
（1））;
}
}
}
for（Iteratorit=map.entrySet（）.iterator（）;it.hasNext（）;）{
Map.Entryentry=（Map.Entry）it.next（）;
System.out.println（entry.getKey（）+"-->"+entry.getValue（）
+"times"）;
}
}finally{
br.close（）;
}
}
17、编程模仿DOS下的dir命令，列出某个目录下的内容
18、编程说明String和StringBuffer字符串的区别
19、编程计算N!
的程序，一个使用递归方法，一个不用递归方法
递归:
longfuction（intn）{
if（n==0）return1;
else
returnn*fuction（n-1）;
}
不递:
longs=1;
for（inti=2;i<=n;i++）
{
s*=i;
}
20、编程实现ASCII码和Unicode码之间的转换
21.用1、2、2、3、4、5这六个数字，用java写一个main函数，打印出所有不同的排列，如：
512234、412345等，要求：
"4"不能在第三位，"3"与"5"不能相连.
此题具体算法及程序可参考：
22。
一个字符串中可能包含a~z中的多个字符，如有重复，如Stringdata="aavzcadfdsfsdhshgWasdfasdf"，求出现次数最多的那个字母及次数，如有多个重复的则都求出。
〔金山公司面试题〕
importjava.util.ArrayList;
importjava.util.Collections;
importjava.util.Iterator;
importjava.util.TreeSet;
publicclassFindRepeatChar{
publicstaticvoiddoString（StringstrInput）{
char[]chars=strInput.toCharArray（）;
ArrayListlists=newArrayList（）;
TreeSetset=newTreeSet（）;
for（inti=0;ilists.add（String.valueOf（chars[i]））;
set.add（String.valueOf（chars[i]））;
}
System.out.println（set）;
Collections.sort（lists）;
System.out.println（lists）;
StringBuffersb=newStringBuffer（）;
for（inti=0;isb.append（lists.get（i））;
}
strInput=sb.toString（）;
System.out.println（strInput）;
intmax=0;
StringmaxString="";
ArrayListmaxList=newArrayList（）;
for（Iteratorits=set.iterator（）;its.hasNext（）;）{
Stringos=（String）its.next（）;
intbegin=strInput.indexOf（os）;
intend=strInput.lastIndexOf（os）;
intvalue=end-begin+1;
if（value>max&&value>1）{
max=value;
maxString=os;
maxList.add（
升级会员 