《剑指offer》Java
文章目录
- 03. 二维数组中的查找
- 04. 替换空格
- 05. 从尾到头打印链表
- 06. 重建二叉树
- 07. 用两个栈实现队列
- 08. 旋转数组的最小数字
- 09. 斐波那契数列
- 8. 跳台阶
- 9. 变态跳台阶
- 10. 矩形覆盖
- 10. 二进制中1的个数
- 11.数值的整数次方
- 14. 调整数组顺序使奇数位于偶数前面
- 15. 链表中倒数第k个结点
- 16. 反转链表
- 17. 合并两个排序的链表
- 18. 树的子结构
- 19. 二叉树的镜像
- 20. 顺时针打印矩阵
- 21. 包含min函数的栈
- 22. 栈的压入、弹出序列
- 23. 从上往下打印二叉树
- 24. 二叉搜索树的后序遍历序列
- 25. 二叉树中和为某一值的路径
- 26. 复杂链表的复制
- 27. 二叉搜索树与双向链表
- 28. 字符串的排列
- 29. 数组中出现次数超过一半的数字
- 30. 最小的K个数
- 31. 连续子数组的最大和
- 32. 整数中1出现的次数（从1到n整数中1出现的次数）
- 33. 把数组排成最小的数
- 34. 丑数
- 35. 第一个只出现一次的字符
- 36. 数组中的逆序对
- 37. 两个链表的第一个公共结点
- 38. 数字在排序数组中出现的次数
- 39. 二叉树的深度
- 40. 数组中只出现一次的数字
- 41. 和为S的两个数字
- 42. 翻转单词顺序列
- 43.
- 44. 扑克牌顺子
- 45. 孩子们的游戏(圆圈中最后剩下的数)
- 46. 求1+2+3+…+n
- 47. 不用加减乘除做加法
- 48. 把字符串转换成整数
- 49.
- 50.
- 51. 数组中重复的数字
- 52. 构建乘积数组
- 53. 正则表达式匹配
- 54. 表示数值的字符串
- 55. 字符流中第一个不重复的字符
- 56. 链表中环的入口结点
- 57. 删除链表中重复的结点
- 58. 二叉树的下一个结点
- 59. 对称的二叉树
- 60. 按之字形顺序打印二叉树
- 61. 把二叉树打印成多行
- 62. 序列化二叉树
- 63. 二叉搜索树的第k个结点
- 64. 数据流中的中位数
- 65. 滑动窗口的最大值
- 66. 矩阵中的路径
- 67. 机器人的运动范围
- [算法总结] 12. 二分查找
03. 二维数组中的查找
题目描述:
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数
解题思路:
二维数组是有序的，从右上角来看，向左数字递减，向下数字递增。
因此从右上角开始查找，
当要查找数字比右上角数字大时，下移；
当要查找数字比右上角数字小时，左移；
如果出了边界，则说明二维数组中不存在该整数。
参考代码:
public class Solution {
public boolean Find(int target, int [][] array) {
if(array.length==0 || array[0].length==0)
return false;
int m = array[0].length-1;
int n = 0;
int temp = array[n][m];
while(target != temp){
if(m>0 && n<array.length-1){
if(target>temp){
n = n + 1;
}else if(target<temp){
m = m - 1;
}
temp = array[n][m];
}else{
return false;
}
}
return true;
}
}
04. 替换空格
题目描述:
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
解题思路:
很简单，从后往前遍历就对了。
参考代码:
public class Solution {
public String replaceSpace(StringBuffer str) {
StringBuffer res = new StringBuffer();
int len = str.length() - 1;
for(int i = len; i >= 0; i--){
if(str.charAt(i) == ' ')
res.append("02%");
else
res.append(str.charAt(i));
}
return res.reverse().toString();
}
}
05. 从尾到头打印链表
题目描述:
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
解题思路:
一种方法是利用栈来实现；
另外一种方法是利用三个指针把链表反转，关键是 r 指针保存断开的节点。
参考代码:
/**
* public class ListNode {
* int val;
* ListNode next = null;
*
* ListNode(int val) {
* this.val = val;
* }
* }
*
*/
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
if(listNode == null)
return new ArrayList<Integer>();
ListNode head = listNode;
ListNode cur = listNode.next;
while( cur!= null){
ListNode temp = cur.next;
cur.next = head;
head = cur;
cur = temp;
}
//此时listNode的next还指向第二个node，所以要让listNode.next=null,防止循环
listNode.next = null;
ArrayList<Integer> res = new ArrayList<Integer>();
while(head !=null){
res.add(head.val);
head = head.next;
}
return res;
}
}
06. 重建二叉树
题目描述:
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
解题思路:
我们知道，前序遍历的第一个节点就是树的根节点，所以我们先根据前序遍历序列的第一个数字创建根结点，接下来在中序遍历序列中找到根结点的位置，根节点的左边就是左子树，右边就是右子树，这样就能确定左、右子树结点的数量。在前序遍历和中序遍历的序列中划分了左、右子树结点的值之后，就可以递归地去分别构建它的左右子树。
参考代码:
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
if(pre.length ==0 || in.length == 0)
return null;
return ConstructBinaryTree(pre, 0, pre.length - 1, in, 0, in.length - 1);
}
public TreeNode ConstructBinaryTree(int [] pre, int ps, int pe,
int [] in, int is, int ie){
if(ps > pe || is > ie){
return null;
}
TreeNode root = new TreeNode(pre);
for(int i = is; i<=ie; i++){
if(in[i] == pre){
root.left = ConstructBinaryTree(pre, ps+1, ps+i-is, in, is, i-1);
root.right = ConstructBinaryTree(pre, ps+i-is+1, pe, in, i+1, ie);
break;
}
}
return root;
}
}
07. 用两个栈实现队列
题目描述:
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
解题思路:
两个栈 stack1 和 stack2:
push 动作都在 stack1 中进行，
pop 动作在 stack2 中进行。当 stack2 不为空时，直接 pop，当 stack2 为空时，先把 stack1 中的元素 pop 出来，push 到 stack2 中，再从 stack2 中 pop 元素。
参考代码:
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(stack1.isEmpty() && stack2.isEmpty())
throw new RuntimeException("Queue is empty!");
int node;
if(stack2.isEmpty()){
while(!stack1.isEmpty()){
node = stack1.pop();
stack2.push(node);
}
}
return stack2.pop();
}
}
08. 旋转数组的最小数字
题目描述:
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
解题思路:
采用二分查找法。
需要考虑三种情况：
array[mid] > array[high]:
出现这种情况的array类似[3,4,5,6,0,1,2]，此时最小数字一定在mid的右边。
low = mid + 1
array[mid] == array[high]:
出现这种情况的array类似 [1,0,1,1,1] 或者[1,1,1,0,1]，此时最小数字不好判断在mid左边
还是右边,这时只好一个一个试
high = high - 1
array[mid] < array[high]:
出现这种情况的array类似[2,2,3,4,5,6,6],此时最小数字一定就是array[mid]或者在mid的左
边。因为右边必然都是递增的。
high = mid
注意这里有个坑：如果待查询的范围最后只剩两个数，那么mid 一定会指向下标靠前的数字。比如 array = [4,6]，
array[low] = 4
array[mid] = 4
array[high] = 6
如果high = mid – 1，就会产生错误， 因此high = mid
参考代码:
import java.util.ArrayList;
public class Solution {
public int minNumberInRotateArray(int [] array) {
int len = array.length;
if(len == 0)
return 0;
int low = 0, high = len - 1;
while(low < high){
int mid = low + (high - low) / 2;
if(array[mid] > array[high]){
low = mid + 1;
}else if(array[mid] == array[high]){
high = high - 1;
}else{
high = mid;
}
}
return array[low];
}
}
09. 斐波那契数列
题目描述:
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
n<=39
解题思路:
公式:
f(n) = n, n <= 1
f(n) = f(n-1) + f(n-2), n > 1
可以直接使用递归的方法：
if(n<=1) return n;
else return Fibonacci(n-1)+Fibonacci(n-2);
递归的方法可能会遇到Stack Overflow，
所以我们可以考虑用动态规划的方法来实现。
采用自底向上方法来保存了先前计算的值，为后面的调用服务。
参考代码:
public class Solution {
public int Fibonacci(int n) {
if(n == 0 || n == 1)
return n;
int fn1 = 0;
int fn2 = 1;
for(int i=2; i<=n; i++){
fn2 += fn1;
fn1 = fn2 - fn1;
}
return fn2;
}
}
8. 跳台阶
题目描述:
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
解题思路
按照题意，
1 级 —- 1 种
2 级 —- 2 种
3 级 —- 3 种
4 级 —- 5 种
5 级 —- 8 种
我们可以得到一种规律，如果要跳 6 级，可以从 5 级跳一步到 6 级，5 级的方案中有多少种就有多少种跳法跳到 6 级；还可以从 4 级跳两步到 6 级，同理，4 级的方案有多少种就有多少种方法从 4 级跳到 6 级，所以可以得到公式f(n) = f(n-1) + f(n-2)，再结合 1 级和 2 级的情况，可以得以如下的规律：
f(n) = 1, (n=1)
f(n) = 2, (n=2)
f(n) = f(n-1)+f(n-2) ,(n>2,n为整数)
这就是斐波那契数列的变形，因此可以用递归来实现。
参考代码:
public class Solution {
public int JumpFloor(int target) {
if(target<=0)
return 0;
else if(target == 1|| target == 2)
return target;
else
return JumpFloor(target-1)+JumpFloor(target-2);
}
}
9. 变态跳台阶
题目描述:
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
解题思路:
f(1) = 1
f(2) = f(2-1) + f(2-2)
f(3) = f(3-1) + f(3-2) + f(3-3)
…
f(n) = f(n-1) + f(n-2) + f(n-3) + … + f(n-(n-1)) + f(n-n)
因为青蛙可以跳上任意级的台阶，所以以青蛙跳上一个 4 级的台阶为例进行分析，它可以在开始直接跳 4 级到 4 级台阶，也可以从 1 级台阶上往上跳 3 个台阶到 4 级，也可以从 2 级台阶往上跳 2 个台阶到 4 级，还可以从 3 级台阶上跳 3 级到 4 级。所以f(4) = f(4-1) + f(4-2) + f(4-3) + f(4-4)
可以得出以下的公式：
f(n) = f(n-1)+f(n-2)+…+f(n-(n-1)) + f(n-n)
=> f(0) + f(1) + f(2) + f(3) + … + f(n-1)
又因为：
f(n-1) = f(0) + f(1)+f(2)+f(3) + … + f((n-1)-1)
= f(0) + f(1) + f(2) + f(3) + … + f(n-2)
f(n) = f(0) + f(1) + f(2) + f(3) + … + f(n-2) + f(n-1) = f(n-1) + f(n-1)
= 2 * f(n-1)
最后可以得到
f(n) = 1, (n=0)
f(n) = 1, (n=1)
f(n) = 2*f(n-1),(n>=2)
参考代码:
public class Solution {
public int JumpFloorII(int target) {
if(target<=0)
return 0;
if(target == 1||target ==2)
return target;
else
return 2*JumpFloorII(target-1);
}
}
10. 矩形覆盖
题目描述:
我们可以用2 * 1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2 * 1的小矩形无重叠地覆盖一个2 * n的大矩形，总共有多少种方法？
解题思路:
依旧是斐波那契数列
f(1) = 1
f(2) = 2
当n=3时，它可以由n=2的情况再覆盖一块得到，也可以由 n=1的情况再覆盖 2 块得到，所以 f(3) = f(1) + f(2)，依次往下推，可以得到
f(n) = 1, (n=1)
f(n) = 2, (n=2)
f(n) = f(n-1) + f(n-2), (n>2)
用递归的方法即可实现
参考代码:
public class Solution {
public int RectCover(int target) {
if(target<=0){
return 0;
}
else if(target == 1|| target ==2){
return target;
}
else{
return RectCover(target-1) + RectCover(target-2);
}
}
}
10. 二进制中1的个数
题目描述:
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
解题思路:
如果一个整数不为0，那么这个整数至少有一位是1。如果我们把这个整数减1，那么原来处在整数最右边的1就会变为0，原来在1后面的所有的0都会变成1(如果最右边的1后面还有0的话)。其余所有位将不会受到影响。
举个例子：一个二进制数1100，从右边数起第三位是处于最右边的一个1。减去1后，第三位变成0，它后面的两位0变成了1，而前面的1保持不变，因此得到的结果是1011.我们发现减1的结果是把最右边的一个1开始的所有位都取反了。这个时候如果我们再把原来的整数和减去1之后的结果做与运算，从原来整数最右边一个1那一位开始所有位都会变成0。如1100&1011=1000.也就是说，把一个整数减去1，再和原整数做与运算，会把该整数最右边一个1变成0.那么一个整数的二进制有多少个1，就可以进行多少次这样的操作。
来源于牛客网@菩提旭光
参考代码:
public class Solution {
public int NumberOf1(int n) {
int count = 0;
while(n!=0){
count += 1;
n &= (n-1);
}
return count;
}
}
11.数值的整数次方
题目描述:
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
解题思路:
指数为负时，可以先对指数求绝对值，算出次方的结果后再取倒数
当底数为0，指数为负时，会出现对0求倒数情况，要特殊处理
0的0次方在数学上没有意义，因此无论输出0还是1都是可以接受的
在计算次方的时候，除了简单的遍历，我们可以使用递归的思想，如下公式，来减少计算量：
参考代码:
public class Solution {
public double Power(double base, int exponent) {
int n = exponent;
if(exponent==0){
// 当指数为0底数为0时，没有意义，返回0或者返回1都可以
return 1;
}else if(exponent < 0){
if(base == 0){
throw new RuntimeException("分母不能为0");
}
n = -exponent;
}
double res = PowerUnsignedExponent(base, n);
return exponent<0? 1/res: res;
}
public double PowerUnsignedExponent(double base, int n){
if(n == 0)
return 1;
if(n == 1)
return base;
//递归
double res = PowerUnsignedExponent(base, n/2);
res *= res;
if(n%2 == 1)
res *= base;
return res;
}
}
代码优化:
可以使用右移运算符代替除以2，用位与运算符代替求余运算符（%）来判断一个数是奇数还是偶数。
public double PowerUnsignedExponent(double base, int n){
if(n == 0)
return 1;
if(n == 1)
return base;
//递归
double res = PowerUnsignedExponent(base, n>>1);
res *= res;
if((n & 0x1) == 1)
res *= base;
return res;
}
14. 调整数组顺序使奇数位于偶数前面
题目描述:
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
参考代码:
最简单的方法就是把奇数和偶数按顺序挑出来，分别放到vector里，最后再把偶数的vector接到奇数vector的末尾。
import java.util.Vector;
public class Solution {
public void reOrderArray(int [] array) {
Vector<Integer> odd = new Vector<Integer>();
Vector<Integer> even = new Vector<Integer>();
for(int i = 0; i < array.length; i++){
if(array[i]%2 == 0){
even.add(array[i]);
}else{
odd.add(array[i]);
}
}
odd.addAll(even);
for(int i=0;i<array.length;i++){
array[i] = odd.get(i);
}
}
}
如果不能开僻额外的空间，可以尝试有类似于冒泡排序的方法,如果当前的值为偶数，后一个值为奇数，则两个数对换位置：
public class Solution {
public void reOrderArray(int [] array) {
for(int i=0; i < array.length; i++){
for(int j=0; j<array.length-1; j++){
if(array[j] % 2 == 0 && array[j+1] % 2 != 0){
int temp = array[j+1];
array[j+1] = array[j];
array[j] = temp;
}
}
}
}
}
15. 链表中倒数第k个结点
题目描述:
输入一个链表，输出该链表中倒数第k个结点。
解题思路:
经典的双指针法。定义两个指针，第一个指针从链表的头指针开始遍历向前走k-1步，第二个指针保持不动，从第k步开始，第二个指针也开始从链表的头指针开始遍历，由于两个指针的距离保持在k-1，当第一个指针到达链表的尾节点时，第二个指针刚好指向倒数第k个节点。
关注要点:
- 链表头指针是否为空，若为空则直接返回回null
- k是否为0，k为0也就是要查找倒数第0个节点，由于计数一般是从1开始的，所有输入0没有实际意义，返回null
- k是否超出链表的长度，如果链表的节点个数少于k，则在指针后移的过程中会出现next指向空指针的错误，所以程序中要加一个判断
参考代码:
public class Solution {
public ListNode FindKthToTail(ListNode head,int k) {
if(head == null || k == 0)
return null;
ListNode temp = head;
//判断k是否超过链表节点的个数，注意是 i < k - 1
for(int i=0; i < k-1; i++){
if(temp.next != null)
temp = temp.next;
else
return null;
}
ListNode pA = head;
ListNode pB = head;
for(int i=0; i<k-1; i++)
pA = pA.next;
while(pA.next != null){
pA = pA.next;
pB = pB.next;
}
return pB;
}
}
当然，还有一种是用stack的方法，把链表按顺序压入stack,然后直接取出stack的第k个节点。
16. 反转链表
题目描述:
输入一个链表，反转链表后，输出新链表的表头。
解题思路:
设置三个指针，head为当前节点，pre为当前节点的前一个节点，next为当前节点的下一个节点，需要pre和next的目的是让当前节点从pre->head->next1->next2变成pre<-head next1->next2的过程中，用pre让节点反转所指方向，next节点保存next1节点防止链表断开
需要注意的点：:
1、如果输入的头结点是null，则返回null
2、链表断裂的考虑
参考代码:
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode ReverseList(ListNode head) {
if(head == null)
return null;
ListNode pre = null;
ListNode next = null;
while(head != null){
next = head.next;
head.next = pre;
pre = head;
head = next;
}
return pre;
}
}
17. 合并两个排序的链表
题目描述:
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
解题思路:
两种解法：递归和非递归
参考代码:
/*
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;
else if(list2 == null)
return list1;
ListNode mergehead = null;
if(list1.val <= list2.val){
mergehead = list1;
mergehead.next = Merge(list1.next,list2);
}else{
mergehead = list2;
mergehead.next = Merge(list1, list2.next);
}
return mergehead;
}
}
//非递归解法
public class Solution {
public ListNode Merge(ListNode list1,ListNode list2) {
if(list1 == null)
return list2;
else if(list2 == null)
return list1;
ListNode mergehead = null;
if(list1.val <= list2.val){
mergehead = list1;
list1 = list1.next;
}else{
mergehead = list2;
list2 = list2.next;
}
ListNode cur = mergehead;
while(list1 != null && list2 != null){
if(list1.val <= list2.val){
cur.next = list1;
list1 = list1.next;
}else{
cur.next = list2;
list2 = list2.next;
}
cur = cur.next;
}
if(list1 == null)
cur.next = list2;
else if(list2 == null)
cur.next = list1;
return mergehead;
}
}
18. 树的子结构
题目描述:
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
解题思路:
递归思想，如果根节点相同则递归调用IsSubtree()，如果根节点不相同，则判断root1的左子树和roo2是否相同，再判断右子树和root2是否相同;
注意节点为空的条件，HasSubTree中，只要有树为空就返回false; IsSubtree中，要先判断root2，如果root2为空，则说明第二棵树遍历完了，即匹配成功。
参考代码:
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public boolean HasSubtree(TreeNode root1,TreeNode root2) {
if(root1 == null || root2 == null){
return false;
}
return IsSubtree(root1, root2) ||
HasSubtree(root1.left, root2) ||
HasSubtree(root1.right, root2);
}
public boolean IsSubtree(TreeNode root1, TreeNode root2){
//要先判断roo2, 不然{8,8,7,9,2,#,#,#,#,4,7},{8,9,2}这个测试用例通不过。
if(root2 == null)
return true;
if(root1 == null)
return false;
if(root1.val == root2.val){
return IsSubtree(root1.left, root2.left) &&
IsSubtree(root1.right, root2.right);
}else
return false;
}
}
19. 二叉树的镜像
题目描述:
操作给定的二叉树，将其变换为源二叉树的镜像。
输入描述:
二叉树的镜像定义：
源二叉树
8
/ \
6 10
/ \ / \
5 7 9 11
镜像二叉树
8
/ \
10 6
/ \ / \
11 9 7 5
解题思路:
通过对以上两棵树的观察，我们可以总结出这两棵树的根节点相同，但它们的左、右两个子节点交换了位置。所以我们可以得出求一棵树的镜像的过程：先前序遍历这棵树的每个节点，如果遍历到的节点有子节点，就交换它的两个子节点。当交换完所有非叶节点的左、右子节点之后，就得到了树的镜像。
参考代码:
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public void Mirror(TreeNode root) {
//当前节点为空，直接返回
if(root == null)
return;
//当前节点没有叶子节点，直接返回
if(root.left == null && root.right == null)
return;
TreeNode temp = root.left;
root.left = root.right;
root.right = temp;
//递归交换叶子节点
if(root.left != null)
Mirror(root.left);
if(root.right != null)
Mirror(root.right);
}
}
20. 顺时针打印矩阵
题目描述:
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.
解题思路:
先得到矩阵的行和列数，然后依次旋转打印数据，一次旋转打印结束后，往对角分别前进和后退一个单位。
要注意单行和单列的情况。
参考代码:
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> printMatrix(int [][] matrix) {
int row = matrix.length;
int col = matrix[0].length;
ArrayList<Integer> res = new ArrayList<>();
if(row == 0 && col == 0)
return res;
int left = 0, right = col - 1, top = 0, bottom = row - 1;
while(left <= right && top <= bottom){
//上：从左到右
for(int i=left; i<=right; i++)
res.add(matrix[top][i]);
//右：从上到下
for(int i=top+1; i<=bottom; i++)
res.add(matrix[i][right]);
//下：从右到左
if(top != bottom){
//防止单行情况
for(int i=right-1; i>=left; i--)
res.add(matrix[bottom][i]);
}
//左：从下到上
if(left != right){
//防止单列情况
for(int i=bottom-1; i>top; i--)
res.add(matrix[i][left]);
}
left++; right--; top++; bottom--;
}
return res;
}
}
21. 包含min函数的栈
题目描述:
定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。
解题思路:
用一个栈stack保存数据，用另外一个栈temp保存依次入栈最小的数
比如，stack中依次入栈
5, 3, 4, 10, 2, 12, 1, 8
则temp依次入栈
5, 3, 3，3, 2, 2, 1, 1
每次入栈的时候，如果入栈的元素比min中的栈顶元素小或等于则入栈，否则用最小元素入栈。
参考代码:
import java.util.Stack;
public class Solution {
Stack<Integer> stack = new Stack<>();
Stack<Integer> temp = new Stack<>();
int min = Integer.MAX_VALUE;
public void push(int node) {
stack.push(node);
if(node < min){
temp.push(node);
min = node;
}
else
temp.push(min);
}
public void pop() {
stack.pop();
temp.pop();
}
public int top() {
int t = stack.pop();
stack.push(t);
return t;
}
public int min() {
int m = temp.pop();
temp.push(m);
return m;
}
}
22. 栈的压入、弹出序列
题目描述:
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
解题思路:
模拟堆栈操作的过程，将原数列依次压栈，把栈顶元素与所给出栈队列相比，如果相同则出栈，如果不同则继续压栈，直到原数列中所有数字压栈完毕。最后，检测栈中是否为空，若空，说明出栈队列可由原数列进行栈操作得到。否则，说明出栈队列不能由原数列进行栈操作得到。
参考代码:
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
public boolean IsPopOrder(int [] pushA,int [] popA) {
if(pushA.length != popA.length ||
pushA.length == 0 ||
popA.length == 0)
return false;
Stack<Integer> stack = new Stack<>();
int index = 0;
for(int i = 0; i < pushA.length; i++){
stack.push(pushA[i]);
while(!stack.empty() && stack.peek() == popA[index]){
stack.pop();
index++;
}
}
return stack.empty();
}
}
23. 从上往下打印二叉树
题目描述:
从上往下打印出二叉树的每个节点，同层节点从左至右打印。
解题思路:
就是二叉树的层序遍历。借助一个队列就可以实现。
使用两个队列一个存放节点，一个存放值。先将根节点加入到队列中，然后遍历队列中的元素，遍历过程中，访问该元素的左右节点，再将左右子节点加入到队列中来。
注意Queue创建的方式：Queue queue = new LinkedList();
用add将元素添加到队列中，用remove来移除并返回队首元素。
参考代码:
import java.util.ArrayList;
import java.util.Queue;
import java.util.LinkedList;
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
ArrayList<Integer> res = new ArrayList<>();
if(root == null)
return res;
//Queue is abstract; 不能用 new Queue();
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.add(root);
while(queue.size() != 0){
root = queue.remove();
res.add(root.val);
if(root.left != null){
queue.add(root.left);
}
if(root.right != null){
queue.add(root.right);
}
}
return res;
}
}
24. 二叉搜索树的后序遍历序列
题目描述:
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
解题思路:
二叉搜索树: 左子树<根<=右子树
对于后序遍历来说，序列数组的最后一个元素一定是根节点, 根据这个元素，将前面的数组分为左、右两个部分，左侧部分都比该元素小，右侧部分都比该元素大，如果右侧部分有比该根节点小的元素，那么就不是后序遍历，如此递归进行。
参考代码:
public class Solution {
public boolean VerifySquenceOfBST(int [] sequence) {
if(sequence.length == 0)
return false;
if(sequence.length == 1)
return true;
return judge(sequence, 0, sequence.length-1);
}
public boolean judge(int [] sequence, int start, int root){
if(start >= root)
return true;
int i = start;
while(i < root && sequence[i] < sequence[root])
i++;
for(int j=i; j<root; j++){
if(sequence[j]<sequence[root])
return false;
}
return (judge(sequence, start, i-1)) && (judge(sequence, i, root-1));
}
}
25. 二叉树中和为某一值的路径
题目描述:
输入一颗二叉树和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。
解题思路:
用前序遍历的方式访问到某一结点时，把该结点添加到路径上，并用目标值减去该节点的值。如果该结点为叶结点并且目标值减去该节点的值刚好为0，则当前的路径符合要求，我们把加入res数组中。如果当前结点不是叶结点，则继续访问它的子结点。当前结点访问结束后，递归函数将自动回到它的父结点。因此我们在函数退出之前要在路径上删除当前结点，以确保返回父结点时路径刚好是从根结点到父结点的路径。
参考代码:
import java.util.ArrayList;
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
ArrayList<ArrayList<Integer> > res = new ArrayList<ArrayList<Integer> >();
ArrayList<Integer> temp = new ArrayList<Integer>();
public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
if(root == null)
return res;
target -= root.val;
temp.add(root.val);
if(target == 0 && root.left == null && root.right == null)
res.add(new ArrayList<Integer>(temp));
else{
FindPath(root.left, target);
FindPath(root.right, target);
}
temp.remove(temp.size()-1);
return res;
}
}
26. 复杂链表的复制
题目描述:
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
解题思路:
参考代码:
/*
public class RandomListNode {
int label;
RandomListNode next = null;
RandomListNode random = null;
RandomListNode(int label) {
this.label = label;
}
}
*/
public class Solution {
public RandomListNode Clone(RandomListNode pHead)
{
if(pHead == null)
return null;
//复制节点 A->B->C 变成 A->A'->B->B'->C->C'
RandomListNode head = pHead;
while(head != null){
RandomListNode node = new RandomListNode(head.label);
node.next = head.next;
head.next = node;
head = node.next;
}
//复制random
head = pHead;
while(head != null){
head.next.random = head.random == null ? null : head.random.next;
head = head.next.next;
}
//折分
head = pHead;
RandomListNode chead = head.next;
while(head != null){
RandomListNode node = head.next;
head.next = node.next;
node.next = node.next == null ? null : node.next.next;
head = head.next;
}
return chead;
}
}
27. 二叉搜索树与双向链表
题目描述:
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
解题思路:
题目可能比较难理解，可以看如下的图，我们有一棵二叉搜索树，要求得右边的双向链表。
在二叉搜索树中，左子结点的值总是小于父结点的值，右子节点的值总是大于父结点的值。因此我们在转换成排序双向链表时，原先指向左子结点的指针调整为链表中指向前一个结点的指针，原先指向右子节点的指针调整为链表中指向后一个结点的指针。
因为中序遍历是按照从小到大的顺序遍历二叉搜索树，所以我们用中序遍历树中的每一个节点得到的正好是要求的排好序的。遍历过程如下：
每次遍历节点的左孩子、右孩子，把左孩子指向转换链表的尾节点，并把末尾指针的右孩子指向自己。右孩子指向节点的右孩子。如果没有右孩子就返回。这一过程可以用递归实现。
参考代码:
递归解法
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
TreeNode head = null;
TreeNode end = null;
public TreeNode Convert(TreeNode pRootOfTree) {
ConvertSub(pRootOfTree);
return head;
}
public void ConvertSub(TreeNode pRootOfTree) {
if(pRootOfTree == null)
return ;
Convert(pRootOfTree.left);
if(end == null){
head = pRootOfTree;
end = pRootOfTree;
}else{
end.right = pRootOfTree;
pRootOfTree.left = end;
end = pRootOfTree;
}
Convert(pRootOfTree.right);
}
}
非递归解法
import java.util.Stack;
public class Solution {
public TreeNode Convert(TreeNode pRootOfTree) {
TreeNode head = null;
TreeNode pre = null;
Stack<TreeNode> stack = new Stack<>();
while(pRootOfTree != null || !stack.isEmpty()){
while(pRootOfTree != null){
stack.push(pRootOfTree);
pRootOfTree = pRootOfTree.left;
}
pRootOfTree = stack.pop();
if(head == null){
head = pRootOfTree;
pre = pRootOfTree;
}else{
pre.right = pRootOfTree;
pRootOfTree.left = pre;
pre = pRootOfTree;
}
pRootOfTree = pRootOfTree.right;
}
return head;
}
}
28. 字符串的排列
题目描述:
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
输入描述:
输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。
解题思路:
刚看题目的时候，可能会觉得这个问题很复杂，不能一下子想出解决方案。那我们就要学会把复杂的问题分解成小问题。我们求整个字符串的排列，其实可以看成两步：
第一步求所有可能出现在第一个位置的字符（即把第一个字符和后面的所有字符交换[相同字符不交换]）；
第二步固定第一个字符，求后面所有字符的排列。这时候又可以把后面的所有字符拆成两部分（第一个字符以及剩下的所有字符），依此类推。这样，我们就可以用递归的方法来解决。
参考代码:
import java.util.ArrayList;
import java.util.Collections;
public class Solution {
ArrayList<String> res = new ArrayList<String>();
public ArrayList<String> Permutation(String str) {
if(str == null)
return res;
PermutationHelper(str.toCharArray(), 0);
Collections.sort(res);
return res;
}
public void PermutationHelper(char[] str, int i){
if(i == str.length - 1){
res.add(String.valueOf(str));
}else{
for(int j = i; j < str.length; j++){
if(j!=i && str[i] == str[j])
continue;
swap(str, i, j);
PermutationHelper(str, i+1);
swap(str, i, j);
}
}
}
public void swap(char[] str, int i, int j) {
char temp = str[i];
str[i] = str[j];
str[j] = temp;
}
}
29. 数组中出现次数超过一半的数字
题目描述:
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
解题思路:
三种解法：
法1：借助hashmap存储数组中每个数出现的次数，最后看是否有数字出现次数超过数组长度的一半；
法2：排序。数组排序后，如果某个数字出现次数超过数组的长度的一半，则一定会数组中间的位置。所以我们取出排序后中间位置的数，统计一下它的出现次数是否大于数组长度的一半；
法3：某个数字出现的次数大于数组长度的一半，意思就是它出现的次数比其他所有数字出现的次数和还要多。因此我们可以在遍历数组的时候记录两个值：
- 数组中的数字;
- 次数。
遍历下一个数字时，若它与之前保存的数字相同，则次数加1，否则次数减1；若次数为0，则保存下一个数字，并将次数置为1。遍历结束后，所保存的数字即为所求。最后再判断它是否符合条件。
参考代码:
法1：
import java.util.HashMap;
import java.util.Map;
public class Solution {
public int MoreThanHalfNum_Solution(int [] array) {
HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
int length = array.length;
for(int i=0; i<length; i++){
if(!map.containsKey(array[i]))
map.put(array[i], 1);
else
map.put(array[i], map.get(array[i])+1);
}
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
if(entry.getValue()*2>length)
return entry.getKey();
}
return 0;
}
}
法2：
import java.util.Arrays;
public class Solution {
public int MoreThanHalfNum_Solution(int [] array) {
Arrays.sort(array);
int half = array.length/2;
int count = 0;
for(int i=0; i<array.length; i++){
if(array[i] == array[half])
count ++;
}
if(count > half)
return array[half];
else
return 0;
}
}
法3：
public class Solution {
public int MoreThanHalfNum_Solution(int [] array) {
int res = array[0], count = 1;
for(int i=1; i<array.length; i++){
if(array[i] == res)
count++;
else{
count--;
}
if(count == 0){
res = array[i];
count = 1;
}
}
count = 0;
for(int i=0; i<array.length; i++){
if(array[i] == res)
count++;
}
return count > array.length/2 ? res : 0;
}
}
30. 最小的K个数
题目描述:
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。
解题思路:
两种方法：
法1：先对数组排序，然后取出前k个
法2：利用最大堆保存这k个数，每次只和堆顶比，如果比堆顶小，删除堆顶，新数入堆。
参考代码:
法1：
import java.util.ArrayList;
import java.util.Arrays;
public class Solution {
public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
ArrayList<Integer> res = new ArrayList<Integer>();
if(input == null || k ==0 || k > input.length)
return res;
Arrays.sort(input);
for(int i=0; i<k; i++)
res.add(input[i]);
return res;
}
}
法2：
import java.util.ArrayList;
import java.util.PriorityQueue;
import java.util.Comparator;
public class Solution {
public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
ArrayList<Integer> res = new ArrayList<Integer>();
if(input == null || k ==0 || k > input.length)
return res;
PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>(k, new Comparator<Integer>() {
public int compare(Integer e1, Integer e2) {
return e2 - e1;
}
});
for(int i=0; i<input.length; i++){
if(maxHeap.size() != k)
maxHeap.offer(input[i]);
else{
if(maxHeap.peek() > input[i]){
maxHeap.poll();
maxHeap.offer(input[i]);
}
}
}
for(Integer i: maxHeap){
res.add(i);
}
return res;
}
}
31. 连续子数组的最大和
题目描述:
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。你会不会被他忽悠住？(子向量的长度至少是1)
解题思路:
对于一个数组中的一个数x，若是x的左边的数加起来非负，那么加上x能使得值变大，这样我们认为x之前的数的和对整体和是有贡献的。如果前几项加起来是负数，则认为有害于总和。我们用cur记录当前值,用max记录最大值，如果cur<0,则舍弃之前的数，让cur等于当前的数字，否则，cur = cur+当前的数字。若cur和大于max更新max。
参考代码:
public class Solution {
public int FindGreatestSumOfSubArray(int[] array) {
if(array.length == 0)
return 0;
int cur = array[0], max = array[0];
for(int i=1; i<array.length; i++){
cur = cur > 0 ? cur + array[i] : array[i];
if(max < cur)
max = cur;
}
return max;
}
}
32. 整数中1出现的次数（从1到n整数中1出现的次数）
题目描述:
求出113的整数中1出现的次数,并算出1001300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。
解题思路:
三种解法：
法一：依次遍历每个数，判断每个数里面是否包含1
法二：同法一，将数字转成字符串，直接判断
法三：归纳法
设N = abcde ,其中abcde分别为十进制中各位上的数字。
如果要计算百位上1出现的次数，它要受到3方面的影响：百位上的数字，百位以下（低位）的数字，百位以上（高位）的数字。
① 如果百位上数字为0，百位上可能出现1的次数由更高位决定。比如：12013，则可以知道百位出现1的情况可能是：100199，11001199,21002199，，…，1110011199，一共1200个。可以看出是由更高位数字（12）决定，并且等于更高位数字（12）乘以 当前位数（100）。
② 如果百位上数字为1，百位上可能出现1的次数不仅受更高位影响还受低位影响。比如：12113，则可以知道百位受高位影响出现的情况是：100199，11001199,21002199，，….，1110011199，一共1200个。和上面情况一样，并且等于更高位数字（12）乘以 当前位数（100）。但同时它还受低位影响，百位出现1的情况是：12100~12113,一共114个，等于低位数字（113）+1。
③ 如果百位上数字大于1（29），则百位上出现1的情况仅由更高位决定，比如12213，则百位出现1的情况是：100199,11001199，21002199，…，1110011199,1210012199,一共有1300个，并且等于更高位数字+1（12+1）乘以当前位数（100）。
——参考牛客网@藍裙子的百合魂
参考代码:
法一：
public class Solution {
public int NumberOf1Between1AndN_Solution(int n) {
int res = 0;
for(int i = 1; i <= n; i++)
res += number1(i);
return res;
}
public int number1(int n){
int res = 0;
while(n>0){
if(n % 10 == 1)
res++;
n /= 10;
}
return res;
}
}
法二：
public class Solution {
public int NumberOf1Between1AndN_Solution(int n) {
int res = 0;
StringBuffer s = new StringBuffer();
for(int i = 1; i<=n; i++){
s.append(i);
}
String str = s.toString();
for(int i=0; i<str.length(); i++){
if(str.charAt(i) == '1')
res++;
}
return res;
}
}
法三：
public class Solution {
public int NumberOf1Between1AndN_Solution(int n) {
int res = 0;
int cur = 0, before = 0, after = 0;
int i = 1;
while(i<=n){
before = n/(i*10);
cur = (n/i)%10;
after = n - n/i*i;
if(cur == 0){
// 如果为0,出现1的次数由高位决定,等于高位数字 * 当前位数
res += before * i;
}else if(cur == 1){
// 如果为1, 出现1的次数由高位和低位决定,高位*当前位+低位+1
res += before * i + after + 1;
}else{
// 如果大于1, 出现1的次数由高位决定,（高位数字+1）* 当前位数
res += (before + 1) * i;
}
i *= 10;
}
return res;
}
}
33. 把数组排成最小的数
题目描述:
输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
解题思路:
先将数组转换成字符串数组，然后对字符串数组按照规则排序，最后将排好序的字符串数组拼接出来。
关键就是制定排序规则：
若ab > ba 则 a > b
若ab < ba 则 a < b
若ab = ba 则 a = b
解释说明：
a = 21
b = 2
因为 212 < 221, 即 ab < ba ，所以 a < b
所以我们通过对ab和ba比较大小，来判断a在前或者b在前的。
参考代码:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
public class Solution {
public String PrintMinNumber(int [] numbers) {
int len = numbers.length;
if(len == 0)
return "";
if(len == 1)
return String.valueOf(numbers[0]);
StringBuffer res = new StringBuffer();
String [] str = new String[len];
for(int i=0; i<len; i++)
str[i] = String.valueOf(numbers[i]);
Arrays.sort(str, new Comparator<String>(){
public int compare(String s1, String s2) {
String c1 = s1 + s2;
String c2 = s2 + s1;
return c1.compareTo(c2);
}
});
for(int i=0; i<len; i++)
res.append(str[i]);
return res.toString();
}
}
34. 丑数
题目描述:
把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
解题思路:
判断一个数是不是丑数，最简单的方法就是让这个数不断除以2，3，5。要求第N个丑数，只要从1开始，依次判断每个数是不是丑数，如果是，则相应的序号加1，直到序号为N，就是我们要的丑数了。但是这种方法时间效率很，通常面试官不会满意这样的答案。因此我们需要一个时间复杂度更低的解法。
换个思路，我们只求丑数，不要去管非丑数。每个丑数必然是由小于它的某个丑数乘以2，3或5得到的，这样我们把求得的丑数都保存下来，用之前的丑数分别乘以2，3，5，找出这三这种最小的并且大于当前最大丑数的值，即为下一个我们要求的丑数。这种方法用空间换时间，时间复杂度为O(n)。
参考代码:
public class Solution {
public int GetUglyNumber_Solution(int index) {
if(index <= 0)
return 0;
if(index == 1)
return 1;
int t2 = 0, t3 = 0, t5 = 0;
int [] res = new int[index];
res[0] = 1;
for(int i = 1; i<index; i++){
res[i] = Math.min(res[t2]*2, Math.min(res[t3]*3, res[t5]*5));
if(res[i] == res[t2]*2) t2++;
if(res[i] == res[t3]*3) t3++;
if(res[i] == res[t5]*5) t5++;
}
return res[index-1];
}
}
35. 第一个只出现一次的字符
题目描述:
在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1.
解题思路:
先在hash表中统计各字母出现次数，第二次扫描直接访问hash表获得次数。也可以用数组代替hash表。
参考代码:
HashMap
import java.util.HashMap;
public class Solution {
public int FirstNotRepeatingChar(String str) {
int len = str.length();
if(len == 0)
return -1;
HashMap<Character, Integer> map = new HashMap<>();
for(int i = 0; i < len; i++){
if(map.containsKey(str.charAt(i))){
int value = map.get(str.charAt(i));
map.put(str.charAt(i), value+1);
}else{
map.put(str.charAt(i), 1);
}
}
for(int i = 0; i < len; i++){
if(map.get(str.charAt(i)) == 1)
return i;
}
return -1;
}
}
数组
public class Solution {
public int FirstNotRepeatingChar(String str) {
int len = str.length();
if(len == 0)
return -1;
char [] s = str.toCharArray();
int [] m = new int[256];
for(int i = 0; i < len; i++){
m[s[i]]++;
}
for(int i = 0; i < len; i++){
if(m[s[i]] == 1)
return i;
}
return -1;
}
}
36. 数组中的逆序对
题目描述:
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
输入描述:
题目保证输入的数组中没有的相同的数字
数据范围：
对于%50的数据,size<=10^4
对于%75的数据,size<=10^5
对于%100的数据,size<=2*10^5
示例1
输入
1,2,3,4,5,6,7,0
输出
7
解题思路:
很容易想到的方法就是遍历每一个元素，让其与后面的元素对比，如果大于则count++，但是这样的时间复杂度是O(n^2)，因此，我们可以用归并排序思路。
例如7,5,4,6可以划分为两段7,5和4,6两个子数组
在7,5中求出逆序对，因为7大于5所以有1对
在6,4中求出逆序对，因为6大于4所以逆序对再加1，为2
对7,5和6,4进行排序，结果为5,7,和4,6
设置两个指针分别指向两个子数组中的最大值，p1指向7，p2指向6
比较p1和p2指向的值，如果大于p2，因为p2指向的是最大值，所以第二个子数组中有几个元素就有几对逆序对(当前有两个元素，逆序对加2,2+2=4)，7>6,比较完之后将p1指向的值放入辅助数组里，辅助数组里现在有一个数字7，然后将p1向前移动一位指向5
再次判断p1和p2指向的值，p1小于p2，因为p1指向的是第一个子数组中最大值，所以子数组中没有能和当前p2指向的6构成逆序对的数，将p2指向的值放入辅助数组，并向前移动一位指向4，此时辅助数组内为6,7
继续判断p1(指向5)和p2(指向4)，5>4,第二个子数组中只有一个数字，逆序对加1，4+1=5，为5对，然后将5放入辅助数组，第一个子数组遍历完毕，只剩下第二个子数组，当前只有一个4，将4也放入辅助数组，函数结束。辅助数组此时为4,5,6,7.逆序对为5.
参考代码:
public class Solution {
public int InversePairs(int [] array) {
int len = array.length;
if(array== null || len <= 0){
return 0;
}
return mergeSort(array, 0, len-1);
}
public int mergeSort(int [] array, int start, int end){
if(start == end)
return 0;
int mid = (start + end) / 2;
int left_count = mergeSort(array, start, mid);
int right_count = mergeSort(array, mid + 1, end);
int i = mid, j = end;
int [] copy = new int[end - start + 1];
int copy_index = end - start;
int count = 0;
while(i >= start && j >= mid + 1){
if(array[i] > array[j]){
copy[copy_index--] = array[i--];
count += j - mid;
if(count > 1000000007){
count %= 1000000007;
}
}else{
copy[copy_index--] = array[j--];
}
}
while(i >= start){
copy[copy_index--] = array[i--];
}
while(j >= mid + 1){
copy[copy_index--] = array[j--];
}
i = 0;
while(start <= end) {
array[start++] = copy[i++];
}
return (left_count+right_count+count)%1000000007;
}
}
37. 两个链表的第一个公共结点
题目描述:
输入两个链表，找出它们的第一个公共结点。
解题思路:
如果两个链表存在公共结点，那么它们从公共结点开始一直到链表的结尾都是一样的，因此我们只需要从链表的结尾开始，往前搜索，找到最后一个相同的结点即可。但是题目给出的单向链表，我们只能从前向后搜索，这时，我们就可以借助栈来完成。先把两个链表依次装到两个栈中，然后比较两个栈的栈顶结点是否相同，如果相同则出栈，如果不同，那最后相同的结点就是我们要的返回值。
还有一种方法，不需要借助栈。先找出2个链表的长度，然后让长的先走两个链表的长度差，然后再一起走，直到找到第一个公共结点。
参考代码:
法1：Stack
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
import java.util.Stack;
public class Solution {
public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
Stack<ListNode> s1 = new Stack<>();
Stack<ListNode> s2 = new Stack<>();
while(pHead1 != null){
s1.push(pHead1);
pHead1 = pHead1.next;
}
while(pHead2 != null){
s2.push(pHead2);
pHead2 = pHead2.next;
}
ListNode res = null;
while(!s1.isEmpty() && !s2.isEmpty() && s1.peek() == s2.peek()){
s1.pop();
res = s2.pop();
}
return res;
}
}
法2：
public class Solution {
public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
if(pHead1 == null || pHead2 == null)
return null;
int count1 = 1, count2 = 1;
ListNode p1 = pHead1;
ListNode p2 = pHead2;
while(p1.next != null){
p1 = p1.next;
count1++;
}
while(p2.next != null){
p2 = p2.next;
count2++;
}
if(count1>count2){
int dif = count1 - count2;
while(dif != 0){
pHead1 = pHead1.next;
dif--;
}
}else{
int dif = count2 - count1;
while(dif != 0){
pHead2 = pHead2.next;
dif--;
}
}
while(pHead1 != null && pHead2 != null){
if(pHead1 == pHead2)
return pHead1;
pHead1 = pHead1.next;
pHead2 = pHead2.next;
}
return null;
}
}
38. 数字在排序数组中出现的次数
题目描述:
统计一个数字在排序数组中出现的次数。
解题思路:
正常的思路就是二分查找了，我们用递归的方法实现了查找k第一次出现的下标，用循环的方法实现了查找k最后一次出现的下标。
除此之外，还有另一种奇妙的思路，因为data中都是整数，所以我们不用搜索k的两个位置，而是直接搜索k-0.5和k+0.5这两个数应该插入的位置，然后相减即可。
参考代码:
法一：
public class Solution {
public int GetNumberOfK(int [] array , int k) {
int len = array.length;
if(len == 0)
return 0;
int first = getFirst(array, k, 0, len-1);
int last = getLast(array, k, 0, len-1);
if(first != -1 && last != -1){
return last - first + 1;
}
return 0;
}
public int getFirst(int [] array, int k, int start, int end){
int mid;
while(start <= end){
mid = start + (end - start) / 2;
if(k <= array[mid])
end = mid - 1;
else
start = mid + 1;
}
if(start < array.length && array[start] == k)
return start;
else
return -1;
}
// 循环
public int getLast(int [] array, int k, int start, int end){
int mid;
while(start <= end){
mid = start + (end - start) / 2;
if(k >= array[mid])
start = mid + 1;
else
end = mid - 1;
}
if(end >= 0 && array[end] == k)
return end;
else
return -1;
}
}
法二：
public class Solution {
public int GetNumberOfK(int [] array , int k) {
return biSearch(array, k+0.5) - biSearch(array, k-0.5);
}
public int biSearch(int [] array, double k){
int start = 0, end = array.length - 1;
while(start <= end){
int mid = start + (end - start)/2;
if(array[mid] > k){
end = mid - 1;
}else{
start = mid + 1;
}
}
return start;
}
}
39. 二叉树的深度
题目描述:
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
解题思路:
法一：递归法。求二叉树的深度，就是求左子树、右子树的中深度最大的加上一个根节点，依此递归即可。
法二：层次遍历。每遍历一层，deep 加 1，直接到最后一层，输出 deep。
参考代码:
法一：递归法
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public int TreeDepth(TreeNode root) {
if(root == null)
return 0;
int left = TreeDepth(root.left) + 1;
int right = TreeDepth(root.right) + 1;
return left > right ? left : right;
}
}
法二：层次遍历
import java.util.Queue;
import java.util.LinkedList;
public class Solution {
public int TreeDepth(TreeNode root) {
if(root == null)
return 0;
int deep = 0;
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.offer(root);
int start = 0, end = 1;
while(!queue.isEmpty()){
TreeNode node = queue.poll();
start ++;
if(node.left != null){
queue.offer(node.left);
}
if(node.right != null){
queue.offer(node.right);
}
if(start == end){
end = queue.size();
start = 0;
deep ++;
}
}
return deep;
}
}
40. 数组中只出现一次的数字
题目描述:
一个整型数组里除了两个数字之外，其他的数字都出现了偶数次。请写程序找出这两个只出现一次的数字。
解题思路:
法一：大家都能想到的HashMap法
法二：异或法
任何一个数字异或它自己都等于0。
如果数组中只一个数字是只出现一次的，其他数字都是成双成对出现的，那么我们从头到尾依次异或数组中的每个数字，最终的结果刚好就是那个只出现一次的数字，因为那些成对出现两次的数字全部在异或中抵消了。
那么回到我们的题目，因为有两个只出现一次的数字，所以我们可以试着把原数组分成两个子数组，使得每个数组包含一个只出现一次的数字，而其他数字都成对出现两次。如果这样拆分成两个数组，那么我们就可以按照之前的办法分别对两个数组进行异或运算找出两个只出现一次的数字。
问题来了，如何进行分组呢？
我们还是从头到尾依次异或数组中的每个数字，那么最终得到的结果就是两个只出现一次的数字异或的结果。由于这两个数字不一样，所以异或的结果至少有一位为1，我们在结果数字中找到第一个为1的位置，记为index位，现在我们以第index位是不是1为标准把原数组拆分成两个子数组，第一个子数组中的数组第index位都为1，第二个子数组中的数组第index位都为0，那么只出现一次的数字将被分配到两个子数组中去，于是每个子数组中只包含一个出现一次的数字，而其他数字都出现两次。这样我们就可以用之前的方法找到数组中只出现一次的数字了。
参考代码:
法一：hashmap
import java.util.HashMap;
public class Solution {
public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
HashMap<Integer, Integer> temp = new HashMap<Integer, Integer>();
for(int i = 0; i < array.length; i++){
if(temp.containsKey(array[i]))
temp.remove(array[i]);
else
temp.put(array[i], 1);
}
int [] a = new int [array.length];
int i = 0;
for(Integer k: temp.keySet()){
a[i] = k;
i++;
}
num1[0] = a[0];
num2[0] = a[1];
}
}
法二：异或法
public class Solution {
public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
num1[0] = 0;
num2[0] = 0;
if(array.length == 0)
return;
int num = 0;
for(int i = 0; i < array.length; i++){
num ^= array[i];
}
int index = 0;
while((num & 1) == 0 && index < 8){
num = num >> 1;
index ++;
}
for(int i = 0; i < array.length; i++){
if(isa1(array[i], index))
num1[0] ^= array[i];
else
num2[0] ^= array[i];
}
}
public boolean isa1(int i, int index){
i = i >> index;
return (i & 1) == 1;
}
}
41. 和为S的两个数字
题目描述:
输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
解题思路:
法一：哈希法。用一个HashMap，它的 key 存储数S与数组中每个数的差，value 存储当前的数字，比较S=15, 当前的数为 4，则往 hashmap 中插入(key=11, value=4)。我们遍历数组，判断hashmap 中的 key 是否存在当前的数字，如果存在，说明存在着另一个数与当前的数相加和为 S，我们就可以判断它们的乘积是否小于之前的乘积，如果小的话就替换之前的找到的数字，如果大就放弃当前找到的。如果hashmap 中的 key 不存在当前的数字，说明还没有找到相加和为 S 的两个数，那就把S与当前数字的差作为 key，当前数字作为 value 插入到 hashmap 中，继续遍历。
法二：左右夹逼的方法。a+b=sum，a和b越远乘积越小，因为数组是递增排序，所以一头一尾两个指针往内靠近的方法找到的就是乘积最小的情况。
若ai + aj == sum，就是答案（相差越远乘积越小）
若ai + aj > sum，说明 aj 太大了，j —
若ai + aj < sum，说明 ai 太小了，i ++
参考代码:
import java.util.ArrayList;
import java.util.HashMap;
public class Solution {
public ArrayList<Integer> FindNumbersWithSum(int [] array,int sum) {
ArrayList<Integer> res = new ArrayList<Integer>();
if(array.length < 2)
return res;
HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
int less = Integer.MAX_VALUE;
for(int i = 0; i < array.length; i++){
if(map.containsKey(array[i])){
if(array[i] * map.get(array[i]) < less){
less = array[i] * map.get(array[i]);
res.clear();
res.add(map.get(array[i]));
res.add(array[i]);
}
}else{
int key = sum - array[i];
map.put(key, array[i]);
}
}
return res;
}
}
法二：左右夹逼
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> FindNumbersWithSum(int [] array,int sum) {
ArrayList<Integer> res = new ArrayList<Integer>();
if(array.length < 2)
return res;
int i = 0, j = array.length - 1;
while(i != j){
if(array[i] + array[j] == sum){
res.add(array[i]);
res.add(array[j]);
break;
}else if(array[i] + array[j] < sum){
i++;
}else{
j--;
}
}
return res;
}
}
和为S的连续正数序列
题目描述:
小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!
解题思路:
滑动窗口的方法：用两个数字 start 和 end 分别表示序列的最小值和最大值，首先将 start 初始化为1，end 初始化为2。如果从start到end的和大于sum，我们就从序列中去掉较小的值(即增大start),
相反，只需要增大end。
终止条件为：一直增加begin到(1+sum)/2并且end小于sum为止
参考代码:
import java.util.ArrayList;
public class Solution {
public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
ArrayList<ArrayList<Integer> > res = new ArrayList<ArrayList<Integer> >();
if(sum < 3)
return res;
int start = 1, end = 2, mid = (1+sum)/2;
while(start < mid){
int s = totalSum(start, end);
if(s == sum){
res.add(getSequence(start, end));
end ++;
}else if(s < sum){
end ++;
}else if(s > sum){
start ++;
}
}
return res;
}
public int totalSum(int start, int end){
int sum = 0;
for(int i = start; i <= end; i++){
sum += i;
}
return sum;
}
public ArrayList<Integer> getSequence(int start, int end){
ArrayList<Integer> temp = new ArrayList<>();
for(int i = start; i <= end; i++){
temp.add(i);
}
return temp;
}
}
42. 翻转单词顺序列
题目描述:
牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一翻转这些单词顺序可不在行，你能帮助他么？
解题思路:
很简单的题，也没啥好说的，注意一下测试用例为全是空格的情况：” ”
trim() : 去除字符串首尾空格
split() : 对字符串按照所传参数进行分割
参考代码:
public class Solution {
public String ReverseSentence(String str) {
if(str.trim().length() == 0)
return str;
String [] temp = str.split(" ");
String res = "";
for(int i = temp.length - 1; i >= 0; i--){
res += temp[i];
if(i != 0)
res += " ";
}
return res;
}
}
左旋转字符串
题目描述:
汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！
解题思路:
很简单的题，在第 n 个字符后面将切一刀，将字符串分为两部分，再重新并接起来即可。注意字符串长度为 0 的情况。
参考代码:
public class Solution {
public String LeftRotateString(String str,int n) {
int len = str.length();
if(len == 0)
return "";
n = n % len;
String s1 = str.substring(n, len);
String s2 = str.substring(0, n);
return s1+s2;
}
}
43.
44. 扑克牌顺子
题目描述:
LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张_)…他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子……LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。 现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何， 如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。
解题思路:
先统计王(0)的数量，再把牌排序，如果后面一个数比前面一个数大于1以上，那么中间的差值就必须用王来补了。看王的数量够不够，如果够就返回true，否则返回false。
参考代码:
import java.util.Arrays;
public class Solution {
public boolean isContinuous(int [] numbers) {
int zero = 0, dis = 0;
if(numbers.length != 5)
return false;
Arrays.sort(numbers);
for(int i = 0; i < 4; i++){
if(numbers[i] == 0){
zero ++;
continue;
}
if(numbers[i] == numbers[i+1])
return false;
if(numbers[i+1] - numbers[i] > 1){
dis += numbers[i+1] - numbers[i] - 1;
}
}
if(zero >= dis)
return true;
else
return false;
}
}
45. 孩子们的游戏(圆圈中最后剩下的数)
题目描述:
每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0…m-1报数….这样下去….直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!_)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)
解题思路:
用环形链表模拟圆圈。创建一个总共有 n 个结点的环形链表，然后每次在这个链表中删除第 m 个结点。注意，起步是-1 不是 0。
参考代码:
import java.util.LinkedList;
public class Solution {
public int LastRemaining_Solution(int n, int m) {
if(n < 1 || m < 1)
return -1;
LinkedList<Integer> link = new LinkedList<Integer>();
for(int i = 0; i < n; i++)
link.add(i);
int index = -1; //起步是 -1 不是 0
while(link.size() > 1){
index = (index + m) % link.size(); //对 link的长度求余不是对 n
link.remove(index);
index --;
}
return link.get(0);
}
}
46. 求1+2+3+…+n
题目描述:
求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
解题思路:
累加不能用循环的话，那就试试递归吧。
判断递归的终止条件不能用 if 和 switch，那就用短路与代替。
(n > 0) && (sum += Sum_Solution(n-1))>0
只有满足n > 0的条件，&&后面的表达式才会执行。
参考代码:
public class Solution {
public int Sum_Solution(int n) {
int sum = n;
boolean t = (n > 0) && (sum += Sum_Solution(n-1))>0;
return sum;
}
}
47. 不用加减乘除做加法
题目描述:
写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。
解题思路:
用位运算来实现。
step1: 进行异或运算，计算两个数各个位置上的相加，不考虑进位；
step2: 进行位与运算，然后左移一位，计算进位值；
step3: 把异或运算的结果赋给 num1，把进位值赋给 num2，依此循环，进位值为空的时候结束循环，num1就是两数之和。
参考代码:
public class Solution {
public int Add(int num1, int num2) {
if(num2 == 0)
return num1;
int sum = 0, carry = 0;
while(num2 != 0){
sum = num1 ^ num2;
carry = (num1 & num2) << 1;
num1 = sum;
num2 = carry;
}
return num1;
}
}
48. 把字符串转换成整数
题目描述:
将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能，但是string不符合数字要求时返回0)，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0。
解题思路:
常规思路，先判断第一位是不是符号位，如果有符号，有flag 做标记。
遍历字符串中的每个字符，如果存在非数字的字符，直接返回 0，否则，用当前字符减去’0’得到当前的数字，再进行运算。
参考代码:
public class Solution {
public int StrToInt(String str) {
if(str.length() == 0)
return 0;
int flag = 0;
if(str.charAt(0) == '+')
flag = 1;
else if(str.charAt(0) == '-')
flag = 2;
int start = flag > 0 ? 1 : 0;
long res = 0;
while(start < str.length()){
if(str.charAt(start) > '9' || str.charAt(start) < '0')
return 0;
res = res * 10 + (str.charAt(start) - '0');
start ++;
}
return flag == 2 ? -(int)res : (int)res;
}
}
49.
50.
51. 数组中重复的数字
题目描述:
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。
解题思路:
最简单的就是用一个数组或者哈希表来存储已经遍历过的数字，但是这样需要开辟额外的空间。
如果题目要求不能开辟额外的空间，那我们可以用如下的方法：
因为数组中的数字都在0~n-1的范围内，所以，如果数组中没有重复的数，那当数组排序后，数字i将出现在下标为i的位置。现在我们重排这个数组，从头到尾扫描每个数字，当扫描到下标为i的数字时，首先比较这个数字(记为m)是不是等于i。如果是，则接着扫描下一个数字；如果不是，则再拿它和m 位置上的数字进行比较，如果它们相等，就找到了一个重复的数字（该数字在下标为i和m的位置都出现了），返回true；如果它和m位置上的数字不相等，就把第i个数字和第m个数字交换，把m放到属于它的位置。接下来再继续循环，直到最后还没找到认为没找到重复元素，返回false。
参考代码:
public class Solution {
// Parameters:
// numbers: an array of integers
// length: the length of array numbers
// duplication: (Output) the duplicated number in the array number,length of duplication array is 1,so using duplication[0] = ? in implementation;
// Here duplication like pointor in C/C++, duplication[0] equal *duplication in C/C++
// 这里要特别注意~返回任意重复的一个，赋值duplication[0]
// Return value: true if the input is valid, and there are some duplications in the array number
// otherwise false
public boolean duplicate(int numbers[],int length,int [] duplication) {
if(length == 0)
return false;
for(int i = 0; i < length; i++){
while(i != numbers[i]){
if(numbers[i] == numbers[numbers[i]]){
duplication[0] = numbers[i];
return true;
}else{
int temp = numbers[numbers[i]];
numbers[numbers[i]] = numbers[i];
numbers[i] = temp;
}
}
}
return false;
}
}
52. 构建乘积数组
题目描述:
给定一个数组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]的值可以看作图中矩阵第 i 行所有元素的乘积。我们可以先算下三角中的连乘，即我们先算出B[i]中的一部分，然后倒过来按上三角中的分布规律，把另一部分也乘进去。
参考代码:
public class Solution {
public int[] multiply(int[] A) {
if(A.length <= 1)
return A;
int [] B = new int[A.length];
B[0] = 1;
for(int i = 1; i < A.length; i++){
B[i] = B[i-1] * A[i-1];
}
int temp = 1;
for(int j = A.length - 2; j>=0; j--){
temp *= A[j+1];
B[j] *= temp;
}
return B;
}
}
53. 正则表达式匹配
题目描述:
请实现一个函数用来匹配包括’.’和’’的正则表达式。模式中的字符’.’表示任意一个字符，而’’表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串”aaa”与模式”a.a”和”abaca”匹配，但是与”aa.a”和”ab*a”均不匹配
解题思路
当模式中的第二个字符不是“*”时：
1、如果字符串第一个字符和模式中的第一个字符相匹配，那么字符串和模式都后移一个字符，然后匹配剩余的。
2、如果 字符串第一个字符和模式中的第一个字符相不匹配，直接返回false。
而当模式中的第二个字符是“”时：
如果字符串第一个字符跟模式第一个字符不匹配，则模式后移2个字符，继续匹配。如果字符串第一个字符跟模式第一个字符匹配，可以有3种匹配方式：
1、模式后移2字符，相当于x被忽略；
2、字符串后移1字符，模式后移2字符；
3、字符串后移1字符，模式不变，即继续匹配字符下一位，因为*可以匹配多位。
参考代码:
public class Solution {
public boolean match(char[] str, char[] pattern)
{
int sindex = 0, pindex = 0;
return matchCore(str, sindex, pindex, pattern);
}
public boolean matchCore(char[] str, int sindex, int pindex, char[] pattern){
if(sindex >= str.length && pindex == pattern.length)
return true;
if(pindex >= pattern.length && sindex < str.length)
return false;
if(pindex+1 < pattern.length && pattern[pindex+1] == '*'){
if(sindex < str.length && (str[sindex] == pattern[pindex] || pattern[pindex] == '.') ){
return matchCore(str, sindex, pindex+2, pattern) ||
matchCore(str, sindex+1, pindex+2, pattern ) ||
matchCore(str, sindex+1, pindex, pattern);
}else{
return matchCore(str, sindex, pindex+2, pattern);
}
}
if(sindex < str.length && (str[sindex] == pattern[pindex] || pattern[pindex] == '.'))
return matchCore(str, sindex+1, pindex+1, pattern);
return false;
}
}
54. 表示数值的字符串
题目描述:
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串”+100″,”5e2″,”-123″,”3.1416″和”-1E-16″都表示数值。 但是”12e”,”1a3.14″,”1.2.3″,”±5″和”12e+4.3″都不是。
解题思路:
设置三个标志符分别记录“+/-”、“e/E”和“.”是否出现过。
对于“+/-”： 正常来看它们第一次出现的话应该出现在字符串的第一个位置，如果它第一次出现在不是字符串首位，而且它的前面也不是“e/E”，那就不符合规则；如果是第二次出现，那么它就应该出现在“e/E”的后面，如果“+/-”的前面不是“e/E”，那也不符合规则。
对于“e/E”： 如果它的后面不接任何数字，就不符合规则；如果出现多个“e/E”也不符合规则。
对于“.”： 出现多个“.”是不符合规则的。还有“e/E”的字符串出现“.”也是不符合规则的。
同时，要保证其他字符均为 0-9 之间的数字。
参考代码:
public class Solution {
public boolean isNumeric(char[] str) {
int len = str.length;
boolean sign = false, decimal = false, hasE = false;
for(int i = 0; i < len; i++){
if(str[i] == '+' || str[i] == '-'){
if(!sign && i > 0 && str[i-1] != 'e' && str[i-1] != 'E')
return false;
if(sign && str[i-1] != 'e' && str[i-1] != 'E')
return false;
sign = true;
}else if(str[i] == 'e' || str[i] == 'E'){
if(i == len - 1)
return false;
if(hasE)
return false;
hasE = true;
}else if(str[i] == '.'){
if(hasE || decimal)
return false;
decimal = true;
}else if(str[i] < '0' || str[i] > '9')
return false;
}
return true;
}
}
55. 字符流中第一个不重复的字符
题目描述:
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符”go”时，第一个只出现一次的字符是”g”。当从该字符流中读出前六个字符“google”时，第一个只出现一次的字符是”l”。
解题思路:
用一个哈希表来存储每个字符及其出现的次数，另外用一个字符串 s 来保存字符流中字符的顺序。
每次插入的时候，在字符串 s 中插入该字符，然后在哈希表中查看是否存在该字符，如果存在则它的 value 加1，如果不存在，它在哈希表中插入该字符，它的 value 为 1。
查找第一个只出现一次的字符时，按照 s 的顺序，依次查找 map 中字符出现的次数，当 value 为 1 时，该字符就是第一个只出现一次的字符。
参考代码:
import java.util.HashMap;
public class Solution {
HashMap<Character, Integer> map = new HashMap<Character, Integer>();
StringBuffer s = new StringBuffer();
//Insert one char from stringstream
public void Insert(char ch)
{
s.append(ch);
if(map.containsKey(ch)){
map.put(ch, map.get(ch)+1);
}else{
map.put(ch, 1);
}
}
//return the first appearence once char in current stringstream
public char FirstAppearingOnce()
{
for(int i = 0; i < s.length(); i++){
if(map.get(s.charAt(i)) == 1)
return s.charAt(i);
}
return '#';
}
}
56. 链表中环的入口结点
题目描述:
给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。
解题思路:
一种方法是用 hashmap来存储和查找节点;
另一种方法是双指针法。
假设环长度为n，进入环之前结点个数为x,slow在环内走了k个结点,fast绕环走了m圈,则有2(x+k)=x+mn+k 可以得出x = mn - k。此时slow距入口结点还剩 n-k个结点,x=(m−1)n+n−k，即一个指针从链表头节点走到环入口的长度等于另一个指针从相遇的位置走 m-1圈后再走n-k的长度，也就是说两个指针相遇后，让一个指针回到头节点，另一个指针不动，然后他们同时往前每次走一步，当他们相遇时，相遇的节点即为环入口节点。
所以，我们设置两个指针，一个是快指针fast，一个是慢指针slow，fast一次走两步，slow一次走一步，如果单链表有环那么当两个指针相遇时一定在环内。此时将一个指针指到链表头部，另一个不变，二者同时每次向前移一格,当两个指针再次相遇时即为环的入口节点。如果fast走到null则无环。
参考代码:
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public ListNode EntryNodeOfLoop(ListNode pHead)
{
if(pHead.next == null || pHead.next.next == null)
return null;
ListNode slow = pHead.next;
ListNode fast = pHead.next.next;
while(fast != null){
if(fast == slow){
fast = pHead;
while(fast != slow){
fast = fast.next;
slow = slow.next;
}
return fast;
}
slow = slow.next;
fast = fast.next.next;
}
return null;
}
}
57. 删除链表中重复的结点
题目描述:
在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
解题思路:
首先添加一个头节点，以方便碰到第一个，第二个节点就相同的情况
设置 first ，second 指针， first 指针指向当前确定不重复的那个节点，而second指针相当于工作指针，一直往后面搜索。
 {
this.val = val;
}
}
*/
public class Solution {
public ListNode deleteDuplication(ListNode pHead)
{
if(pHead == null || pHead.next == null)
return pHead;
ListNode head = new ListNode(-1);
head.next = pHead;
ListNode first = head;
ListNode second = first.next;
while(second != null){
if(second.next != null && second.val == second.next.val){
while(second.next != null && second.val == second.next.val){
second = second.next;
}
first.next = second.next;
}else{
first = first.next;
}
second = second.next;
}
return head.next;
}
}
58. 二叉树的下一个结点
题目描述:
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
解题思路:
中序遍历：左 -> 根 -> 右
分三种情况：
如果当前节点为空，直接返回空；
如果当前节点有右子树，则返回右子树的最左子树；
如果当前节点没有右子树，再分两种情况：
看看当前节点是不是它的父节点的左子树，如果是，则返回它的父节点；
如果当前节点不是它的父节点的左子树，则把父节点赋给当前节点，再判断当前节点是不是它的父节点的左子树，直到当前节点是不是它的父节点的左子树，返回它的父节点。
参考代码:
/*
public class TreeLinkNode {
int val;
TreeLinkNode left = null;
TreeLinkNode right = null;
TreeLinkNode next = null;
TreeLinkNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public TreeLinkNode GetNext(TreeLinkNode pNode)
{
if(pNode == null){
return null;
}
if(pNode.right != null){
TreeLinkNode node = pNode.right;
while(node.left != null){
node = node.left;
}
return node;
}
while(pNode.next != null){
TreeLinkNode root = pNode.next;
if(pNode == root.left)
return root;
pNode = root;
}
return null;
}
}
59. 对称的二叉树
题目描述:
请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
解题思路:
法一：递归。根节点的左右子树相同，左子树的左子树和右子树的右子树相同，左子树的右子树和右子树的左子树相同即可。
法二：非递归。非递归也是一样，采用栈或队列存取各级子树根节点。
参考代码:
法一：递归。
/*
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
boolean isSymmetrical(TreeNode pRoot)
{
if(pRoot == null)
return true;
return isSymmetrical(pRoot.left, pRoot.right);
}
boolean isSymmetrical(TreeNode left, TreeNode right){
if(left == null && right == null)
return true;
if(left == null || right == null)
return false;
if(left.val == right.val){
return isSymmetrical(left.left, right.right) &&
isSymmetrical(left.right, right.left);
}
return false;
}
}
法二：非递归。
import java.util.Stack;
public class Solution {
boolean isSymmetrical(TreeNode pRoot)
{
if(pRoot == null)
return true;
Stack<TreeNode> s = new Stack<TreeNode>();
s.push(pRoot.left);
s.push(pRoot.right);
while(!s.isEmpty()){
TreeNode right = s.pop();
TreeNode left = s.pop();
if(right == null && left == null)
continue;
if(right == null || left == null)
return false;
if(right.val != left.val)
return false;
s.push(left.left);
s.push(right.right);
s.push(left.right);
s.push(right.left);
}
return true;
}
}
60. 按之字形顺序打印二叉树
题目描述:
请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
解题思路:
设两个栈，s2存放奇数层，s1存放偶数层
遍历s2节点的同时按照左子树、右子树的顺序加入s1，
遍历s1节点的同时按照右子树、左子树的顺序加入s2
参考代码:
import java.util.ArrayList;
import java.util.Stack;
/*
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
ArrayList<ArrayList<Integer> > res = new ArrayList<ArrayList<Integer> >();
Stack<TreeNode> s1 = new Stack<TreeNode>();
Stack<TreeNode> s2 = new Stack<TreeNode>();
int flag = 1;
if(pRoot == null)
return res;
s2.push(pRoot);
ArrayList<Integer> temp = new ArrayList<Integer>();
while(!s1.isEmpty() || !s2.isEmpty()){
if(flag % 2 != 0){
while(!s2.isEmpty()){
TreeNode node = s2.pop();
temp.add(node.val);
if(node.left != null){
s1.push(node.left);
}
if(node.right != null){
s1.push(node.right);
}
}
}
if(flag % 2 == 0){
while(!s1.isEmpty()){
TreeNode node = s1.pop();
temp.add(node.val);
if(node.right != null){
s2.push(node.right);
}
if(node.left != null){
s2.push(node.left);
}
}
}
res.add(new ArrayList<Integer>(temp));
temp.clear();
flag ++;
}
return res;
}
}
61. 把二叉树打印成多行
题目描述:
从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
解题思路:
就是二叉树的层序遍历，用队列来实现。我们需要两个变量，一个start记录当前层已经打印的节点个数，一个end记录前当层所有的节点个数，当 start == end 时，表时当前层遍历完了，就可以开始下一层遍历。
参考代码:
import java.util.ArrayList;
import java.util.Queue;
import java.util.LinkedList;
/*
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
ArrayList<ArrayList<Integer> > res = new ArrayList<ArrayList<Integer> >();
if(pRoot == null)
return res;
ArrayList<Integer> temp = new ArrayList<Integer>();
Queue<TreeNode> layer = new LinkedList<TreeNode>();
layer.offer(pRoot);
int start = 0, end = 1;
while(!layer.isEmpty()){
TreeNode node = layer.poll();
temp.add(node.val);
start ++;
if(node.left != null)
layer.add(node.left);
if(node.right != null)
layer.add(node.right);
if(start == end){
start = 0;
res.add(temp);
temp = new ArrayList<Integer>();
end = layer.size();
}
}
return res;
}
}
62. 序列化二叉树
题目描述:
请实现两个函数，分别用来序列化和反序列化二叉树
解题思路:
对于序列化：使用前序遍历，递归的将二叉树的值转化为字符，并且在每次二叉树的结点不为空时，在转化val所得的字符之后添加一个’,’作为分割; 对于空节点则以 ‘#,’ 代替。
对于反序列化：将字符串按照“，”进行分割，插入到队列中，然后依次从队列中取出字符建立节点，递归创建一个二叉树。
参考代码:
/*
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
import java.util.Queue;
import java.util.LinkedList;
public class Solution {
String Serialize(TreeNode root) {
if(root == null){
return "#,";
}
StringBuffer res = new StringBuffer(root.val + ",");
res.append(Serialize(root.left));
res.append(Serialize(root.right));
return res.toString();
}
TreeNode Deserialize(String str) {
String [] res = str.split(",");
Queue<String> queue = new LinkedList<String>();
for(int i = 0; i < res.length; i++){
queue.offer(res[i]);
}
return pre(queue);
}
TreeNode pre(Queue<String> queue){
String val = queue.poll();
if(val.equals("#"))
return null;
TreeNode node = new TreeNode(Integer.parseInt(val));
node.left = pre(queue);
node.right = pre(queue);
return node;
}
}
63. 二叉搜索树的第k个结点
题目描述:
给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8）中，按结点数值大小顺序第三小结点的值为4。
解题思路:
因为二叉搜索树按照中序遍历的顺序打印出来就是排好序的，所以，我们按照中序遍历找到第k个结点就是题目所求的结点。
参考代码:
/*
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
int index = 0;
TreeNode KthNode(TreeNode pRoot, int k)
{
if(pRoot != null){
TreeNode node = KthNode(pRoot.left, k);
if(node != null)
return node;
index ++;
if(index == k)
return pRoot;
node = KthNode(pRoot.right, k);
if(node != null)
return node;
}
return null;
}
}
64. 数据流中的中位数
题目描述:
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。
解题思路:
我们可以将数据排序后分为两部分，左边部分的数据总是比右边的数据小。那么，我们就可以用最大堆和最小堆来装载这些数据：
最大堆装左边的数据，取出堆顶（最大的数）的时间复杂度是O(1)
最小堆装右边的数据，同样，取出堆顶（最小的数）的时间复杂度是O(1)
从数据流中拿到一个数后，先按顺序插入堆中：如果左边的最大堆是否为空或者该数小于等于最大堆顶的数，则把它插入最大堆，否则插入最小堆。然后，我们要保证左边的最大堆的size等于右边的最小堆的size或者最大堆的size比最小堆的size大1。
要获取中位数的话，直接判断最大堆和最小堆的size，如果相等，则分别取出两个堆的堆顶除以2得到中位数，不然，就是最大堆的size要比最小堆的size大，这时直接取出最大堆的堆顶就是我们要的中位数。
参考代码:
import java.util.PriorityQueue;
import java.util.Comparator;
public class Solution {
// 最小堆（右）
private PriorityQueue<Integer> rHeap = new PriorityQueue<>();
// 最大堆（左）
private PriorityQueue<Integer> lHeap = new PriorityQueue<Integer>(15, new Comparator<Integer>() {
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
// 保证lHeap.size()>=rHeap.size()
public void Insert(Integer num) {
// 先按大小插入，再调整
if(lHeap.isEmpty() || num <= lHeap.peek())
lHeap.offer(num);
else
rHeap.offer(num);
if(lHeap.size() < rHeap.size()){
lHeap.offer(rHeap.peek());
rHeap.poll();
}else if(lHeap.size() - rHeap.size() == 2){
rHeap.offer(lHeap.peek());
lHeap.poll();
}
}
public Double GetMedian() {
if(lHeap.size() > rHeap.size())
return new Double(lHeap.peek());
else
return new Double(lHeap.peek() + rHeap.peek())/2;
}
}
65. 滑动窗口的最大值
题目描述:
给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{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]}。
解题思路:
法一：简单的暴力法
法二：双向队列
用一个双向队列，队列第一个位置保存当前窗口的最大值，当窗口滑动一次，判断当前最大值是否过期（当前最大值的位置是不是在窗口之外），新增加的值从队尾开始比较，把所有比他小的值丢掉。这样时间复杂度为O(n)。
参考代码:
法一：简单的暴力法
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> maxInWindows(int [] num, int size)
{
ArrayList<Integer> res = new ArrayList<Integer>();
if(num.length < size || size == 0)
return res;
for(int i = 0; i < num.length - size + 1; i++){
res.add(max(num, i, size));
}
return res;
}
public int max(int [] num, int index, int size){
int res = num[index];
for(int i = index + 1; i < index + size; i++){
if(num[i] > res)
res = num[i];
}
return res;
}
}
法二：双向队列
import java.util.ArrayList;
import java.util.LinkedList;
public class Solution {
public ArrayList<Integer> maxInWindows(int [] num, int size){
ArrayList<Integer> res = new ArrayList<Integer>();
LinkedList<Integer> deque = new LinkedList<Integer>();
if(num.length == 0 || size == 0)
return res;
for(int i = 0; i < num.length; i++){
if(!deque.isEmpty() && deque.peekFirst() <= i - size)
deque.poll();
while(!deque.isEmpty() && num[deque.peekLast()] < num[i])
deque.removeLast();
deque.offerLast(i);
if(i + 1 >= size)
res.add(num[deque.peekFirst()]);
}
return res;
}
}
66. 矩阵中的路径
题目描述:
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。 例如 a b c e s f c s a d e e 这样的3 X 4 矩阵中包含一条字符串”bcced”的路径，但是矩阵中不包含”abcb”路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。
解题思路:
回溯法：
- 将matrix字符串映射为一个字符矩阵（index = i * cols + j）
- 遍历matrix的每个坐标，与str的首个字符对比，如果相同，用flag做标记，matrix的坐标分别上、下、左、右、移动（判断是否出界或者之前已经走过[flag的坐标为1]），再和str的下一个坐标相比，直到str全部对比完，即找到路径，否则找不到。
**参考代码:
public class Solution {
public boolean hasPath(char[] matrix, int rows, int cols, char[] str)
{
if(matrix.length == 0 || str.length == 0)
return false;
int [][] flag = new int[rows][cols];
for(int i = 0; i < rows; i++){
for(int j = 0; j < cols; j++){
if(search(matrix, rows, cols, i, j, str, 0, flag))
return true;
}
}
return false;
}
public boolean search(char[] matrix, int rows, int cols,
int i, int j, char[] str, int index, int[][] flag){
int m_i = i * cols + j;
if(i<0 || j<0 || i >= rows || j>=cols || flag[i][j] == 1 || matrix[m_i] != str[index])
return false;
if(index >= str.length - 1)
return true;
flag[i][j] = 1;
if(search(matrix, rows, cols, i+1, j, str, index+1, flag) ||
search(matrix, rows, cols, i-1, j, str, index+1, flag) ||
search(matrix, rows, cols, i, j+1, str, index+1, flag) ||
search(matrix, rows, cols, i, j-1, str, index+1, flag))
return true;
flag[i][j] = 0;
return false;
}
}
67. 机器人的运动范围
题目描述:
地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？
解题思路:
回溯法：从(0,0)开始走，每成功走一步用一个flag数组标记当前位置为1，然后从当前位置往四个方向探索，
返回1 + 4 个方向的探索值之和。
参考代码:
public class Solution {
public int movingCount(int threshold, int rows, int cols)
{
if(threshold == 0)
return 0;
int flag[][] = new int[rows][cols];
return count(threshold, rows, cols, 0, 0, flag);
}
public int count(int threshold, int rows, int cols, int i, int j, int[][] flag){
if(i<0 || j<0 || i>=rows || j>=cols || sum(i)+sum(j) > threshold || flag[i][j] == 1){
return 0;
}
flag[i][j] = 1;
return 1 + count(threshold, rows, cols, i - 1, j, flag) +
count(threshold, rows, cols, i + 1, j, flag) +
count(threshold, rows, cols, i, j - 1, flag) +
count(threshold, rows, cols, i, j + 1, flag);
}
public int sum(int i){
int s = 0;
while(i>0){
s += i%10;
i /= 10;
}
return s;
}
}
[算法总结] 12. 二分查找
二分查找法作为一种常见的查找方法，将原本是线性时间提升到了对数时间范围，大大缩短了搜索时间，但它有一个前提，就是必须在有序数据中进行查找。
二分查找很好写，却很难写对，据统计只有10%的程序员可以写出没有bug的的二分查找代码。出错原因主要集中在判定条件和边界值的选择上，很容易就会导致越界或者死循环的情况。
下面对二分查找及其变形进行总结：
1. 最基本的二分查找:
public int binarySearch(int[] A, int target, int n){
int low = 0, high = n, mid;
while(low <= high){
mid = low + (high - low) / 2;
if(A[mid] == target){
return mid;
}else if(A[mid] > target){
high = mid - 1;
}else{
low = mid + 1;
}
}
return -1;
}
其中，有几个要注意的点：
- 循环的判定条件是：low <= high
- 为了防止数值溢出，mid = low + (high - low)/2
- 当 A[mid]不等于target时，high = mid - 1或low = mid + 1
leetcode参考：Search Insert Position
- 查找目标值区域的左边界/查找与目标值相等的第一个位置/查找第一个不小于目标值数的位置
A = [1,3,3,5, 7 ,7,7,7,8,14,14]
target = 7
return 4
public int binarySearchLowerBound(int[] A, int target, int n){
int low = 0, high = n, mid;
while(low <= high){
mid = low + (high - low) / 2;
if(target <= A[mid]){
high = mid - 1;
}else{
low = mid + 1;
}
}
if(low < A.length && A[low] == target)
return low;
else
return -1;
}
- 查找目标值区域的右边界/查找与目标值相等的最后一个位置/查找最后一个不大于目标值数的位置
A = [1,3,3,5,7,7,7, 7 ,8,14,14]
target = 7
return 7
public int binarySearchUpperBound(int[] A, int target, int n){
int low = 0, high = n, mid;
while(low <= high){
mid = low + (high - low) / 2;
if(target >= A[mid]){
low = mid + 1;
}else{
high = mid - 1;
}
}
if(high >= 0 && A[high] == target)
return high;
else
return -1;
}
此题以可变形为查找第一个大于目标值的数/查找比目标值大但是最接近目标值的数，我们已经找到了最后一个不大于目标值的数，那么再往后进一位，返回high + 1，就是第一个大于目标值的数。
剑指offer：数字在排序数组中出现的次数
- 查找最后一个小于目标值的数/查找比目标值小但是最接近目标值的数
此题以可由第 2 题变形而来，我们已经找到了目标值区域的下（左）边界，那么再往左退一位，即low - 1，就是最后一个小于目标值的数。其实low - 1也是退出循环后high的值，因为此时 high刚好等于low - 1，它小于low，所以 while 循环结束。我们只要判断high是否超出边界即可。
A = [1,3,3, 5 ,7,7,7,7,8,14,14]
target = 7
return 3
int low = 0, high = n, mid;
while(low <= high){
mid = low + (high - low) / 2;
if(target <= A[mid]){
high = mid - 1;
}else{
low = mid + 1;
}
}
return high < 0 ? -1 : high;
- 查找第一个大于目标值的数/查找比目标值大但是最接近目标值的数
此题以可由第 3 题变形而来，我们已经找到了目标值区域的上（右）边界，那么再往右进一位，即high + 1，就是第一个大于目标值的数。其实high + 1也是退出循环后low的值，因为此时 low刚好等于high + 1，它大于high，所以 while 循环结束。我们只要判断low是否超出边界即可。
A = [1,3,3,5,7,7,7,7, 8 ,14,14]
target = 7
return 8
int low = 0, high = n, mid;
while(low <= high){
mid = low + (high - low) / 2;
if(target >= A[mid]){
low = mid + 1;
}else{
high = mid - 1;
}
}
return low > n ? -1 : low;
- 旋转数组返回最小元素
6.1 查找旋转数组的最小元素（假设不存在重复数字）
LeetCode: Find Minimum in Rotated Sorted Array
Input: [3,4,5,1,2]
Output: 1
public int findMin(int[] nums) {
int len = nums.length;
if(len == 0)
return -1;
int left = 0, right = len - 1, mid;
while(left < right){
mid = left + (right - left) / 2;
if(nums[mid] > nums[right])
left = mid + 1;
else{
right = mid;
}
}
return nums[left];
}
注意这里和之前的二分查找的几点区别：
- 循环判定条件为left < right，没有等于号
- 循环中，通过比较nums[left]与num[mid]的值来判断mid所在的位置:
如果nums[mid] > nums[right]，说明前半部分是有序的，最小值在后半部分，令left = mid + 1；
如果nums[mid] <= num[right]，说明最小值在前半部分，令right = mid。
最后，left会指向最小值元素所在的位置。
6.2 查找旋转数组的最小元素（存在重复项）
LeetCode: Find Minimum in Rotated Sorted Array II
剑指offer：旋转数组的最小数字
Input: [2,2,2,0,1]
Output: 0
public int findMin(int[] nums) {
int len = nums.length;
if(len == 0)
return -1;
int left = 0, right = len - 1, mid;
while(left < right){
mid = left + (right - left) / 2;
if(nums[mid] > nums[right])
left = mid + 1;
else if(nums[mid] < nums[right])
right = mid;
else
right--;
}
return nums[left];
}
和之前不存在重复项的差别是：当nums[mid] == nums[right]时，我们不能确定最小值在 mid的左边还是右边，所以我们就让右边界减一。
7. 在旋转排序数组中搜索
7.1 不考虑重复项
LeetCode: Search in Rotated Sorted Array
法一：
先利用方法 6.1 查找数组中的最小元素，即确定分界点的位置
把旋转的数组当成偏移，用(offset + mid) % len来求真实的 mid 的位置。
然后用二分查找来定位目标值
public int search(int[] nums, int target) {
int len = nums.length;
if(len == 0)
return -1;
int left = 0, right = len - 1, mid;
while(left < right){
mid = left + (right - left) / 2;
if(nums[mid] > nums[right])
left = mid + 1;
else
right = mid;
}
int offset = left;
left = 0;
right = len - 1;
while(left <= right){
mid = left + (right - left) / 2;
int realmid = (mid + offset) % len;
if(nums[realmid] == target)
return realmid;
else if(nums[realmid] < target)
left = mid + 1;
else
right = mid - 1;
}
return -1;
}
法二：其实没有必要找到旋转数组的分界点，对于搜索左侧还是右侧我们是可以根据mid跟high的元素大小来判定出来的，直接根据target的值做二分搜索就可以了。
public int search(int[] nums, int target) {
int len = nums.length;
if(len == 0)
return -1;
int left = 0, right = len - 1, mid;
while(left <= right){
mid = left + (right - left) / 2;
if(nums[mid] == target)
return mid;
else if(nums[left] <= nums[mid]){
if(target < nums[mid] && target >= nums[left])
right = mid - 1;
else
left = mid + 1;
}else if(nums[mid] <= nums[right]){
if(target > nums[mid] && target <= nums[right])
left = mid + 1;
else
right = mid - 1;
}
}
return -1;
}
7.2 存在重复项
LeetCode: Search in Rotated Sorted Array II
public boolean search(int[] nums, int target) {
int len = nums.length;
if(len == 0)
return false;
int left = 0, right = len - 1, mid;
while(left <= right){
mid = left + (right - left) / 2;
if(nums[mid] == target)
return true;
else if(nums[mid] > nums[right]){
if(target < nums[mid] && target >= nums[left])
right = mid;
else
left = mid + 1;
}else if(nums[mid] < nums[right]){
if(target > nums[mid] && target <= nums[right])
left = mid + 1;
else
right = mid;
}else{
right --;
}
}
return false;
}
8. 二维数组中的查找
剑指offer：二维数组中的查找
二维数组是有序的，从右上角来看，向左数字递减，向下数字递增。因此可以利用二分查找的思想，从右上角出发：
当要查找数字比右上角数字大时，下移；
当要查找数字比右上角数字小时，左移；