剑指Offer刷题整理(51-66)，Java版
题目来自牛客网
文章目录
- 51.构建乘积数组
- 题目描述
- 思路：
- 算法实现
- 52.正则表达式匹配
- 题目描述
- 思路：
- 算法实现
- 53.表示数值的字符串
- 题目描述
- 思路：
- 算法实现
- 54.字符流中第一个不重复的字符
- 题目描述
- 思路：
- 算法实现
- 55.链表中环的入口节点
- 题目描述
- 思路：
- 算法实现
- 56.删除链表中重复的节点
- 题目描述
- 思路：
- 算法实现
- 57.二叉树的下一个节点
- 题目描述
- 思路：
- 算法实现
- 58.对称的二叉树
- 题目描述
- 思路：
- 算法实现
- 59.按之字型顺序打印二叉树
- 题目描述
- 思路：
- 算法实现
- 60.把二叉树打印成多行
- 题目描述
- 思路：
- 算法实现
- 61.序列化二叉树
- 题目描述
- 思路：
- 算法实现
- 62.二叉搜索树的第k个节点
- 题目描述
- 思路：
- 算法实现
- 63.数据流中的中位数
- 题目描述
- 思路：
- 算法实现
- 64.滑动窗口的最大值
- 题目描述
- 思路：
- 算法实现
- 65.矩阵中的路径
- 题目描述
- 思路：
- 算法实现
- 66.机器人的运动范围
- 题目描述
- 思路：
- 算法实现
51.构建乘积数组
题目描述
给定一个数组A[0,1,…,n-1],请构建一个数组B[0,1,…,n-1],其中B中的元素B[i]=A[0]A[1]…*A[i-1]A[i+1]…*A[n-1]。不能使用除法。
思路：
B[i]的值可以看作下图的矩阵中每行的乘积。
下三角用连乘可以很容求得，上三角，从下向上也是连乘。
因此我们的思路就很清晰了，先算下三角中的连乘，即我们先算出B[i]中的一部分，然后倒过来按上三角中的分布规律，把另一部分也乘进去。。
算法实现
class Solution51 {
public int[] multiply(int[] A) {
int length = A.length;
int[] B = new int[length];
if(length != 0 ){
B[0] = 1;
//计算下三角连乘
for(int i = 1; i < length; i++){
B[i] = B[i-1] * A[i-1];
}
int temp = 1;
//计算上三角
for(int j = length-2; j >= 0; j--){
temp *= A[j+1];
B[j] *= temp;
}
}
return B;
}
}
52.正则表达式匹配
题目描述
请实现一个函数用来匹配包括’.‘和’‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但是与"aa.a"和"ab*a"均不匹配
思路：
要分为几种情况：（状态机）
（1）当第二个字符不为‘*’时：匹配就是将字符串和模式的指针都下移一个，不匹配就直接返回false
（2）当第二个字符为'*'时：
匹配：
a.字符串下移一个，模式不动
b.字符串下移一个，模式下移两个
c.字符串不动，模式下移两个
不匹配：字符串下移不动，模式下移两个
算法实现
class Solution52 {
public boolean match(char[] str, char[] pattern)
{
if(str==null||pattern==null) {
return false;
}
return matchCore(str,0,pattern,0);
}
private boolean matchCore(char[] str, int i, char[] pattern, int j) {
if(i==str.length&&j==pattern.length) {
return true;
}
if(i!=str.length&&j==pattern.length) {
return false;
}
if(j+153.表示数值的字符串
题目描述
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100",“5e2”,"-123",“3.1416"和”-1E-16"都表示数值。 但是"12e",“1a3.14”,“1.2.3”,"±5"和"12e+4.3"都不是。
思路：
- 输入为数的话只能满足以下形式[+/-]x[.y]{(e/E)[+/-]z}，其中x，y，z表示一个整数，
- []和{}内的内容可以不出现。于是可以将数分为三个部分，1.整数部分 2.小数部分 3.科学计数法部分
- 然后逐一判断各个位置。
步骤： - 1.判断整数部分的符号位和数字
- 2.判断是否有小数点
若有：
I.判断是否有多个小数点，若有多个返回false
II.判断是否有e/E，同3
若没有：该数是小数，返回true - 3.判断是否有e/E
若有，则判断该数为科学计数法
若没有，则该数为整数或者小数
4.科学计数法的判断
I.检查e后边是否存在符号位，若存在将index+1
II.index之后是否存在其他字符，若有返回false，若没有返回true
算法实现
class Solution53 {
public boolean isNumeric(char[] str) {
boolean isNumber = true;
if (str == null || str.length == 0) {
return false;
}
int index = 0;
if (str[index] == '+' || str[index] == '-') {// 先判断符号位
index++;
}
for (int i = index; i < str.length; i++) {// 然后判断数字
if (str[i] >= '0' && str[i] <= '9') {
index++;
} else if (str[i] == '.') {
return IsDecimal(str, index + 1);//判断小数
} else if ((str[i] == 'e' || str[i] == 'E') && index < str.length - 1) {
return IsExponential(str, index + 1);//判断是否科学计数法
} else {
return false;//出现其他字符直接返回false
}
}
return isNumber;//如果循环走完，说明输入为一个整数，返回true
}
private boolean IsExponential(char[] str, int index) {
if (str[index] == '+' || str[index] == '-') {// 先判断符号位
index++;
}
for (int i = index; i < str.length; i++) {// 然后判断数字
if (str[i] >= '0' && str[i] <= '9') {
index++;
} else {
return false;//e后边的数字为整数，如果出现其他字符直接返回false
}
}
return true;//如果循环走完说明输入为科学计数法，返回true
}
private boolean IsDecimal(char[] str, int index) {
for (int i = index; i < str.length; i++) {
if (str[i] >= '0' && str[i] <= '9') {
index++;
}
if (str[i] == '.') {//如果有多余的小数点直接false
return false;
}
if (str[i] == 'e' || str[i] == 'E') {
return IsExponential(str, index + 1);//判断是否科学计数法
}
}
return true;//如果循环走完说明输入为一个小数，返回true
}
}
54.字符流中第一个不重复的字符
题目描述
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。
输出描述:
如果当前字符流没有存在出现一次的字符，返回#字符。
思路：
HashMap
算法实现
class Solution54 {
HashMap map = new LinkedHashMap();
public void Insert(char ch) {
if (!map.containsKey(ch)) {
map.put(ch, 1);
} else {
map.put(ch, map.get(ch) + 1);
}
}
public char FirstAppearingOnce() {
for (char ch : map.keySet()) {
int time = map.get(ch);
// 目前第一个只出现一次的字符，返回
if (time == 1)
return ch;
}
return '#';
}
}
55.链表中环的入口节点
题目描述
给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。
思路：
- 方法一：使用Hashmap，遍历过得节点加入map，纪录次数，若有一个节点遍历超过1次，则为入口
- 方法二：首先确定环的长度为len，然后双指针，一个指针先走len，另一个指针再走，当两个指针相遇的时候，
便是环的入口。
算法实现
方法一：
class Solution55_1 {
public ListNode EntryNodeOfLoop(ListNode pHead)
{
Map map = new LinkedHashMap();
ListNode p = pHead;
while(p!=null) {
if(!map.containsKey(p)) {
map.put(p, 1);
}else {
return p;
}
p=p.next;
}
return null;
}
}
方法二：
class Solution55_2 {
public ListNode EntryNodeOfLoop(ListNode pHead)
{
Map map = new LinkedHashMap();
ListNode p = pHead;
while(p!=null) {
if(!map.containsKey(p)) {
map.put(p, 1);
}else {
return p;
}
p=p.next;
}
return null;
}
}
56.删除链表中重复的节点
题目描述
在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
思路：
注意断链即可
算法实现
class Solution56 {
public ListNode deleteDuplication(ListNode pHead)
{
if(pHead==null) {
return null;
}
ListNode pre = new ListNode(0);
ListNode p = pHead;
ListNode head=pre;
pre.next=p;
while(p!=null) {
if(p.next!=null&&p.next.next!=null&&p.val==p.next.val&&p.val==p.next.next.val) {//aaa的情形
p.next=p.next.next;
}else if((p.next!=null&&p.next.next!=null&&p.val==p.next.val&&p.val!=p.next.next.val)||(p.next!=null&&p.val==p.next.val)) {///aa的情形
pre.next=p.next.next;
p=pre.next;
}
else{//ab的情形
pre=p;
p=p.next;
}
}
return head.next;
}
}
57.二叉树的下一个节点
题目描述
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
思路：
考虑三种情况：
- I.当前节点为空，返回null
- II.当前节点的右孩子不存在:
1:当前节点的父亲节点存在，返回父亲节点
2：当前节点的父亲节点不存在，返回null - III.当前节点的右孩子存在:
以有孩子节点为起点，向左遍历，访问的第一个节点返回
算法实现
class Solution57 {
public TreeLinkNode GetNext(TreeLinkNode pNode) {
if (pNode == null) {
return null;
}
if (pNode.right != null) {
TreeLinkNode p = pNode.right;
while (p != null && p.left != null) {
p = p.left;
}
return p;
}
if (pNode.next != null) {
if(pNode==pNode.next.left) {
return pNode.next;
}
if(pNode==pNode.next.right&&pNode.next==pNode.next.next.left) {
return pNode.next.next;
}
return null;
}
return null;
}
}
58.对称的二叉树
题目描述
请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
思路：
遍历即可
算法实现
class Solution58 {
boolean isSymmetrical(TreeNode pRoot)
{
if(pRoot==null) {
return true;
}
return isSymmetrical( pRoot.left,pRoot.right);
}
private boolean isSymmetrical(TreeNode left, TreeNode right) {
if(left==null&&right==null) return true;
if(left==null||right==null) return false;
return left.val==right.val && isSymmetrical(left.left,right.right)&&isSymmetrical(left.right,right.left);
}
}
59.按之字型顺序打印二叉树
题目描述
请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
思路：
利用两个栈，先将头结点入一个栈，然后出栈时将子节点加入另一个栈，重复操作，直至有一个栈为空
算法实现
class Solution59 {
public ArrayList > Print(TreeNode pRoot) {
ArrayList> list = new ArrayList >();
if(pRoot==null) return list;
Stack stack1 = new Stack();
Stack stack2 = new Stack();
TreeNode p =null;
stack1.push(pRoot);
while(!stack1.isEmpty()||!stack2.isEmpty()) {
ArrayList list1 = new ArrayList();
while(!stack1.empty()) {
p=stack1.pop();
list1.add(p.val);
if(p.left!=null) {
stack2.push(p.left);
}
if(p.right!=null) {
stack2.push(p.right);
}
}
if(list1.size()!=0) {
list.add(list1);
}
ArrayList list2 = new ArrayList();
while(!stack2.empty()) {
p=stack2.pop();
list2.add(p.val);
if(p.right!=null) {
stack1.push(p.right);
}
if(p.left!=null) {
stack1.push(p.left);
}
}
if(list2.size()!=0) {
list.add(list2);
}
}
return list;
}
}
60.把二叉树打印成多行
题目描述
从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
思路：
使用1个队列进行层次遍历，遍历的过程中，设置三个变量，nowlayer,nextlayer,i分别表示当前层的节点数，下一层的节点数和当前节点编号，遍历的时候若存在孩子节点便将nextlayer+1，遍历的完一层的时候令nowlayer=nextlayer,i重置为0, 并且为将当前list加入到list集合中，最后返回list。
算法实现
class Solution60 {
public ArrayList> Print(TreeNode pRoot) {
ArrayList> list = new ArrayList>();
if (pRoot == null)
return list;
Queue queue = new LinkedList();
TreeNode p = null;
queue.offer(pRoot);//根节点入队
int nowlayer = 1;//当前层节点数1
int nextlayer = 0;//下一层节点数0
int i = 0;//计数器
while (!queue.isEmpty()) {//遍历开始
ArrayList list1 = new ArrayList();
while (i < nowlayer) {//遍历一层的循环
TreeNode tr = queue.poll();
list1.add(tr.val);
if (tr.left != null) {
queue.offer(tr.left);
nextlayer++;
}
if (tr.right != null) {
queue.offer(tr.right);
nextlayer++;
}
i++;
}
i = 0;//重新设置参数
nowlayer = nextlayer;
nextlayer = 0;
list.add(list1);
}
return list;
}
}
61.序列化二叉树
题目描述
请实现两个函数，分别用来序列化和反序列化二叉树
思路：
- 对于序列化：使用前序遍历，递归的将二叉树的值转化为字符，并且在每次二叉树的结点
不为空时，在转化val所得的字符之后添加一个’ ， '作为分割。对于空节点则以 ‘#’ 代替。 - 对于反序列化：按照前序顺序，递归的使用字符串中的字符创建一个二叉树(特别注意：
在递归时，递归函数的参数一定要是char ** ，这样才能保证每次递归后指向字符串的指针会
随着递归的进行而移动！！！)
算法实现
class Solution61 {
int index =-1;
String Serialize(TreeNode root) {
StringBuilder sb = new StringBuilder();
if(root==null) {
sb.append("#,");
return sb.toString();
}
sb.append(root.val+",");
sb.append(Serialize(root.left));
sb.append(Serialize(root.right));
return sb.toString();
}
TreeNode Deserialize(String str) {
index++;
String[] s = str.split(",");
TreeNode node=null;
if(!s[index].equals("#")) {
node = new TreeNode(Integer.valueOf(s[index]));
node.left=Deserialize(str);
node.right=Deserialize(str);
}
return node;
}
}
62.二叉搜索树的第k个节点
题目描述
给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8） 中，按结点数值大小顺序第三小结点的值为4。
思路：
中序遍历计数即可
算法实现
class Solution62 {
int index = 0; //计数器
TreeNode KthNode(TreeNode root, int k)
{
if(root != null){ //中序遍历寻找第k个
TreeNode node = KthNode(root.left,k);
if(node != null)
return node;
index ++;
if(index == k)
return root;
node = KthNode(root.right,k);
if(node != null)
return node;
}
return null;
}
}
63.数据流中的中位数
题目描述
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。
思路：
为了保证插入新数据和取中位数的时间效率都高效，这里使用大顶堆+小顶堆的容器，并且满足：
1、两个堆中的数据数目差不能超过1，这样可以使中位数只会出现在两个堆的交接处；
2、大顶堆的所有数据都小于小顶堆，这样就满足了排序要求。
算法实现
class Solution63 {
int count;
PriorityQueue minHeap = new PriorityQueue();
PriorityQueue maxHeap = new PriorityQueue(11, new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
//PriorityQueue默认是小顶堆，实现大顶堆，需要反转默认排序器
return o2.compareTo(o1);
}
});
public void Insert(Integer num) {
count++;
if ((count & 1) == 0) { // 判断偶数的高效写法
if (!maxHeap.isEmpty() && num < maxHeap.peek()) {
maxHeap.offer(num);
num = maxHeap.poll();
}
minHeap.offer(num);
} else {
if (!minHeap.isEmpty() && num > minHeap.peek()) {
minHeap.offer(num);
num = minHeap.poll();
}
maxHeap.offer(num);
}
}
public Double GetMedian() {
if(count==0)
throw new RuntimeException("no available number!");
double result;
//总数为奇数时，大顶堆堆顶就是中位数
if((count&1)==1)
result=maxHeap.peek();
else
result=(minHeap.peek()+maxHeap.peek())/2.0;
return result;
}
}
64.滑动窗口的最大值
题目描述
给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。
思路：
队列来模拟滑动窗口
算法实现
class Solution64 {
public ArrayList maxInWindows(int [] num, int size)
{
ArrayList list = new ArrayList();
if(num.length==0 || num==null||size==0||size>num.length) {
return list;
}
Queue q=new LinkedList();
int i = 0;
for(;i < size;i++) {//将前size个入队
q.offer(num[i]);
}
while(i q) {//获取当前队列的最大值
int max=0;
for(int i = 0;imax) {
max=s;
}
q.offer(s);
}
return max;
}
}
65.矩阵中的路径
题目描述
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。 例如 a b c e s f c s a d e e 这样的3 X 4 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。
思路：
- 0.根据给定数组，初始化一个标志位数组，初始化为false，表示未走过，true表示已经走过，不能走第二次
- 1.根据行数和列数，遍历数组，先找到一个与str字符串的第一个元素相匹配的矩阵元素，进入judge
- 2.根据i和j先确定一维数组的位置，因为给定的matrix是一个一维数组
- 3.确定递归终止条件：越界，当前找到的矩阵值不等于数组对应位置的值，已经走过的，这三类情况，都直接false，说明这条路不通
- 4.若k，就是待判定的字符串str的索引已经判断到了最后一位，此时说明是匹配成功的
- 5.下面就是本题的精髓，递归不断地寻找周围四个格子是否符合条件，只要有一个格子符合条件，就继续再找这个符合条件的格子的四周 是否存在符合条件的格子，直到k到达末尾或者不满足递归条件就停止。
- 6.走到这一步，说明本次是不成功的，我们要还原一下标志位数组index处的标志位，进入下一轮的判断。
算法实现
class Solution65 {
public boolean hasPath(char[] matrix, int rows, int cols, char[] str)
{
boolean[] flag = new boolean[matrix.length];
for(int i = 0;i=rows || j>=cols||matrix[index]!=str[k]||flag[index]==true) {
return false;
}
if(k==str.length-1) {
return true;
}
flag[index]=true;
if(judge(matrix,i-1,j,rows,cols,flag,str,k+1)||
judge(matrix,i+1,j,rows,cols,flag,str,k+1)||
judge(matrix,i,j-1,rows,cols,flag,str,k+1)||
judge(matrix,i,j+1,rows,cols,flag,str,k+1)) {
return true;
}
flag[index]=false;
return false;
}
}
66.机器人的运动范围
题目描述
地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？
思路：
1.从(0,0)开始走，每成功走一步标记当前位置为true,然后从当前位置往四个方向探索，
返回1 + 4 个方向的探索值之和。
2.探索时，判断当前节点是否可达的标准为：
1）当前节点在矩阵内；
2）当前节点未被访问过；
3）当前节点满足limit限制。
算法实现
class Solution66 {
public int movingCount(int t, int rows, int cols)
{
boolean[] flag = new boolean[rows*cols];
return judge(t,0,0,rows,cols,flag);
}
private int judge(int t, int i, int j, int rows, int cols, boolean[] flag) {
int index = i*cols+j;
if(i<0 || j<0 || i>=rows || j>=cols||calc(i)+calc(j)>t||flag[index]==true) {
return 0;
}
flag[index]=true;
return judge(t,i-1,j,rows,cols,flag)+judge(t,i+1,j,rows,cols,flag)
+judge(t,i,j-1,rows,cols,flag)+judge(t,i,j+1,rows,cols,flag)+1;
}
private int calc(int i) {
int count=0;
while(i%10!=0) {
count+=i%10;
i=i/10;
}
return count;
}
}