剑指Offer刷题整理(1-10)，Java版
题目来自牛客网
文章目录
- 1.二维数组查找
- 题目描述
- 思路：
- 算法实现
- 2.替换空格
- 题目描述
- 思路：
- 算法实现
- 3.从尾到头打印链表
- 题目描述
- 思路：
- 算法实现
- 4.重建二叉树
- 题目描述
- 思路：
- 算法实现
- 5.用两个栈实现一个队列
- 题目描述
- 思路：
- 算法实现
- 6.旋转数组的最小数字
- 题目描述
- 思路：
- 算法实现
- 7.斐波那契数列
- 题目描述
- 思路：
- 算法实现
- 8.跳台阶
- 题目描述
- 思路：
- 算法实现
- 9.变态跳台阶
- 题目描述
- 思路：
- 算法实现
- 10.矩形覆盖
- 题目描述
- 思路：
- 算法实现
1.二维数组查找
题目描述
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
思路：
从右上角开始和从左下角开始本质上是一样的，都是忽略掉其中的一行或者一列，以右上角为例，记右上角元素为a[0][j],若要查找的值比a[0][j]小则j-1, 反之则i+1。
算法实现
class Solution1{
public boolean Find(int target, int [][] array) {
boolean flag=false;//设置flag记录是否找到
for(int i=0,j=array[0].length-1;j>=0&&i2.替换空格
题目描述
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
思路：
先统计空格数量，然后将字符串扩容为len+spcacenum*2然后自后向前遍历，从尾部向前插入，遇到空格插入三个字符
算法实现
class Solution2{
public String replaceSpace(StringBuffer str) {
int len = str.length();
int spacenum=0;
for(int i=0;i=0;--i){//自后向前插入
if(str.charAt(i)!=' ') {
str.setCharAt(index--,str.charAt(i) );
}else {
str.setCharAt(index--,'0' );
str.setCharAt(index--,'2' );
str.setCharAt(index--,'%' );
}
}
return str.toString();
}
}
3.从尾到头打印链表
题目描述
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
思路：
遇到逆序输出，考虑两种做法，一是用栈，二是递归。
算法实现
方法一：使用栈
class Solution3_1 {//栈版本
public ArrayList printListFromTailToHead(ListNode listNode) {
ArrayList list =new ArrayList<>();
Stack stack= new Stack<>();
while(listNode!=null){
stack.push(listNode.val);
listNode=listNode.next;
}
while(!stack.isEmpty()){
list.add(stack.pop());
}
return list;
}
}
方法二：递归
class Solution3_2{//递归版本
ArrayList list =new ArrayList<>();
public ArrayList printListFromTailToHead(ListNode listNode) {
if(listNode!=null) {
this.printListFromTailToHead(listNode.next);
list.add(listNode.val);
}
return list;
}
}
4.重建二叉树
题目描述
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
思路：
二叉树遍历序列的特性：前序遍历，第一个数总是树的根节点的值；中序遍历根节点的值在中间，左子树的节点位于根节点的左边，右子树的节点位于根节点的右边；后序遍历的序列和前序刚好相反，最后一个数是根节点。利用这些特点可以相继确立根节点和左右子树。
算法实现
方法一：递归
class Solution4_1 {
public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
TreeNode root = reBuildBinaryTree(pre, 0, pre.length-1, in, 0, in.length-1);
return root;
}
private TreeNode reBuildBinaryTree(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(pre[startPre]==in[i]) {
root.left=reBuildBinaryTree(pre, startPre+1, i+startIn-startPre, in, startIn, i-1);
root.right=reBuildBinaryTree(pre, i+startIn-startPre+1, endPre, in, i+1, endIn);//这里要注意的是需要记录之前传入的根节点的位置
break;
}
}
return root;
}
}
方法二：HashMap
class Solution4_2 {//HasMap解法
public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
Map map = new HashMap<>();
for (int i = 0; i < in.length; i++) {
map.put(in[i], i);
}
return reConstructBinaryTree(pre, 0, pre.length - 1, in, 0, in.length - 1, map);
}
private TreeNode reConstructBinaryTree(int[] p, int pi, int pj, int[] n, int ni, int nj, Map map) {
if (pi > pj || ni > nj) {
return null;
}
TreeNode head = new TreeNode(p[pi]);
int index = map.get(p[pi]);
head.left = reConstructBinaryTree(p, pi + 1, pi + index - ni, n, ni, index - 1, map);
head.right = reConstructBinaryTree(p, pi + index - ni + 1, pj, n, index + 1, nj, map);
return head;
}
}
5.用两个栈实现一个队列
题目描述
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
思路：
1.队列是先进先出，而栈是先进后出，两个栈可以通过互相复制数据，实现序列反转，来达到先进先出的目的
2.优化：Stack1只存放入栈数据就可以，因为Stack2中的数据始终是在队列的前端
入队：Stack1入栈
出队：若Stack2不为空，Stack2出栈，若为空，将Stack1压入Stack2，出栈
算法实现
class Solution5 {
Stack stack1 = new Stack();
Stack stack2 = new Stack();
public void push(int node) {
stack1.push(node);
}
public int pop() {
if(stack2.isEmpty()) {
while(!stack1.isEmpty()) {
stack2.push(stack1.pop());
}
}
return stack2.pop();
}
}
6.旋转数组的最小数字
题目描述
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
思路：
有序数组就应该想到二分查找，时间复杂度为O(log(n)),注意点是当两端和中间的数字相等的时候，无法确定中间数字的位置是在前面的子串还是后边的子串，此时应该顺序查找,存在一个小问题是当end-start=1时，mid向下取整为start，这里应该选择的是end
算法实现
class Solution6 {
public int minNumberInRotateArray(int [] array) {
if(array.length==0) {
return 0;
}
int start = 0;
int end = array.length-1;
int mid = (start+end)/2;
while(array[start]>=array[end]&&start=array[start]) {
start=mid+1;
mid=(start+end)/2;
}else if(array[start]>=array[mid]) {
end=mid;
mid=(start+end)/2;
}
}
return array[mid];
}
}
7.斐波那契数列
题目描述
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
n<=39
思路：
两种做法一是递归二是循环，递归时间复杂度是O(2^n),循环时间复杂度是O(n)
算法实现
方法一：递归版
class Solution7_1{//递归版 t：1532ms m：9256k
public int Fibonacci(int n) {
if(n==0) {
return 0;
}
if(n==1) {
return 1;
}
return Fibonacci(n-1)+Fibonacci(n-2);
}
}
方法二：循环版
class Solution7_2{//循环版 t:13ms m:9196k
public int Fibonacci(int n) {
int a = 0;
int b = 1;
int c = 0;
if(n==0) {
return 0;
}
if(n==1) {
return 1;
}
for(int i=2;i<=n;i++) {
c= a + b;
a= b;
b= c;
}
return c;
}
}
8.跳台阶
题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
思路：
跳N阶台阶的时候从后向前看在最后一步有两种选择，一是跳1阶，二是跳2阶，跳1阶的时候前面需要跳N-1阶，跳2阶的时候前面需要跳N-2阶，实际上就是一个Fibonacci数列了，做法同Q7
算法实现
同第7题 斐波那契数列
9.变态跳台阶
题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
思路：
变态跳台阶，一次可以跳1~n步，利用Q8的思路，倒推：
已知前几项是固定的，f1=1,f2=2,f3=f1+f2+1=4,f4=f3+f2+f1+1=8,f5=f4+f3+f2+f1+1=16,…
归纳可得fn=2^(n-1)
算法实现
class Solution9{
public int JumpFloorII(int n) {
return (int)(Math.pow(2,n-1));
}
}
10.矩形覆盖
题目描述
我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
思路：
Fibonacci数列，和前面的题目一样倒推
算法实现
class Solution10{
public int RectCover(int n) {
int a = 1;
int b = 2;
int c = 0;
if(n==0) {
return 0;
}
if(n==1) {
return 1;
}
if(n==2) {
return 2;
}
for(int i=3;i<=n;i++) {
c= a + b;
a= b;
b= c;
}
return c;
}
}