剑指Offer系列之题1~题5
写在前面：本随笔中包含五道题：题目描述，题目思路以及对应解法。后续该系列的随笔结构与之相同。
1.二维数组的查找
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
找到最大或最小值，然后以此为界，进行查找。
1、暴力解：
public class Solution {
public boolean Find(int target, int [][] array) {
int n=array[0].length;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(array[i][j]==target){
return true;
}
}
}
return false;
}
}
2、从左下开始比较：
public class Solution {
public boolean Find(int target, int [][] array) {
int rowLen=array[0].length;//列数
int colLen=array.length;//行数
//从左下角开始，大于则向右找，小于则向上
int j=0;
for(int i=colLen-1;i>=0;i--){
if(j<rowLen){
if(target>array[i][j]){
j++;
i++;//右移，i不变，该步抵消i--
}else if(target==array[i][j]){
return true;
}
}
}
return false;
}
}
2.替换空格
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
重点是考虑边界问题，全为空格；末尾有空格等情况
1、遍历：
public class Solution {
public String replaceSpace(StringBuffer str) {
String demo=str.toString();
String temp="";
for(int i=0;i<demo.length();i++){
if(demo.charAt(i)==' '){
temp+="%20";
}else{
temp+=demo.charAt(i);
}
}
return temp;
}
}
2、如果要求在原字符串上进行操作。则先计算新字符串的长度进行扩展。然后从后向前依次替换空格。
public class Solution {
public String replaceSpace(StringBuffer str) {
int spaceNum=0;
//计算空格数量，
for(int i=0;i<str.length();i++){
if(str.charAt(i)==' '){
spaceNum++;
}
}
int indexOld=str.length()-1;
str.setLength(str.length()+spaceNum*2);
int indexNew=str.length();//扩容后长度
for(int i=indexNew-1;i>=0 && indexOld>=0;i--){//从末尾开始
if(str.charAt(indexOld)==' '){
str.setCharAt(i,'0');
str.setCharAt(i-1,'2');
str.setCharAt(i-2,'%');
i=i-2;
indexOld--;
}else{
str.setCharAt(i,str.charAt(indexOld));
indexOld--;
}
}
return str.toString();
}
}
3.从尾到头打印链表
输入一个链表，按链表从尾到头的顺序返回一个ArrayList。
暴力解或递归
1、暴力解：
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
ArrayList<Integer> al=new ArrayList<Integer>();
if(listNode==null){//判空
return al;
}
al.add(listNode.val);
while(listNode.next!=null){
listNode=listNode.next;
al.add(listNode.val);
}
ArrayList<Integer> result=new ArrayList<Integer>();
for(int i=al.size()-1;i>=0;--i){
result.add(al.get(i));
}
return result;
}
}
//注：ArrayList的add(int index,E element)方法在添加时会将index处元素后移
2、递归：
import java.util.*;
public class Solution {
ArrayList<Integer> list = new ArrayList();
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
//从最后一个节点开始加入列表
if(listNode!=null){
printListFromTailToHead(listNode.next);
list.add(listNode.val);
}
return list;
}
}
4.链表中环的入口节点
给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。
先判断是否有环（快慢指针，相遇则有环），若有环，则令两个指针，一个从头节点，一个从相遇点分别开始走，再次相遇的点即环的入口节点。
1、双指针：
public ListNode EntryNodeOfLoop(ListNode pHead)
{
if(pHead==null||pHead.next==null){
return null;
}
//判断有无环
ListNode slow=pHead;
ListNode fast=pHead;
boolean flag=false;
while(fast!=null&&fast.next!=null){
fast=fast.next.next;
slow=slow.next;
if(fast==slow){
flag=true;
}
break;
}
//两者相遇时循环结束，此时开始计算环中结点的数目
int count=0;
while(fast.next!=slow){
count++;
fast=fast.next;
}
count++;//环的节点数
ListNode fir=pHead;
ListNode sec=pHead;
for(int i=0;i<count;i++){
fir=fir.next;
}//第一个指针走了count步
//两者开始一起走，相遇的点即入口点。第二个指针与入口点的距离=总结点数-环中的结点数
//因为第一个指针走了环中结点数，所以两者必在入口点相遇。第二个指针到达入口节点时第一个指针走了一圈到达入口结点。
while(fir!=sec){
fir=fir.next;
sec=sec.next;
}
return fir;
}
5.重建二叉树
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
一般情况下树的题目都可以考虑递归方法，找到递归的退出条件（本题即：前序和中序序列只剩下一个节点），在完成的基础上对代码进行优化。
1、递归：
/**
* 递归解决
* 跳出条件是只剩下一个节点，返回赋值给上一个根节点的左或右子树
* @param pre
* @param in
* @return
*/
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
//前序：根左右；中序：左根右
/*if(pre==null || in == null ){
return null;
}*/
TreeNode root=new TreeNode(pre[0]);//根节点
if(pre.length==in.length && pre.length==1){//若前序和中序遍历都只剩下一个节点则返回该节点
return root;
}
int mid=0;
//找到中序遍历中根节点的位置
for(int i=0;i<in.length;i++){
if(in[i]==root.val){
mid=i;
}
}
int left=mid;//左子树的节点个数
int right=in.length-mid-1;//右子树的节点个数
//递归
if(left>0){
int leftpre[]=new int[left];
int leftin[]=new int[left];
for(int i=0;i<left;i++){
leftpre[i]=pre[i+1];
leftin[i]=in[i];
}
root.left=reConstructBinaryTree(leftpre,leftin);//左子树的前序遍历和左子树的中序遍历
}
if(right>0){
int rightpre[]=new int[right];
int rightin[]=new int[right];
for(int i=0;i<right;i++){
rightpre[i]=pre[i+1+left];
rightin[i]=in[i+left+1];
}
root.right=reConstructBinaryTree(rightpre,rightin);//右子树的前序遍历和左子树的中序遍历
}
return root;
}
2、递归精简版：
public TreeNode reConstructBinaryTree1(int [] pre,int [] in) {
TreeNode root=reConstructBinaryTree1(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 reConstructBinaryTree1(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]){
/*startPre+i-startIn是startPre+左子树的节点个数 得到前序序列的末尾位置*/
root.left=reConstructBinaryTree1(pre,startPre+1,startPre+i-startIn,in,startIn,i-1);
root.right=reConstructBinaryTree1(pre,i-startIn+startPre+1,endPre,in,i+1,endIn);
break;
}
return root;
}
如有错误，欢迎指正
