【牛客网】剑指Offer题解
目录
- 1.二维数组中的查找【数组】
- 2.替换空格【字符串】
- 3.从尾到头打印链表【链表】
- 4.重建二叉树【树】
- 5.用两个栈实现队列【栈和队列】
- 5.旋转数组的最小数字【查找和排序】
- 6.斐波那契数列【递归和循环】
- 7.跳台阶【递归和循环】
- 8.变态跳台阶【递归和循环】
- 9.矩形覆盖【递归和循环】
- 10.二进制中1的个数【位运算】
- 11.数值的整数次方【代码的完整性】
- 12.调整数组顺序使奇数位于偶数前面【代码的完整性】
- 13.链表中倒数第k个结点【代码的鲁棒性】
- 14.反转链表【代码的鲁棒性】
- 15.合并两个排序的链表【代码的鲁棒性】
1.二维数组中的查找【数组】
题目描述
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
题解：
从左到右逐渐增大，从上到下逐渐增大。右边的一定比左边的大，下边的一定比上面大。所以我们选择第一行最后一个元素与目标值target比较，若target大于当前元素，说明与target相等的元素在下面，此时i++，访问下面的元素。若target小于当前元素，说明与target相等的元素在左侧，此时j–，访问左侧的元素。若相等，则找到匹配值，返回true；若整个过程并未找到匹配值，则返回false。最多遍历r+c次（即行数+列数）。
代码如下：
class Solution {
public:
bool Find(int target, vector<vector<int> > array) {
int r=array.size();
int c=array[0].size();
int i=0;
int j=c-1;
while(i<r && j>=0){
if(target > array[i][j]){
i++;
}else if(target < array[i][j]){
j--;
}else{
return true;
}
}
return false;
}
};
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2.替换空格【字符串】
题目描述
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
代码如下：
public class Solution {
public String replaceSpace(StringBuffer str) {
StringBuffer newStr = new StringBuffer();
int len=str.length();
for(int i=0;i<len;i++){
if(str.charAt(i)==' '){
newStr.append("%20");
}else{
newStr.append(str.charAt(i));
}
}
return newStr.toString();
}
}
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
3.从尾到头打印链表【链表】
题目描述
输入一个链表，按链表从尾到头的顺序返回一个ArrayList。
代码如下：
/**
* public class ListNode {
* int val;
* ListNode next = null;
*
* ListNode(int val) {
* this.val = val;
* }
* }
*
*/
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
Stack<Integer> sta = new Stack<>();
while(listNode!=null){
sta.push(listNode.val );
listNode = listNode.next ;
}
ArrayList<Integer > res = new ArrayList<>();
while(!sta.isEmpty()){
res.add(sta.pop());
}
return res;
}
}
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
4.重建二叉树【树】
题目描述
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
知识补充：
先序遍历：
若二叉树为空，则什么也不做；否则，
1）访问根节点；
2）先序遍历左子树；
3）先序遍历右子树。
中序遍历：
若二叉树为空，则什么也不做；否则，
1）中序遍历左子树；
2）访问根节点；
3）中序遍历右子树。
后序遍历：
若二叉树为空，则什么也不做；否则，
1）后序遍历左子树；
2）后序遍历右子树；
3）访问根节点。
由二叉树的先序序列和中序序列可以唯一确定一颗二叉树。
由二叉树的后序序列和中序序列也可以唯一确定一颗二叉树。
在先序遍历序列中，第一个结点一定是二叉树的根节点；
在后序遍历序列中，最后一个结点也一定是二叉树的根节点；
而在中序遍历中，根节点必然将中序序列分割成两个子序列，前一个子序列是根节点的左子树的中序序列，后一个子序列是根节点的右子树的中序序列。
根据这两个子序列，在先序序列(或后序序列)中找到对应的左子序列和右子序列。在先序序列中，左子序列的第一个结点是左子树的根节点，右子序列的第一个结点是右子序列的根节点。后序序列同理。如此递归地进行下去，便能唯一地确定这颗二叉树。
代码如下：
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
import java.util.Arrays;
public class Solution {
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
if (pre.length == 0 || in.length == 0) {
return null;
}
//在先序序列的第一个元素即为二叉树的根
TreeNode theRoot = new TreeNode(pre[0]);
// 在中序序列中找到前序的根
for (int i = 0; i < in.length; i++) {
if (in[i] == pre[0]) {
// 左子树， copyOfRange 数组复制函数，范围左闭右开
theRoot.left = reConstructBinaryTree(Arrays.copyOfRange(pre, 1, i + 1), Arrays.copyOfRange(in, 0, i));
// 右子树， copyOfRange 数组复制函数，范围左闭右开
theRoot.right = reConstructBinaryTree(Arrays.copyOfRange(pre, i + 1, pre.length), Arrays.copyOfRange(in, i + 1, in.length));
break;
}
}
return theRoot;
}
}
补充：
copyOfRange用法链接：点此查看
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
5.用两个栈实现队列【栈和队列】
题目描述
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
题解：
首先，明确栈与队列的区别：
栈：先入后出；
队列：先入先出；
然后，
所有进入的都存到stack1中，在需要弹出时，把stack1中的元素都存到stack2中，此时在从stack2中弹出元素即可实现先入先出。这是只有一次持续加入元素的情况；而现实是，可能会在弹出元素后再要求加入元素，此时再弹出时，就要求先判断stack2中是否还有元素，若有就先把stack2中的元素弹出再进行下一步操作，当stack2中没有元素时，就要把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.size()<=0){
while (stack1.size()!=0){
stack2.push(stack1.pop());
}
}
return stack2.pop();
}
}
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
5.旋转数组的最小数字【查找和排序】
题目描述
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
6.斐波那契数列【递归和循环】
题目描述
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
n<=39
题解：
常规斐波那契数列：F(n)=F(n-1)+F(n-2) 其中F(1)=1、F(2)=1；
此处从0开始，即F(0)=0;
递归太耗时，用数组存每次的结果又太耗内存
用sum表示第 i 项结果，它是第 i-1 项和 i-2 项的和；
而第 i+1 项的值，则是需要上一项（即第 i 项）的值sum，同时需要第 i-1 项的值；
这就可以找到方法了：
当前值会成为下一项的前一项，而当前值的前一项会成为下一项的前两项；
设sum为当前值，num为前二项的值，则：
sum(当前值) = sum(即：上一轮的值，也就是当前值的前一项) + num(即，上一轮的前一项，也就是当前值的前二项);
num(当前值的前一项，即像议论的前二项)= sum (当前值)- num (当前值的前二项项);//更新num
代码如下：
public class Solution {
public int Fibonacci(int n) {
if(n==0)
return 0;
else if(n==1)
return 1;
int sum = 1;
int num = 0;
for(int i=2;i<=n;i++){
sum = sum + num;
num = sum - num;
}
return sum;
}
}
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
7.跳台阶【递归和循环】
题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
题解：
找规律：
到第1级，只有1种跳法，即直接一步跨上去
到第2级，只有2种跳法，即先1步到第1级再1步到第2级，这是1种跳法；第2种是直接跨2步到第2级；
…
接着你便会发现：
当前你处于第 i 级，你只能从第 i-1 级跨1步到第 i 级，或从第 i-2 级跨2步到第 i 级；
即到第 i 级的跳法 ：F(i)=F(i-1)+F(i-2)；
斐波那契数列，其写法参考上一题。
代码如下：
public class Solution {
public int JumpFloor(int target) {
if(target==1)
return 1;
else if(target==2)
return 2;
int sum = 2;
int num = 1;
for(int i=3;i<=target;i++){
sum = sum + num;
num = sum - num;
}
return sum;
}
}
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
8.变态跳台阶【递归和循环】
题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
题解：
我们只需要考虑一个问题：当前台阶能从哪个台阶跳过来？
若处于第 i 级，则 能从第0级，第1级，第2级…第 i-1 级跳过来；
即： F(i) = F(0) + F(1) +F(2)+…+F(i-1);
其中F(0)=1，即从第0级跨 i 步到第 i 级；
可知：
F(1)=1;
F(2)=1+1=2;
F(3)=1+1+2=4;
F(4)=1+1+2+4=8;
可知F(i)=2^(i-1);
代码如下：
public class Solution {
public int JumpFloorII(int target) {
return (int)Math.pow(2 , target-1);
}
}
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9.矩形覆盖【递归和循环】
题目描述
我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
比如n=3时，2*3的矩形块有3种覆盖方法：
题解：
找规律，递推。
代码如下：
public class Solution {
public int RectCover(int target) {
if(target==0)
return 0;
else if(target ==1)
return 1;
else if(target==2)
return 2;
int sum=2;
int num=1;
for(int i=3;i<=target;i++){
sum=sum+num;
num=sum-num;
}
return sum;
}
}
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10.二进制中1的个数【位运算】
题目描述
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
题解：
一个整数只要不为0，其二进制中一定有1；
若一个数的二进制为1100，其减1为1011；
二者进行按位与运算，即1100&1011=1000；
可知，再减1，然后按位与，1000&0111=0；
按这个思路，就可找到该数二进制中1的个数。
代码如下：
public class Solution {
public int NumberOf1(int n) {
int num=0;
while(n!=0){
num++;
n=n &(n-1);
}
return num;
}
}
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11.数值的整数次方【代码的完整性】
题目描述
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
保证base和exponent不同时为0
代码如下：
public class Solution {
public double Power(double base, int exponent) {
return Math.pow(base,exponent);
}
}
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
12.调整数组顺序使奇数位于偶数前面【代码的完整性】
题目描述
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
题解：
内存占用略多，复杂度还行
代码如下：
public class Solution {
public void reOrderArray(int [] array) {
int len = array.length;
int[] a=new int[len];
int[] b=new int[len];
int ak=0;
int bk=0;
for(int i=0;i<len;i++){
if(array[i]%2==1)
a[ak++]=array[i];
else
b[bk++]=array[i];
}
for(int i=0;i<ak;i++){
array[i]=a[i];
}
for(int i=0;i<bk;i++){
array[i+ak]=b[i];
}
}
}
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
13.链表中倒数第k个结点【代码的鲁棒性】
题目描述
输入一个链表，输出该链表中倒数第k个结点。
题解：
快慢指针，设立两个指针fast和head；
起始时都指向头节点，
fast先遍历k次，若不到k个就发现fast==null，说明链表内的结点不到k个，直接null；
然后fast和head同时向后遍历，直到fast指向null，说明此时fast已访问到链表的末尾；而又因为fast比head多遍历k次，而后二者是同时遍历的，所以当fast指向链表尾部时，head刚好指向链表的中倒数第k个结点。
代码如下：
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode FindKthToTail(ListNode head,int k) {
if(head==null || k <= 0)
return null;
ListNode fast=head;
ListNode slow=head;
for(int i=0;i<k;i++){
if(fast==null )
return null;
fast=fast.next;
}
while(fast!=null){
fast=fast.next ;
slow=slow.next;
}
return slow;
}
}
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
14.反转链表【代码的鲁棒性】
题目描述
输入一个链表，反转链表后，输出新链表的表头。
题解：
链表内的各结点是通过指针顺次相连的，题目要求反转链表，我们只需要改变各结点之间原有的链接关系即可，即反向链接即可。
这时我们引入两个辅助用的指针pre(指向前一个结点)和next(指向后一个结点)。
head指向当前结点，head.next指向下一个结点，这样才构成了整个链表；而我们要做的就是让head.next指向前一个结点。
知道了思路，接下来就是要利用pre和next辅助转变：
next=head.next; //解放出head.next以便下一步让其指向前一个结点，同时next可以便于链表向后遍历；
head.next = pre; //指向前一个结点，完成了一个结点的反向链接，接下来的操作就是要保证后序的结点也可以这么方便的操作。
pre=head; //为下一轮操作做准备，
head=next; //为下一轮操作做准备，
代码如下：
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode ReverseList(ListNode head) {
ListNode pre=null;
ListNode next=null;
while(head!=null){
next=head.next;
head.next = pre;
pre=head;
head=next;
}
return pre;
}
}
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
15.合并两个排序的链表【代码的鲁棒性】
题目描述
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
题解：
对于链表list1与list2，先比较各自第一个结点的大小，小的作为新的链表第一个结点，这里假设list1的第一个结点最小。然后，比较list1的第二个结点与list2的第一个结点的大小，把小的与上一步的结点相连；以此类推。
代码如下：
《递归实现》
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode Merge(ListNode list1,ListNode list2) {
if(list1==null)
return list2;
if(list2==null)
return list1;
ListNode resList;
if(list1.val<list2.val){
resList=list1;
resList.next=Merge(list1.next,list2);
}else{
resList=list2;
resList.next=Merge(list1,list2.next);
}
return resList;
}
}