java 递归 面试题

package math;

public class RevertANumber {

/*

* 一列数的规则如下: 1、1、2、3、5、8、13、21、34...... 求第30位数是多少， 用递归算法实现。

* */

static int find30(int n){

if (n <= 0)

return 0;

else if(n > 0 && n <= 2)

return 1;

return find30(n-1)+find30(n-2);



}





/*

* 将一整数逆序后放入一数组中（要求递归实现） Ex : 1234 变为 {4,3,2,1}

*/

static int revert(int rs[], int i, int number) {

if (i < rs.length) {

rs[i] = number % 10;

number = (number - number % 10) / 10;

return revert(rs, i + 1, number);

} else {

return 0;

}

}

/*

* 递归实现回文判断（如：abcdedbca就是回文，判断一个面试者对递归理解的简单程序）

*/

static boolean loopWord(String str, int i) {

if (str.charAt(i) == str.charAt(str.length() - 1 - i)) {

if (i == (str.length() + 1) / 2)

return true;

return loopWord(str, i + 1);

} else {

return false;

}

}

/*

* 分解成质因数(如435234=251*17*17*3*2，据说是华为笔试题)

*/

static void dividePrimeToFactors(int num, int factor) {

while ((factor < num) && (num % factor != 0))

factor++;

if(factor<=num)

{

System.out.print(factor + " ");

num = num / factor;

dividePrimeToFactors(num, 2);

return;

}

else if (factor >num)

{

System.out.println(num);

return ;// 结束判断

}

}

public static void main(String[] args) {



System.out.println(find30(30));



int number = 1234;

int[] rs = new int[(number + "").length()];

revert(rs, 0, number);

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

System.out.print(rs[i]);

}

System.out.println(loopWord("1234321", 0));

dividePrimeToFactors(435234, 2);

}

}

================================================================================

//递归 寻找迷宫出路

package agrisom;

import java.util.EmptyStackException;

import java.util.Stack;

/**

* 递归_迷宫

*/

/**

* 位置类

*/

class Position{

public int row;

public int col;

public Position(int row,int col){

this.row=row;

this.col=col;

}

}

public class Maze {

public Stack<Position> stack=new Stack<Position>(); //保存迷宫路径

public int array[][] ={

{1,1,1,1,1,1,1,1},

{1,0,0,0,1,0,0,1},

{1,0,1,1,1,0,0,1},

{0,0,1,0,1,0,0,0},

{1,1,1,0,1,0,0,1},

{1,1,0,1,1,1,1,1},

{0,0,0,1,0,0,0,0},

{0,0,1,1,1,1,1,1},

};

//定义的方格数组需在迷宫内

private boolean value(int hang,int lie){

if(hang >= 0 && hang < array.length &&

lie >=0 && lie< array.length &&

array[hang][lie] == 1){

return true;

}else{

return false;

}

}

private boolean discovery(int row, int col){

boolean pass =false;

if(value(row,col)){

//将走过的位置标记为2

array[row][col] = 2;

Position pos=new Position(row,col);

this.stack.push(pos);

//判断是否到达终点.

if(row == array.length -1 && col == array.length - 1){

pass = true;

}else{//往右走

pass = discovery(row,col + 1);

//往下走

if(pass==false)

pass = discovery(row + 1, col);

//往左走

if(pass==false)

pass = discovery(row , col-1);

//往上走

if(pass==false)

pass = discovery(row - 1, col);

}

if(pass==true) {

array[row][col] = 3;

}else{

this.stack.pop();

}

}

return pass;

}

public static void main(String[] args) {

Maze mi = new Maze();

int[][] c = mi.array;

//输出走之前的迷宫

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

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

// System.out.print(mi.array[i][j]+" ");

if(mi.array[i][j] == 1)

System.out.print("□"+" ");

if(mi.array[i][j] == 0)

System.out.print("■"+" ");

}

System.out.println();

}

System.out.println(mi.discovery(0,0));

//输出走过之后的迷宫

for(int i = 0 ;i<= c.length-1;i++){

for(int j = 0; j<= c.length-1;j++){



// System.out.print(c[i][j]+" ");

if(c[i][j] == 1)

System.out.print("□"+" ");

if(c[i][j] == 0)

System.out.print("■"+" ");

if(c[i][j] == 3)

System.out.print("○"+" ");

if(c[i][j] == 2)

System.out.print("●"+" ");

}

System.out.println();

}

System.out.println();

//输出路径

Stack<Position> stack=new Stack<Position>();

Position pos=mi.stack.pop();

while(pos!=null){

stack.push(pos);

try{

pos=mi.stack.pop();

}catch(EmptyStackException e){

break;

}



}

pos=stack.pop();

int length=stack.size();

while(pos!=null){

if(1==length){

System.out.print("("+pos.row+","+pos.col+")");

}else{

System.out.print("("+pos.row+","+pos.col+")→");

length=stack.size();

}

try{

pos=stack.pop();

}catch(EmptyStackException e){

break;

}

}

}

}

/**

运行结果:

□ □ □ □ □ □ □ □

□ ■ ■ ■ □ ■ ■ □

□ ■ □ □ □ ■ ■ □

■ ■ □ ■ □ ■ ■ ■

□ □ □ ■ □ ■ ■ □

□ □ ■ □ □ □ □ □

■ ■ ■ □ ■ ■ ■ ■

■ ■ □ □ □ □ □ □

true

○ ○ ○ ○ ○ ● ● ●

□ ■ ■ ■ ○ ■ ■ ●

□ ■ □ □ ○ ■ ■ ●

■ ■ □ ■ ○ ■ ■ ■

□ □ □ ■ ○ ■ ■ ●

□ □ ■ ○ ○ ● ● ●

■ ■ ■ ○ ■ ■ ■ ■

■ ■ □ ○ ○ ○ ○ ○

(0,0)→(0,1)→(0,2)→(0,3)→(0,4)→(1,4)→(2,4)→(3,4)→(4,4)→(5,4)→(5,3)→(6,3)→(7,3)→(7,4)→(7,5)→(7,6)→(7,7)

*/