以前总是断断续续的刷剑指offer,现在准备以10道题为一组进行整理分析方便复习查看,后面会陆续更新,按牛客网上剑指offer的题号进行排序,欢迎浏览。
JZ1:二维数组中的查找
题目描述:在一个二维数组中(每个一维数组的长度相同),每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。
解题思路:这个题相对比较简单,两个for循环,一个控制数组长度,一个控制每个arr[i]的长度,找到就返回true;
public static boolean Find(int target,int[][] array){
for(int i=0;i<array.length;i++){
for(int j=0;j<array[0].length;i++){
if(array[i][j]==target){
return true;
}
}
}
return false;
}
JZ2:替换空格
题目描述:请实现一个函数,将一个字符串中的每个空格替换成“%20”。例如,当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
解题思路:用的是StringBuffer的方法,从后往前遍历,如果它等于空格,就删了,然后把%20插进去。
public class Solution {
public String replaceSpace(StringBuffer str) {
for(int i=str.length()-1;i>=0;i--){
if(str.charAt(i)==' '){//charAt(i):获得i位置的元素
str.deleteCharAt(i);
str.insert(i,"%20");
}
}
return str.toString();//转成字符串
}
}
JZ3:从尾到头打印链表
题目描述:输入一个链表,按链表从尾到头的顺序返回一个ArrayList。
解题思路:建一个新链表,可以自己写头插,也可以调用ArrayList的方法,不断地往它0位置处加val
import java.util.ArrayList;
public class Solution{
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
ArrayList<Integer> list=new ArrayList<>();
if(listNode==null){
return list;
}
while(listNode!=null){
list.add(0,listNode.val);
listNode=listNode.next;
}
return list;
}
}
JZ4:重建二叉树
题目描述:输入某二叉树的前序遍历和中序遍历的结果,请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6},则重建二叉树并返回。
解题思路:因为是树的结构,一般都是用递归来实现。假设最后一步,就是root的左右子树都已经重建好了,那么我只要考虑将root的左右子树安上去即可。根据前序遍历的性质,第一个元素必然就是root,那么下面的工作就是如何确定root的左右子树的范围。根据中序遍历的性质,root元素前面都是root的左子树,后面都是root的右子树。那么我们只要找到中序遍历中root的位置,就可以确定好左右子树的范围。这里用了Arrays的copyOfRange方法。
import java.util.Arrays;
public class Solution {
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
if(pre.length==0||pre.length!=in.length){//合法性判断
return null;
}
TreeNode node=new TreeNode(pre[0]);
for(int i=0;i<in.length;i++){
if(pre[0]==in[i]){//找根节点
node.left=reConstructBinaryTree(Arrays.copyOfRange(pre,1,i+1),
Arrays.copyOfRange(in,0,i));//三个参数分别是数组和要复制的下标
node.right=reConstructBinaryTree(Arrays.copyOfRange(pre,i+1,pre.length),
Arrays.copyOfRange(in,i+1,in.length));
}
}
return node;
}
}
JZ5:用两个栈实现队列
题目描述:用两个栈来实现一个队列,完成队列的Push和Pop操作。 队列中的元素为int类型。
解题思路:栈是先进后出 ,队列是先进先出
先将元素压入stack1,再反序到stack2中,在·一一弹出,就实现了队列
import java.util.Stack;
public class Solution {
Stack<Integer> stack1 = new Stack<Integer>();
Stack<Integer> stack2 = new Stack<Integer>();
public void push(int node) {
stack1.push(node);
}
public int pop(){
if(stack2.isEmpty()){
while(!stack1.isEmpty()){//判空
stack2.push(stack1.pop());//返回栈顶元素
}
}
return stack2.pop();
}
}
JZ6:旋转数组的最小数字
题目描述:把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转,输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转,该数组的最小值为1。NOTE:给出的所有元素都大于0,若数组大小为0,请返回0。
解题思路:遍历找最小值
import java.util.ArrayList;
public class Solution {
public int minNumberInRotateArray(int [] array) {
if(array.length==0){//数组为0返回0
return 0;
}
if(array.length==1){//为1就这一个元素
return array[0];
}
for(int i=0;i<array.length-1;i++){
if(array[i]>array[i+1]){
return array[i+1];
}
}
return 0;
}
}
JZ7:斐波那契数列
题目描述:大家都知道斐波那契数列,现在要求输入一个整数n,请你输出斐波那契数列的第n项(从0开始,第0项为0,第1项是1)。n<=39
解题思路:第三个数是前两个数之和,写就完了
public class Solution {
public int Fibonacci(int n) {
int a=1,b=1,c=0;
if(n<0){
return 0;//输入不对
}
else if(n==1||n==2){//前两个值为1
return 1;
}
else{
for (int i=3;i<=n;i++){
c=a+b;//第三个数是前两个数之和
b=a;
a=c;
}
return c;
}
}
}
JZ8:跳台阶
题目描述:一只青蛙一次可以跳上1级台阶,也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法(先后次序不同算不同的结果)。
解题思路:当台阶数小于等于2的时候,跳法数就等于台阶数,大于等于3时跳法数就是前两个台阶之和。即f(n) = f(n-1) + f(n-2)假设现在6个台阶,我们可以从第5跳一步到6,这样的话有多少种方案跳到5就有多少种方案跳到6,另外我们也可以从4跳两步跳到6,跳到4有多少种方案的话,就有多少种方案跳到6,所以最后就是f(6) = f(5) + f(4)
public class Solution {
public int JumpFloor(int target) {
if(target<=2){
return target;
}
int first=1,sencond=2;
int method=0;
for(int i=2;i<target;i++){
method=first+sencond;
first=sencond;
sencond=method;
}
return method;
}
}
JZ9:变态跳台阶
题目描述:一只青蛙一次可以跳上1级台阶,也可以跳上2级,它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法
解题思路:第一次跳1个台阶,剩n-1个台阶,这n-1个台阶的跳法为f(n-1),第一次跳2个台阶,剩n-2个台阶,这n-2个台阶的跳法为f(n-2),以此推论,第一次跳n-1个台阶,剩1个台阶,跳法为f(1),第一次跳的是n阶,那么剩下的是0个台阶,跳法是1
规律: f(n) = 1(一次跳n阶)+f(n-1) + f(n-2)+…+f(1) ,写出前三项不难发现f(n)=2^(n-1)
public class Solution {
public int JumpFloorII(int target) {
return (int) Math.pow(2,(target-1));
//pow来实现指数
}
}
JZ10:矩形覆盖
题目描述:我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形,总共有多少种方法?
解题思路:说到底还是个斐波那契,看图
public class Solution {
public int RectCover(int target) {
int two=2,three=3;
if(target<=3){//小于3是就是本身
return target;
}
int result=0;
for(int i=4;i<=target;i++){//从4开始,依旧斐波那契
result=two+three;
two=three;
three=result;
}
return result;
}
}