① 面试算法题：你的任务就是计算出长度为n的字符串(只包含‘A’、‘B’和‘C’)，有多少个是暗黑字符串。
程序肯定不是判断一个字符串是纯洁的还是黑暗的。从现有的题目描述看，程序和题目没有关系。
题目是否不全？
java面试题大全-基础方面Java基础方面:
1、作用域public,private,protected,以及不写时的区别
答：区别如下：
作用域 当前类 同一package 子孙类 其他package
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×
不写时默认为friendly
2、Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)
答：匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现
3、Static Nested Class 和 Inner Class的不同
答：Nested Class （一般是C++的说法），Inner Class (一般是JAVA的说法)。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。注： 静态内部类（Inner Class）意味着1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象
4、&和&&的区别
答：&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）
5、Collection 和 Collections的区别
答：Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作
6、什么时候用assert
答：assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，系统将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的
7、String s = new String("xyz");创建了几个String Object
答：两个，一个字符对象，一个字符对象引用对象
8、Math.round(11.5)等于多少? Math.round(-11.5)等于多少
答: Math.round(11.5)==12;Math.round(-11.5)==-11;round方法返回与参数最接近的长整数，参数加1/2后求其floor
9、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错
答：short s1 = 1; s1 = s1 + 1; （s1+1运算结果是int型，需要强制转换类型）short s1 = 1; s1 += 1;（可以正确编译）
10、Java有没有goto
答：java中的保留字，现在没有在java中使用
11、数组有没有length()这个方法? String有没有length()这个方法
答：数组没有length()这个方法，有length的属性。String有有length()这个方法
12、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型
答：方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型
13、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别
答：Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等
equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值
14、给我一个你最常见到的runtime exception
答：常见的运行时异常有如下这些ArithmeticException, ArrayStoreException, BufferOverflowException, BufferUnderflowException, CannotRedoException, CannotUndoException, ClassCastException, CMMException, , DOMException, EmptyStackException, IllegalArgumentException, IllegalMonitorStateException, IllegalPathStateException, IllegalStateException, ImagingOpException, IndexOutOfBoundsException, MissingResourceException, NegativeArraySizeException, NoSuchElementException, NullPointerException, ProfileDataException, ProviderException, RasterFormatException, SecurityException, SystemException, UndeclaredThrowableException, UnmodifiableSetException, UnsupportedOperationException
15、error和exception有什么区别
答：error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况
exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况
16、List, Set, Map是否继承自Collection接口
答： List，Set是，Map不是
17、abstract class和interface有什么区别
答：声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法
接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口
18、abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized
答：都不能
19、接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)
答：接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数
20、构造器Constructor是否可被override
答：构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading
21、是否可以继承String类
答：String类是final类故不可以继承
22、try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后
答：会执行，在return前执行
23、用最有效率的方法算出2乘以8等于几
答：2 << 3
24、两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对
答：不对，有相同的hash code
25、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递
答：是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的
26、swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上
答：witch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。long,string 都不能作用于swtich
27、ArrayList和Vector的区别,HashMap和Hashtable的区别
答：就ArrayList与Vector主要从二方面来说.
一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半
就HashMap与HashTable主要从三方面来说。
一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现
二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的
三.值：只有HashMap可以让你将空值作为一个表的条目的key或value
28、char型变量中能不能存贮一个中文汉字?为什么?
答：是能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的
29、GC是什么? 为什么要有GC
答：GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。
30、float型float f=3.4是否正确?
答:不正确。精度不准确,应该用强制类型转换，如下所示：float f=(float)3.4
31、介绍JAVA中的Collection FrameWork(包括如何写自己的数据结构)?
答：Collection FrameWork如下：
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）
Map提供key到value的映射
32、抽象类与接口？
答：抽象类与接口都用于抽象，但是抽象类(JAVA中)可以有自己的部分实现，而接口则完全是一个标识(同时有多重继承的功能)。
JAVA类实现序例化的方法是实现java.io.Serializable接口
Collection框架中实现比较要实现Comparable 接口和 Comparator 接口
33、STRING与STRINGBUFFER的区别。
答：STRING的长度是不可变的，STRINGBUFFER的长度是可变的。如果你对字符串中的内容经常进行操作，特别是内容要修改时，那么使用StringBuffer，如果最后需要String，那么使用StringBuffer的toString()方法
34、谈谈final, finally, finalize的区别
答：final?修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载
finally?再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）
finalize?方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的
35、面向对象的特征有哪些方面
答：主要有以下四方面：
1.抽象：
抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。
2.继承：
继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
3.封装：
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
4. 多态性：
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
36、String是最基本的数据类型吗
答：基本数据类型包括byte、int、char、long、float、double、boolean和short。
java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类
37、int 和 Integer 有什么区别
答：Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。
原始类型封装类,booleanBoolean,charCharacter,byteByte,shortShort,intInteger,longLong,floatFloat,doubleDouble
引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关
38、运行时异常与一般异常有何异同
答：异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。
39、说出ArrayList,Vector, LinkedList的存储性能和特性
答：ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
40、HashMap和Hashtable的区别
答：HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，效率上可能高于Hashtable。
HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。
HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。
Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。
最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。
Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。
③ c#面试题字符串分割问题
C#最简单的分割你这样的字串,用它本身的Split函数就可以了,这个是很基础的了
但面试肯定不是那么简单的,它要考虑转换成int数组,这个要用到使用Array类中的静态泛形式方法ConvertAll进行转换,这个是难点,参考程序如下:
string
s="1,2,,4";
string
[]x=s.Split(',');
int[]
output
=
Array.ConvertAll<string,
int>(x,
delegate(string
t)
{
return
int.Parse(t);
});
④ leetcode-程序员面试金典-字符串比较
看完之后，立刻根据三种情况开始处理.....
insert和delete都是使用的之前回文序列的较为繁琐的去重方法搞定的，bug来源就这里了。
也怪我没怎么好好理解题的意思，英文版的更好明白一点，只能是“one/zero edit”才能返回true，其他情况统统是false。
这样的话对字符串的匹配程度应该要求很高，insert和delete的处理过于粗糙了。
然后测试不通过，看到用例我才傻眼了
这样的情况下字符串完美匹配就非常重要了，因为从测试用例知道不能仅仅要求字符串的字符元素匹配，还得要求字符顺序也匹配。
最后采用双索引方法通过，用时2ms
⑤ java面试有哪些算法
面试-java算法题：
1.编写一个程序，输入n,求n！（用递归的方式实现）。
public static long fac(int n){ if(n<=0) return 0; else if(n==1) return 1; else return n*fac(n-1);
} public static void main(String [] args) {
System.out.println(fac(6));
}
2.编写一个程序，有1，2,3,4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？
public static void main(String [] args) { int i, j, k; int m=0; for(i=1;i<=4;i++) for(j=1;j<=4;j++) for(k=1;k<=4;k++){ if(i!=j&&k!=j&&i!=k){
System.out.println(""+i+j+k);
m++;
}
}
System.out.println("能组成："+m+"个");
}
3.编写一个程序，将text1.txt文件中的单词与text2.txt文件中的单词交替合并到text3.txt文件中。text1.txt文件中的单词用回车符分隔，text2.txt文件中用回车或空格进行分隔。
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
public class text{
public static void main(String[] args) throws Exception{
String[] a = getArrayByFile("text1.txt",new char[]{'\n'});
String[] b = getArrayByFile("text2.txt",new char[]{'\n',' '});
FileWriter c = new FileWriter("text3.txt");
int aIndex=0; int bIndex=0;
while(aIndex<a.length){
c.write(a[aIndex++] + "\n");
if(bIndex<b.length)
c.write(b[bIndex++] + "\n");
}
while(bIndex<b.length){
c.write(b[bIndex++] + "\n");
}
c.close();
}
public static String[] getArrayByFile(String filename,char[] seperators) throws Exception{
File f = new File(filename);
FileReader reader = new FileReader(f);
char[] buf = new char[(int)f.length()];
int len = reader.read(buf);
String results = new String(buf,0,len);
String regex = null;
if(seperators.length >1 ){
regex = "" + seperators[0] + "|" + seperators[1];
}else{
regex = "" + seperators[0];
}
return results.split(regex);
}
}
4.639172每个位数上的数字都是不同的，且平方后所得数字的所有位数都不会出现组成它自身的数字。（639172*639172=408540845584），类似于639172这样的6位数还有几个？分别是什么？
这题采用的HashMap结构判断有无重复，也可以采用下题的数组判断。
public void selectNum(){
for(long n = 100000; n <= 999999;n++){
if(isSelfRepeat(n)) //有相同的数字，则跳过
continue;
else if(isPingFangRepeat(n*n,n)){ //该数的平方中是否有与该数相同的数字
continue;
} else{ //符合条件，则打印 System.out.println(n);
}
}
} public boolean isSelfRepeat(long n){
HashMap<Long,String> m=new HashMap<Long,String>(); //存储的时候判断有无重复值
while(n!=0){ if(m.containsKey(n%10)){ return true;
} else{
m.put(n%10,"1");
}
n=n/10;
} return false;
} public boolean isPingFangRepeat(long pingfang,long n){
HashMap<Long,String> m=new HashMap<Long,String>(); while(n!=0){
m.put(n%10,"1");
n=n/10;
} while(pingfang!=0){ if(m.containsKey(pingfang%10)){ return true;
}
pingfang=pingfang/10;
} return false;
} public static void main(String args[]){ new test().selectNum();
}
5.比如，968548+968545=321732732它的答案里没有前面两个数里的数字，有多少这样的6位数。
public void selectNum(){
for(int n = 10; n <= 99;n++){
for(int m = 10; m <= 99;m++){ if(isRepeat(n,m)){ continue;
} else{
System.out.println("组合是"+n+","+m);
}
}
}
} public boolean isRepeat(int n,int m){ int[] a={0,0,0,0,0,0,0,0,0,0}; int s=n+m; while(n!=0){
a[n%10]=1;
n=n/10;
} while(m!=0){
a[m%10]=1;
m=m/10;
} while(s!=0){ if(a[s%10]==1){ return true;
}
s=s/10;
} return false;
} public static void main(String args[]){ new test().selectNum();
}
6.给定String,求此字符串的单词数量。字符串不包括标点，大写字母。例如 String str="hello world hello hi";单词数量为3，分别是：hello world hi。
public static void main(String [] args) { int count = 0;
String str="hello world hello hi";
String newStr="";
HashMap<String,String> m=new HashMap<String,String>();
String [] a=str.split(" "); for (int i=0;i<a.length;i++){ if(!m.containsKey(a[i])){
m.put(a[i],"1");
count++;
newStr=newStr+" "+a[i];
}
}
System.out.println("这段短文单词的个数是："+count+","+newStr);
}
7.写出程序运行结果。
public class Test1 { private static void test(int[]arr) { for (int i = 0; i < arr.length; i++) { try { if (arr[i] % 2 == 0) { throw new NullPointerException();
} else {
System.out.print(i);
}
} catch (Exception e) {
System.out.print("a ");
} finally {
System.out.print("b ");
}
}
}
public static void main(String[]args) { try {
test(new int[] {0, 1, 2, 3, 4, 5});
} catch (Exception e) {
System.out.print("c ");
}
}
}
运行结果：a b 1b a b 3b a b 5b
public class Test1 { private static void test(int[]arr) { for (int i = 0; i < arr.length; i++) { try { if (arr[i] % 2 == 0) { throw new NullPointerException();
} else {
System.out.print(i);
}
}
finally {
System.out.print("b ");
}
}
}
public static void main(String[]args) { try {
test(new int[] {0, 1, 2, 3, 4, 5});
} catch (Exception e) {
System.out.print("c ");
}
}
}
运行结果：b c
8.单词数
统计一篇文章里不同单词的总数。
Input
有多组数据，每组一行，每组就是一篇小文章。每篇小文章都是由小写字母和空格组成，没有标点符号，遇到#时表示输入结束。
Output
每组值输出一个整数，其单独成行，该整数代表一篇文章里不同单词的总数。
Sample Input
you are my friend
#
Sample Output
4
public static void main(String [] args) {
List<Integer> countList=new ArrayList<Integer>(); int count;
HashMap<String,String> m;
String str; //读取键盘输入的一行（以回车换行为结束输入） String[] a;
Scanner in=new Scanner(System.in);
while( !(str=in.nextLine()).equals("#") ){
a=str.split(" ");
m=new HashMap<String,String>();
count = 0; for (int i=0;i<a.length;i++){ if(!m.containsKey(a[i]) && (!a[i].equals(""))){
m.put(a[i],"1");
count++;
}
}
countList.add(count);
}s for(int c:countList)
System.out.println(c);
}
⑥ 寻找最大回文字符串: Manacher算法详解
Manacher算法是一种用于找出给定字符串中最长的回文字符子串的算法.该算法的神来之笔是: 用一个不会出现在该目标字符串中的特殊字符对目标字符串进行填充, 为描述简便, 我们就假设该特殊符号为"#", 并且算法是从字符串的左端向右端开始寻找.
我们这样来完成填充:
1)在目标字符串的每个字符前面都塞入一个"#";
2)在目标字符串的末端加一个"#".
如此一来, 任意字符串" *** "填充之后都会变成这个样子" #*#*#*# "
从填充的两个步骤可以看出, 任意长度为n的字符串, 在填充之后长度都会变成n+n+1, 即2n+1, 也就是说填充之后得到的字符串的长度一定是奇数.
由于后面不可避免地要讨论字符的位置下标, 所以从这里开始, 我们就把被填充后的字符串看做一个字符数组, 如果被填充前的目标字符串长度为n, 那么该字符数组的下标显然就是从0开始, 到2n结束. 同时为了后续描述的统一和便于理解, 我们在这个字符数组的基础上定义几个代名词:
当前有效回文字符串 : 它是指当前已经找到的, 拥有 最大右端下标的回文字符串 , 注意 , 它不一定是已经找到的最长回文字符串.
mPoint : middle point, 它是指当前有效回文字符串的 中点字符的下标 . mPoint的初始值是0, 它会逐渐右移.
radius : 回文字符串半径 , 由于回文字符串是关于中点位置对称的, 所以把长度为n的回文字符串的半径定义为从中点位置分割后, 任意一侧的字符串长度+1(要把中点位置的字符算进去), 即n/2 + 1. 请注意: Manacher算法第一步所做的填充, 其神奇之处在这里开始显现, 因为从填充后的字符串中找出的最长回文字符串的长度也一定是奇数, 并且 radius-1 就是原始字符串中回文字符串的长度, 比如:
原字符串是"bbad", 我们可以找到的最长回文字符串是长度为2(偶数)的"bb"
而由于填充之后的字符串是"#b#b#a#d#", 所以我们可以找到的最长回文字符串就变成了长度为5(奇数)的"#b#b#" (半径为3, 减1恰好等于2)
原字符串是"cabad", 我们可以找到的最长回文字符串是长度为3(奇数)的"aba"
而由于填充之后的字符串是"#c#a#b#a#d#", 所以我们可以找到的最长回文字符串就变成了长度为7(仍为奇数)的"#a#b#a#" (半径为4, 减1恰好等于3)
数组P : 构造一个数组P, 用于记录字符数组中每个元素以其为中点可以形成的最大回文字符串的半径
rPoint : right point, 它是指当前有效回文字符串的右端字符的下标+1(注意我们是从左端开始检查的), rPoint = mPoint+P[mPoint]. rPoint 的作用是利用回文字符串的特性, 减少不必要的检查, 后面会详述. rPoint 的初始值是0, 它会逐渐右移
Manacher算法开始:
第一步, 初始化:
令 i = 0 (当前检查的字符下标), mPoint=0 , rPoint = 0
第二步:
判断不等式① i < rPoint , 亦即确认当前检查的字符是否落在了当前有效回文字符串内
如果不等式①不成立, 说明当前还 没有找到回文字符串 , 或者 当前有效回文字符串 的半径 没有覆盖 到当前检查的字符, 则令 radius = 1 开始检查, 由于 radius = 1 , 即只包含当前元素本身, 必然立即找到以当前字符为中点第一个回文字符串(即它自己), 更新 P[i] = 1
如果不等式①成立, 说明之前的检查已经找到了 当前有效回文字符串, 并且其半径覆盖到了当前检查的字符, 也可以说当前检查的字符落在了 当前有效回文字符串内
那么 i 一定有一个关于当前有效回文字符串的中点即 mPoint 的 对称点 , 我们称它为 j
作为同在当前有效回文字符串内的两个对称点, 在不超出当前有效回文字符串的左右两端的前提下, 注意这里要强调不超出 , 我们不难想象, 如果以 j 为中点可以形成一个回文字符串, 那么一定也可以以 i 为中点形成一个相同的回文字符串(否则就不对称, 当前有效回文字符串就不可能存在).
于是我们可以整理下目前已经直接或者间接知道的事实:
(1) P[j] 中已经存储了以 j 这个元素为中点可以形成的最长回文字符串半径
(2) 当前有效回文字符串是以 mPoint 为中心可以形成的最长回文字符串, 也就是说以 mPoint 为中心, 不可能再有更长的回文字符串 , 并且其半径已经存储在了 P[mPoint] 中
(3) 如果回文字符串内部 对称 位置上有两个回文子串, 那么这两个回文子串必然是相同的
进而我们可以有以下推导(请读者不妨拿出笔和纸画一画线段图, 帮助理解):
a. 当 P[j]>rPoint-i 时, 也就是说以 j 这个元素为中点形成的最长回文字符串足以延伸至当前有效回文字符串左端以外时, 则一定有 P[i] = rPoint-i , 因为如果 P[i] > rPoint-i , 说明以 i 这个元素为中点形成的最长回文字符串足以延伸至当前有效回文字符串右端以外, 那么 当前有效回文字符串 就应该有更长的半径, 但这与事实(2)矛盾了. 而如果 P[i] < rPoint-i , 则在当前有效回文字符串内部就会出现不对称使其不能成为回文字符串, 这同样产生矛盾.
b. 当 P[j]<rPoint-i 时, 也就是说以 j 这个元素为中点形成的最长回文字符串完全被包裹在 当前有效回文字符串 内部时, 则一定有 P[i] = P[j] , 否则它与事实(3)矛盾
以上两种情况就可以直接得出P[i], 无需任何检查!
c. 当 P[j] = rPoint-i 时呢? 这时只能确定 P[i] 应至少等于 rPoint-i , 否则会与事实(3)矛盾, 可是 P[i] 可以更大, 这时我们才需要令 radius=rPoint-i 开始检查(这就比令 radius = 1 开始检查高效)
以当前元素为中点, 半径为 radius 开始检查回文字符串, 如果是回文字符串则扩展半径 radius , 尝试寻找更长的回文字符串, 直至失败
此时要满足两个条件:
②扩展半径之后, 左端和右端的下标不越界.
③当前左端和右端的元素字符相同.
如果条件②和③都成立,则 P[i] = P[i] + 1
紧接着判断不等式④ i+P[i] > rPoint
如果④成立, 说明当前回文字符串的右端已经延伸到了更靠右的位置, 即产生新的 当前有效回文字符串
立即更新 mPoint 为当前的 i , rPoint 为 i+P[i]
mPoint=i
rPoint=i+P[i]
如果 P[i] 比已知的最大回文字符串半径都大, 记录并更新最大半径(根据最终需求结果不同也可能是记录 mPoint 和 rPoint 的下标),
循环执行直至②或③不成立
第三步
i 自增, 重复执行第二步, 直至 i 到达字符数组的最有端(当然如果从 i 的位置不可能再找到比当前最长回文字符串更长的回文字符串时, 就可以提前结束)
⑦ 面试题 描述java中字符串的比较方式有哪些
java中的字符串比较方法：
1）string1.equals(string2)
2） str1==str2 。
java中字符串的比较是==比较引用，equals 比较值的做法。但是不同的声明方法字符串的比较结果也是不同的。
例如： String str1=new String("a");
String str2=new String("a");
str1==str2 输出false
str1.equals(str2) 输出true
而如果这样声明
String str1="a";
String str2="a";
str1==str2 输出true
str1.equals(str2) 输出true
这是因为 equals 方法本来也是比较引用的字符串类在实现的时候重写了该方法。
第一种声明方法等于是声明了两个对象，用’==‘比较是时候比较的是引用输出的是false 由于他们的值相同用equals的时候就比较的是值了，输出true。
第二种情况不是因为比较有与第一种有差异，而是因为声明有差异，第二种声明方法在声明的时候有堆或堆栈 共用的现象，也就是说
在声明的时候如果如果声明为类属性他会检查在堆栈中有没有与现在声明的是相同结构的字符串。如果有就直接将地址指向已有内存地址。声明在方法内部的局部变
量原理一样只不过他是堆栈共享。
⑧ Java程序员面试题 1.String s = new String(“xyz”); 创建了几个String Object
通常版
创建2个String 对象, 都为 "xyz".
严禁版
要看 外部条件, 在标准SUN JVM里, 如果在此代码之前的代码中有"xyz"的声明 那么只会创建 一个String 对象 即通过new 关键字创建出来的. 在括号内的"xyz" 会使用JVM 之前创建的对象.
⑨ 字符串匹配算法是怎么算的
这是一个毕业老师出的字符串的算法的题目！这是答案 可以参考一下！ boyermoore算法的sample程序 TCHAR * BoyerMooreSearch(TCHAR *sSrc, TCHAR *sFind) { // // 声明： // 该段代码只是BoyerMoore(名字也许不准确) 的基本思想，当 // 然不是最优的，具体完善工作就留给你自己乐！嘻嘻。 // 该算法的本质就是从字符串的右端而不是左端开始比较，这 // 样，当查询不匹配时才有可能直接跃过多个字符（最多可以跃过 // strlen(sFind)个字符）， 如果最右边的字符匹配则回溯。比如： // // pain // ^ 这是第一次比较n和空格比 // The rain in SpainThe rain in Spain // // pain // ^ 这是第二次比较，好爽呀！ // The rain in SpainThe rain in Spain // // 当然，这样比较会产生一些问题，比如： // // pain // ^ （图1） // The rain in SpainThe rain in Spain // // 如果比较到这儿，大家都会看到，只需再向后移到两个字符 // 就匹配成功了，但如果接下去还按上面的方法跳strlen( sFind)的 // 话，就会错过一次匹配！！！！！ // // pain // ^ // The rain in SpainThe rain in Spain // // 怎么办？当然可以解决！大家回头看图1，当时a是pain的子 // 串，说明有可能在不移动strlen(sFind) 的跨度就匹配成功，那就 // 人为地给它匹配成功的机会嘛！串一下pain串， 直接让两个a对齐 // 再做比较！呵呵，如果要比较的字符不是pain的子串，当然就可 // 以直接跨过strlen(sFind)个字符了！ 不知我说明白没？ // // // 查询串的长度 int nLenOfFind = lstrlen(sFind); // 被查询串的长度 int nLenOfSrc = lstrlen(sSrc); // 指向查询串最后一个字符的指针 TCHAR * pEndOfFind = sFind + nLenOfFind -1; // 指向被查询串最后一个字符的指针 TCHAR * pEndOfSrc = sSrc + nLenOfSrc -1; // 在比较过程中要用到的两个指针 TCHAR * pSrc = sSrc; TCHAR * pFind; // 总不能一直让它比较到 win.com 文件的地址去吧？嘻嘻！ while ( pSrc <= pEndOfSrc ) { // 每次匹配都是从右向左，这是本算法的核心。 pFind = pEndOfFind; // 如果比较不成功，被查询串指针将向右串的字符数 int nMoveRightSrc; // 比较被查询串的当前字符是否和查询串的最右边字 // 符匹配，如果匹配则回溯比较，如果全匹配了，该 // 干什么，我就不用说了吧？:-) while ( pFind >= sFind ) { // TNND，白废功夫比了！看看需要向右移动几个 // 字符吧（如果说从右到左是本算法的核心，则 // 判断向右移几个字符则是本算法的技巧）。 if ( *pSrc != *pFind ) { // 被查询串的当前字符是否在查询串里？ TCHAR * p = strrchr( sFind, *pSrc ); // 没在，直接移lstrlen(sFind)个字符 if ( NULL == p ) nMoveRightSrc = nLenOfFind; else // 哇塞！真的在，那就只需... nMoveRightSrc = pEndOfFind - p; break; } // 哈！又匹配成功了一个！接着向左回溯... pFind --; pSrc --; } // 如果在上面的while循环里每一次比较都匹配了 // 那就对了呗！告诉用户找到了 if ( pFind < sFind ) return ( pSrc + 1 ); // 没匹配成功，nMoveRightSrc上面已经算好了 // 直接用就可以了。 pSrc += nMoveRightSrc; } // 程序运行到这儿肯定是没指望了！ return NULL; } 行了，函数写完了，我们可以试一下了！ void CTNNDDlg::OnButton1() { TCHAR sSrc[] = "The rain in Spain"; TCHAR sFind[]= "pain"; TCHAR * pFound = BoyerMooreSearch( sSrc, sFind ); if ( pFound ) MessageBox(pFound); else MessageBox("没找到"); } //另外一个 void preBmBc(char *x, int m, int bmBc[]) { int i; for (i = 0; i < ASIZE; ++i) bmBc[i] = m; for (i = 0; i < m - 1; ++i) bmBc[x[i]] = m - i - 1; } void suffixes(char *x, int m, int *suff) { int f, g, i; suff[m - 1] = m; g = m - 1; for (i = m - 2; i >= 0; --i) { if (i > g && suff[i + m - 1 - f] < i - g) suff[i] = suff[i + m - 1 - f]; else { if (i < g) g = i; f = i; while (g >= 0 && x[g] == x[g + m - 1 - f]) --g; suff[i] = f - g; } } } void preBmGs(char *x, int m, int bmGs[]) { int i, j, suff[XSIZE]; suffixes(x, m, suff); for (i = 0; i < m; ++i) bmGs[i] = m; j = 0; for (i = m - 1; i >= -1; --i) if (i == -1 || suff[i] == i + 1) for (; j < m - 1 - i; ++j) if (bmGs[j] == m) bmGs[j] = m - 1 - i; for (i = 0; i <= m - 2; ++i) bmGs[m - 1 - suff[i]] = m - 1 - i; } void BM(char *x, int m, char *y, int n) { int i, j, bmGs[XSIZE], bmBc[ASIZE]; /* Preprocessing */ preBmGs(x, m, bmGs); preBmBc(x, m, bmBc); /* Searching */ j = 0; while (j <= n - m) { for (i = m - 1; i >= 0 && x[i] == y[i + j]; --i); if (i < 0) { OUTPUT(j); j += bmGs[0]; } else j += MAX(bmGs[i], bmBc[y[i + j]] - m + 1 + i); } }
⑩ 面试算法知识梳理(14) - 数字算法
面试算法知识梳理(1) - 排序算法
面试算法知识梳理(2) - 字符串算法第一部分
面试算法知识梳理(3) - 字符串算法第二部分
面试算法知识梳理(4) - 数组第一部分
面试算法知识梳理(5) - 数组第二部分
面试算法知识梳理(6) - 数组第三部分
面试算法知识梳理(7) - 数组第四部分
面试算法知识梳理(8) - 二分查找算法及其变型
面试算法知识梳理(9) - 链表算法第一部分
面试算法知识梳理(10) - 二叉查找树
面试算法知识梳理(11) - 二叉树算法第一部分
面试算法知识梳理(12) - 二叉树算法第二部分
面试算法知识梳理(13) - 二叉树算法第三部分
斐波那契数列 满足下面的通项公式，要求给出 N ，输出第 N 项的 F(N)
这里介绍两种解决办法， 循环算法 和 矩阵算法 。循环算法比较容易理解，就是从 F(0) 开始，根据通项公式，得到下一个斐波那契数列中的数字即可。
对于上面的通项公式，可以用下面的矩阵乘法的形式来表示
一个台阶总共有 n 级，如果一次可以跳 1 级，也可以跳 2 级，求总共有多少总跳法。
由于有两种跳台阶方式，因此跳 n 级台阶可以转换为下面两个问题之和：
这就和之前的斐波那契数列的通项公式相同。
这个问题，需要先总结一下规律，我们根据数字 N 的 位数 来进行分析：
那么 N>=1 时才会出现 1 ，并且出现 1 的次数为 1 次
在这种情况下，出现 1 的次数等于个位上出现 1 的次数加上十位上出现 1 的个数。
例如，如果要计算百位上 1 出现的次数，它要受到三方面的影响：百位上的数字，百位以下的数字，百位以上的数字。
对于一个二进制数，例如 1010 ，将其减 1 后得到的结果是 1001 ，也就是将最后一个 1 （倒数第二位）及其之后的 0 变成 1 ， 1 变成 0 ，再将该结果与原二进制数相与，也就是 1010 & 1001 = 1000 ，那么就可以去掉最后一个 1 。
因此，如果需要计算两个数的二进制表示中有多少位是不同的，可以 先将这两个数异或 ，那么不相同的位数就会变成 1 ，之后利用上面的技巧，通过每次去掉最后一个 1 ，来 统计该结果中 1 的个数 ，就可以知道两个数的二进制表示中有多少是不同的了。
N! 的含义为 1*2*3*...*(N-1)*N ，计算 N! 的十进制表示中，末尾有多少个 0 。
N! 中能产生末尾是 0 的质数组合是 2*5 ，所以 N! 末尾的 0 的个数取决了 2 的个数和 5 的个数的最小值，有因为被 2 整除的数出现的概率大于 5 ，因此 5 出现的次数就是 N! 末尾 0 的个数。因此，该问题就转换成为计算从 1~N ，每个数可以贡献 5 的个数，也就是每个数除以 5 的值。
上面的解法需要从 1 到 N 遍历每一个数，当然还有更加简便的方法。以 26! 为例，贡献 5 的数有 5、10、15、20、25 ，一共贡献了 6 个 5 ，可以理解为 5 的倍数 5、10、15、20、25 贡献了一个 5 ，而 25 的倍数又贡献了一个 5 ，得到下面的公式：
首先，让我们换一个角度考虑，其实这个问题就是求解二进制表示中从最低位开始 0 的个数，因为二进制最低位为 0 代表的是偶数，能够被 2 整除，所以质因数 2 的个数就是二进制表示中最低位 1 后面的 0 的个数。
因此，我们的实现这就和上面 2.7 中求解质因数 5 的个数是一样的。
最大公约数 的定义为 两个或多个整数的共有约数中最大的一个 。这里采用的是 更相止损法 ，其操作步骤为：
则第一步中约掉的若干个 2 与第二步中等数的乘积就是所求的最大公约数。
有限小数或者无限循环小数都可以转化为分数，例如：
在 http://blog.csdn.net/flyfish1986/article/details/47783545 这边文章中，详细地描述了该题的解决思路，核心思想就是将原小数分为 有限部分 和 无限循环小数 部分，对于这两部分别进行处理。