题目1
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数
思路：从后往前，从前往后，确定行，确定列
184ms
public class Solution {
public boolean Find(int target, int [][] array) {
int m = array.length - 1;
int i = 0;
while(m >= 0 && i < array[0].length){
if(array[m][i] > target)
m--;
else if(array[m][i] < target)
i++;
else
return true;
}
return false;
}
}
题目2
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
方法1：16ms
public class Solution {
public String replaceSpace(StringBuffer str) {
String s = str.toString();
if(str==null)
return s;
char []ss=s.toCharArray();
StringBuffer sb = new StringBuffer();
for(int i=0;i<ss.length;i++)
{
if(ss[i]==' ')
{
sb.append("%20");
}
else
sb.append(ss[i]);
}
return sb.toString();
}
}
方法2：18ms
public class Solution {
public String replaceSpace(StringBuffer str) {
return str.toString().replace(" ","%20");
}
}
题目3
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
方法1：14ms
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
Stack<Integer> stack=new Stack<Integer>();
while(listNode!=null){
stack.push(listNode.val);
listNode=listNode.next;
}
ArrayList<Integer> array=new ArrayList<Integer>();
while(!stack.isEmpty()){
array.add(stack.pop());
}
return array;
}
}
方法2：14ms
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
ArrayList<Integer> array=new ArrayList<Integer>();
if(listNode!=null){
if(listNode.next!=null){
array=printListFromTailToHead(listNode.next);
}
array.add(listNode.val);
}
return array;
}
}
题目4
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
/* 先序遍历第一个位置肯定是根节点node，
中序遍历的根节点位置在中间p，在p左边的肯定是node的左子树的中序数组，p右边的肯定是node的右子树的中序数组
另一方面，先序遍历的第二个位置到p，也是node左子树的先序子数组，剩下p右边的就是node的右子树的先序子数组
把四个数组找出来，分左右递归调用即可
*/
运行时间：230ms
占用内存：23368k
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
TreeNode root=reConstructBinaryTree(pre,0,pre.length-1,in,0,in.length-1);
return root;
}
//前序遍历{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}
private TreeNode reConstructBinaryTree(int [] pre,int startPre,int endPre,int [] in,int startIn,int endIn) {
if(startPre>endPre||startIn>endIn)
return null;
TreeNode root=new TreeNode(pre[startPre]);
for(int i=startIn;i<=endIn;i++)
if(in[i]==pre[startPre]){
root.left=reConstructBinaryTree(pre,startPre+1,startPre+i-startIn,in,startIn,i-1);
root.right=reConstructBinaryTree(pre,i-startIn+startPre+1,endPre,in,i+1,endIn);
break;
}
return root;
}
}
题目5
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
n<=39
运行时间：17ms
占用内存：9228k
public class Solution {
public int Fibonacci(int n) {
if (n < 1)
return 0;
if (n == 1 || n == 2)
return 1;
int[][] base = { { 1, 1 }, { 1, 0 } };
int[][] res = maxtrixPower(base, n - 2);
return res[0][0] + res[0][1];
}
private int[][] maxtrixPower(int[][] m, int p) {
int[][] res = new int[m.length][m.length];
for (int i = 0; i < m.length; i++) {
res[i][i] = 1;
}
int[][] tmp = m;
for (; p != 0; p >>= 1) {
if ((p & 1) != 0) {
res = multiMatrix(res, tmp);
}
tmp = multiMatrix(tmp, tmp);
}
return res;
}
/*
* 求两个矩阵相乘
*/
public int[][] multiMatrix(int[][] m1, int[][] m2) {
int[][] res = new int[m1.length][m2[0].length];
for (int i = 0; i < m1.length; i++) {
for (int j = 0; j < m2[0].length; j++) {
for (int k = 0; k < m1[0].length; k++) {
res[i][j] += m1[i][k] * m2[k][j];
}
}
}
return res;
}
}
题目6
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
方法1：
运行时间：1614ms
占用内存：9432k
public class Solution {
public int JumpFloor(int target) {
int n=0;
if(target==0){
return 1;
}
if(target<0)
return 0;
n+=JumpFloor(target-1);
n+=JumpFloor(target-2);
return n;
}
}
方法2：本问题就是斐波那契数列的应用的所以解法和斐波那契数列一致
运行时间：10ms
占用内存：9432k
public class Solution {
public int JumpFloor(int target) {
if(target==1)
return 1;
if(target==2)
return 2;
if(target<0)
return 0;
int first=1;
int second=2;
int temp=0;
for(int i=0;i<target-2;i++){
temp=first;
first=second;
second=temp+second;
}
return second;
}
}
题目7
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
提示: f(1)=1;f(2)=f(1)+1;f(3)=f(2)+f(1)+1;f(4)=f(3)+f(2)+f(1)+1
运行时间：10ms
占用内存：9292k
public class Solution {
public int JumpFloorII(int target) {
if(target<=0)
return 0;
if(target==1)
return 1;
return 2*JumpFloorII(target-1);
}
}
题目8
我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
方法1：递归法,该问题类似于菲波那切数列问题，用的思想还是从1开始推到，发现前一项和后一项之间的关系。
运行时间：586ms
占用内存：9352k
public class Solution {
public int RectCover(int target) {
if(target==1)
return 1;
if(target==2)
return 2;
if(target<1)
return 0;
return RectCover(target-1)+RectCover(target-2);
}
}