java算法面试题-----1

.比较两个字符串如果不等返回True？
答案： 
 

Java代码

1. package com.test.kaoshi;   
2.   
3. public class StringDemo {   
4.   
5.     private static String a = "abc";   
6.     private static String b = "abcg";   
7.   
8.     public static boolean equalString() {   
9.         if (a.equals(b)) {   
10.             return false;   
11.         } else {   
12.                
13.             return true;   
14.         }   
15.     }   
16.     public static void main(String[] args) {   
17.         StringDemo  sd = new StringDemo();   
18.         System.out.println("主要考察返回Boolean变量和字符串比较使用的方法?+sd.equalString());   
19.     }   
20. }  

[java] view plaincopy

1. package com.test.kaoshi;  
2.   
3. public class StringDemo {  
4.   
5.     private static String a = "abc";  
6.     private static String b = "abcg";  
7.   
8.     public static boolean equalString() {  
9.         if (a.equals(b)) {  
10.             return false;  
11.         } else {  
12.               
13.             return true;  
14.         }  
15.     }  
16.     public static void main(String[] args) {  
17.         StringDemo  sd = new StringDemo();  
18.         System.out.println("主要考察返回Boolean变量和字符串比较使用的方法?+sd.equalString());  
19.     }  
20. }  

2.随机产生20个字符并且排序？

答案：
 

Java代码

1. package com.test.kaoshi;   
2.   
3. import java.util.HashSet;   
4. import java.util.Iterator;   
5. import java.util.Random;   
6. import java.util.Set;   
7. import java.util.TreeSet;   
8.   
9. public class RadomDemo {   
10. /**  
11.  * 随机产生20个字符串并且字符串不能重复 且进行排序  
12.  * @param random  
13.  * @param len  
14.  * @return  
15.  */  
16.     public Set getChar(){   
17.            
18.         Set numberSet01 = new HashSet();   
19.         Random rdm = new Random();   
20.         char ch;   
21.         while(numberSet01.size()<20){    
22.            int rdGet = Math.abs(rdm.nextInt())%26+97;//产生97到122的随机数a-z值  
23.             ch=(char)rdGet;   
24.             numberSet01.add(ch);   
25.             //Set中是不能放进重复的值的，当它有20个时，就满足你的条件了   
26.         }    
27.           return numberSet01;   
28.         }   
29.     public static void main(String[] args) {   
30.         RadomDemo rd = new RadomDemo();   
31.         Set numberSet01=rd.getChar();   
32.            
33.         Set numberSet = new TreeSet();    
34.         numberSet.addAll(numberSet01);   
35.         for(Iterator it=numberSet01.iterator();it.hasNext();){    
36.             System.out.print(it.next());    
37.             }    
38.         System.out.println();   
39.         for(Iterator it=numberSet.iterator();it.hasNext();){    
40.             System.out.print(it.next());    
41.             }    
42.     }   
43. }  

[java] view plaincopy

1. package com.test.kaoshi;  
2.   
3. import java.util.HashSet;  
4. import java.util.Iterator;  
5. import java.util.Random;  
6. import java.util.Set;  
7. import java.util.TreeSet;  
8.   
9. public class RadomDemo {  
10. /** 
11.  * 随机产生20个字符串并且字符串不能重复 且进行排序 
12.  * @param random 
13.  * @param len 
14.  * @return 
15.  */  
16.     public Set getChar(){  
17.           
18.         Set numberSet01 = new HashSet();  
19.         Random rdm = new Random();  
20.         char ch;  
21.         while(numberSet01.size()<20){   
22.            int rdGet = Math.abs(rdm.nextInt())%26+97;//产生97到122的随机数a-z值  
23.             ch=(char)rdGet;  
24.             numberSet01.add(ch);  
25.             //Set中是不能放进重复的值的，当它有20个时，就满足你的条件了   
26.         }   
27.           return numberSet01;  
28.         }  
29.     public static void main(String[] args) {  
30.         RadomDemo rd = new RadomDemo();  
31.         Set numberSet01=rd.getChar();  
32.           
33.         Set numberSet = new TreeSet();   
34.         numberSet.addAll(numberSet01);  
35.         for(Iterator it=numberSet01.iterator();it.hasNext();){   
36.             System.out.print(it.next());   
37.             }   
38.         System.out.println();  
39.         for(Iterator it=numberSet.iterator();it.hasNext();){   
40.             System.out.print(it.next());   
41.             }   
42.     }  
43. }  

3.50个人围成一圈数到三和三的倍数时出圈，问剩下的人是谁？在原来的位置是多少？


答案：

 

Java代码

1. package com.test.kaoshi;   
2.   
3. import java.util.Iterator;   
4. import java.util.LinkedList;   
5.   
6. public class YouXi {   
7.     public static int removeNM(int n, int m) {   
8.         LinkedList ll = new LinkedList();   
9.         for (int i = 0; i < n; i++)   
10.             ll.add(new Integer(i + 1));   
11.         int removed = -1;   
12.         while (ll.size() > 1) {   
13.             removed = (removed + m) % ll.size();   
14.             ll.remove(removed--);   
15.         }   
16.         return ((Integer) ll.get(0)).intValue();   
17.     }   
18.   
19.     public static void main(String[] args) {   
20.         System.out.println(removeNM(50, 3));   
21.     }   
22. } 
    

4、

import java.util.Arrays;
import java.util.Random;

/**
* 几个经典的java算法面试题集锦,答案并不一定标准,多多指正
*
* @author lance
* @date 2010-09-04 15:23
*/
public class SomeDemo {
public static void main(String args[]) {
   findNumber();
   substring();
   exchange();
   compare();
   createNaN();
}

/**
* 一个已知的1-10000的int数组,中间去掉了一个,查找少了哪一个? 这个写得最没把握,多多指正
*/
public static void findNumber() {
   // 初始化一个1-10000的数组,中间随机少一个数
   int number = new Random().nextInt(10001);
   while (number == 0) {
    number = new Random().nextInt(10001);
   }
   int[] srcArray = new int[9999];
   for (int i = 1; i <= 10000; i++) {
    if (i < number) {
     srcArray[i - 1] = i;
    } else if (i > number) {
     srcArray[i - 2] = i;
    }
   }

   // 先升序排列,然后处理首尾元素,再二分查找缺少的元素
   Arrays.sort(srcArray);

   int findResult = -1;
   // 首尾元素直接处理
   if (srcArray[0] == 2) {
    findResult = 1;
   } else if (srcArray[srcArray.length - 1] == 9999) {
    findResult = 10000;
   }

   if (findResult == -1) {
    // 二分查找元素
    int head = 0;
    int end = srcArray.length;
    while (head < end) {
     int middle = (head + end) / 2;
     // 前面处理了首尾元素,因此这里不用担心数组越界了
     if (srcArray[middle] == srcArray[middle + 1] - 2) {
      findResult = srcArray[middle] + 1;
      break;
     } else if (srcArray[middle] == middle + 1) {
      head = middle;
     } else if (srcArray[middle] == middle + 2) {
      end = middle;
     }
    }
   }

   System.out.println("随机产生的数=" + number);
   System.out.println("找到的数=" + findResult + "\n");
}

/**
* 从字母数字中文混合的String中截取指定大小的byte字符串,保证不乱码
*/
public static void substring() {
   String src = "test测试字符串";
   int length = 5;
   String result = null;
   for (int i = 0; i < src.length(); i++) {
    if (src.substring(0, i).getBytes().length >= length) {
     result = src.substring(0, i);
     break;
    }
   }
   System.out.println(result + "\n");
}

/**
* 两个数互换,不引用第三个变量
*/
public static void exchange() {
   int a = 5; // 任意数
   int b = 10; // 任意数
   System.out.println("1. a=" + a + "\t b=" + b);
   a = a ^ b;
   b = a ^ b;
   a = a ^ b;
   System.out.println("2. a=" + a + "\t b=" + b + "\n");

   // 下面这个也可以
   // a = a + b;
   // b = a - b;
   // a = a - b;
}

/**
* java中NaN值的产生
*/
public static void createNaN() {
   // 在Double和Float类型中有NaN值; Integer,Long中没有.
   double a = 0, b = 0, c;
   c = a / (a + b);
   System.out.println(c + "\n");
}

/**
* java中两个自己不等于自己(即 o!=o 为true)的值, NaN和无穷大数
*/
public static void compare() {
   // 1
   double o = Double.longBitsToDouble(0x7ff8000000000000L);
   System.out.println(o != o);

   // 2
   System.out.println(Float.NaN != Float.NaN);
   System.out.println((Double.NaN != Double.NaN) + "\n");
}

}

5、题目是这样的：给你10分钟时间，根据上排给出十个数，在其下排填出对应的十个数 

 

　　要求下排每个数都是先前上排对应那个数在下排十个数中出现的次数。 

 

　　上排的十个数如下： 

 

　　【0，1，2，3，4，5，6，7，8，9】 

代码如下：

 

/** */

/**

 * http://yydcj.iteye.com/

 */

public class Test {

    public static void main(String[] args) {

        NumberTB nTB = new NumberTB(18);

        int[] result = nTB.getBottom();

        for (int i = 0; i < result.length; i++) {

            System.out.print(result[i] + " ");

        }

    }

 

    static class NumberTB {

 

        private int[] top;

        private int[] bottom;

        private int len;

        private boolean success;

 

        // please into len >= 4　　

        public NumberTB(int len) {

            this.len = len <= 4 ? 4 : len;

            this.success = false;

            this.top = new int[this.len];

            this.bottom = new int[this.len];

 

            // format top　　

            for (int i = 0; i < this.len; i++) {

                this.top[i] = i;

            }

        }

 

        public int[] getBottom() {

            int i = 0;

            while (!this.success) {

                i++;

                setNextBottom();

            }

            System.out.println("执行了: " + i + "次循环得到结果");

            return this.bottom;

        }

 

        // set next bottom　　

        private void setNextBottom() {

            boolean reB = true;

            for (int i = 0; i < this.len; i++) {

                int frequecy = getFrequecy(i);

                if (this.bottom[i] != frequecy) {

                    this.bottom[i] = frequecy;

                    reB = false;

                }

            }

            this.success = reB;

        }

 

        // get frequency in bottom　　

 

        private int getFrequecy(int num) {

            int count = 0;

            for (int i = 0; i < this.len; i++) {

                if (this.bottom[i] == num)

                    count++;

            }

            return count;

        }

    }

}

 

下面给出一个更具一般性的结论： 

 

　　这个是有规律可循的，不仅0~9有唯一解，0~n都只有唯一解。关键是最后面一个1它可以左右移动，1和2下面的数永远是2和1，0下面对应的数为n-3（n>=3），上排数n-3下面对应的数为1，其它上排数下面对应为0就ok了。有了这个一般性的结论再大的数都可以马上给出答案。www.2cto.com

 

　　比如 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 

 

　　 12 2 1 0 0 0 0 0 0 0 0 0 1 0 0 0

 

　　请大家验证，这个算法可以用到数据压缩领域。

6、写一个方法，能够判断任意一个整数是否素数
   
    /** 
     * 判断任意一个整数是否素数 
     * @param num 
     * @return boolean
     */ 
     public boolean isPrimeNumber(int num) 
     { 
       for (int i = 2; i <= Math.sqrt(num); i++) { 
           if(num%i==0) 
           { 
               return false; 
           } 
       } 
       return true; 
     }
7、1. 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，

最小值，平均值，和值，并输出出来。

 

class ArrayNumber{

public static void main(String[] args){

int[] arrayNumber;

arrayNumber = new int[10];

System.out.println(“以下是随机的10个整数：”);

// 填入随机的 10个整数

for (int i =0; i<arrayNumber.length; i++){

arrayNumber[i] = (int)(100*Math.random());

System.out.print(arrayNumber[i]+” “);

}

System.out.println();

int max = arrayNumber[0];

int min = arrayNumber[0];

int sum = 0;

for (int i =0; i<arrayNumber.length; i++){

if(max < arrayNumber[i])

max = arrayNumber[i];  //求最大值

if(min > arrayNumber[i])

min = arrayNumber[i];   //求最小值

sum += arrayNumber[i];

}

System.out.println(“其中 Max=”+max+”,Min=”+min+”,Sum=”+sum+”,Avg=”+sum/10.0);

}

}

 

 

2.定义一个int型的一维数组，包含10个元素，分别赋值为1~10， 然后将数组中的元素都向前移一个位置，

即，a[0]=a[1],a[1]=a[2],…最后一个元素的值是原来第一个元素的值，然后输出这个数组。

 

3. 定义一个int型的一维数组，包含40个元素，用来存储每个学员的成绩，循环产生40个0~100之间的随机整数，

将它们存储到一维数组中，然后统计成绩低于平均分的学员的人数，并输出出来。

 

4. （选做）承上题，将这40个成绩按照从高到低的顺序输出出来。

 

5,（选做）编写程序，将一个数组中的元素倒排过来。例如原数组为1，2，3，4，5；则倒排后数组中的值

为5，4，3，2，1。

 

6,要求定义一个int型数组a,包含100个元素,保存100个随机的4位数。再定义一个

int型数组b，包含10个元素。统计a数组中的元素对10求余等于0的个数，保存

到b[0]中；对10求余等于1的个数，保存到b[1]中，……依此类推。

 

class Remain{

public  static void main( String[] args){

int[] a = new int[100];

 

//保存100个随机4位数到 a 中

for (int i = 0;  i < a.length;  i++){

a[i] = (int) (1000*Math.random());

}

 

//统计 a 数组中的元素对 10 求余的各个的数目

int[] b = new int[10];

int k,sum;

for (int j = 0;  j < b.length;  j++){

for (k=0,sum=0;  k < a.length;  k++){

if ((a[k]%10)==j) sum++;

}

b[j] = sum;

System.out.printf(“b[%d]=%d\n”,j,b[j]);

}

}

}

 

 

7,定义一个20*5的二维数组，用来存储某班级20位学员的5门课的成绩；这5门课

按存储顺序依次为：core C++，coreJava，Servlet，JSP和EJB。

（1）循环给二维数组的每一个元素赋0~100之间的随机整数。

（2）按照列表的方式输出这些学员的每门课程的成绩。

（3）要求编写程序求每个学员的总分，将其保留在另外一个一维数组中。

（4）要求编写程序求所有学员的某门课程的平均分。

 

class Student{

public static void main(String[] args ){

int[][] mark = new int[20][5];

// 给学生赋分数值，随机生成

for ( int i = 0;  )

}

}//未完成

 

 

8,完成九宫格程序

在井字形的格局中(只能是奇数格局)，放入数字(数字由)，使每行每列以及斜角线的和都相等

 

经验规则：从 1 开始按顺序逐个填写； 1  放在第一行的中间位置；下一个数往右上角45度处填写；

如果单边越界则按头尾相接地填；如果有填写冲突，则填到刚才位置的底下一格；

如果有两边越界，则填到刚才位置的底下一格。

 

个人认为，可以先把最中间的数填到九宫格的最中间位置；再按上面的规则逐个填写，而且

填的时候还可以把头尾对应的数填到对应的格子中。(第 n 个值跟倒数第 n 个值对应，格局上以最中

间格为轴心对应)

这样就可以同时填两个数，效率比之前更高；其正确性有待数学论证(但多次实验之后都没发现有错)。

九宫格的 1 至少还可以填在另外的三个位置，只是接下来的填写顺序需要相应改变；

再根据九宫格的对称性，至少可以有8种不同的填写方式

 

import java.util.Scanner;

class NinePalace{

public static void main(String[] args){

// 定义 N 为九宫格的行列数，需要输入

System.out.println(“请输入九宫格的行列规模(只能是奇数的)”);

Scanner n = new Scanner(System.in);

int N;

 

//判断格局是否奇数 （可判断出偶数、负数 及小数）

double d;

while (true){

d = n.nextDouble();

N = (int)d;

if ((d-N)>1.0E-4||N%2==0||N<0)

{System.out.println(“输入出错,格局只能是正奇数。请重新输入”);}

else break;

}

 

//老师的九宫格填写方法

int[][] result = new int[N][N];   //定义保存九宫格的数组

int row = 0; //行 初始位置

int col = N/2; //列 初始位置,因为列由0开始，故N/2是中间位置

for (int i=1;  i<=N*N; i++){

result [row][col] = i;

row–;

col++;

if (row=N){col–;row+=2;} //行列都越界

else if (row<0){ row = N-1;}   //行越界

else if (col>=N){col = 0;}  //列越界

else if (result[row][col] != 0){col–;row+=2;}  //有冲突

}

 

//打印出九宫格

for (int i=0;  i<N;  i++){

for(int j=0;  j<N; j++){System.out.print(result[i][j]+”\t”);}

System.out.println();

}

 

//我个人的填格方式

int[][] result2 = new int[N][N];  //为免冲突，重新 new 一个数组

result2[N/2][N/2] = (N*N+1)/2;  //先把中间值赋予中间位置

row = 0;   //定义行及列的初始赋值位置。之前赋值的for对两个值有影响，故需重新定位

col = N/2;

for (int i=1; i<=N*N/2; i++){

result2[row][col] = i;

//下面这句是把跟 i 对应的值放到格局对应的位置上

result2[N-row-1][N-col-1] = N*N+1-i;

row–;

col++;

if (row<0){ row = N-1;}   //行越界

else if (col>=N){col = 0;}  //列越界

else if (result2[row][col] != 0){col–;row+=2;}  //有冲突

//这方法不可能出现行列两边都越界的情况,详情需要数学论证

}

 

System.out.println();

//再次打印出九宫格，以对比验证

for (int i=0;  i<N;  i++){

for(int j=0;  j<N; j++){System.out.print(result2[i][j]+”\t”);}

System.out.println();

}

 

}

}

 

 

 

 

 

9,求一个3*3矩阵对角线元素之和

 

 

10,打印杨辉三角

 

 

11. 约梭芬杀人法

把犯人围成一圈，每次从固定位置开始算起，杀掉第7个人，直到剩下最后一个。

 

11_2、用数组实现约瑟夫出圈问题。 n个人排成一圈，从第一个人开始报数，从1开始报，报到m的人出圈，剩下的人继续开始从1报数，直到所有的人都出圈为止。对于给定的n,m，求出所有人的出圈顺序。

 

 

 

12. 判断随机整数是否是素数

产生100个0-999之间的随机整数，然后判断这100个随机整数哪些是素数，哪些不是?

 

public class PrimeTest{

public static void main(String args[]){

for(int i=0;i<100;i++){

int num = (int)(Math.random()*1000);

PrimeTest t = new PrimeTest();

if(t.isPrime(num)){

System.out.println(num+” 是素数!”);

}else{

System.out.println(num+” 不是素数!”);

}

System.out.println();

}

}

public boolean isPrime(int num){

for(int i=2;i<=num/2;i++){

if(num%i==0){

System.out.println(num+”第一个被”+i+”整除!”);

return false;

}

}

return true;

}

}

 

 

 

 

 

 

 

冒泡排序法：

//按从大到小的排序

int tmp = a[0];

for (int i=0; i < a.length; i++){

for (int j=0; j < a.length – i -1; j++){

if (a[j] < a[j+1]) {

tmp = a[j];

a[j] = a[j+1];

a[j+1] = tmp;

}

}

}