剑指offer题目汇总及解答
文章目录
- 1.二维数组中的查找
- 2.替换空格
- 3.从尾到头打印链表
- 4.重建二叉树
- 5.用两个栈实现队列
- 6.旋转数组的最小数字
- 7.斐波那契数列
- 8.跳台阶
- 9.变态跳台阶
- 10.矩形覆盖
- 11.二进制中 1 的个数
- 12.数值的整数次方
- 13.调整数组顺序使奇数位于偶数前面
- 14.链表中倒数第k个结点
- 15.反转链表
- 16.合并两个排序的链表
- 17.树的子结构
- 18.二叉树的镜像
- 19.顺时针打印矩阵
- 20.包含min函数的栈
- 21.栈的压入、弹出序列
- 22.从上往下打印二叉树
- 23.二叉搜索树的后序遍历序列
- 24.二叉树中和为某一值的路径
- 25.复杂链表的复制
- 26.二叉搜索树与双向链表
- 27.字符串的排列
- 28.数组中出现次数超过一半的数字
- 29.最小的K个数
- 30.连续子数组的最大和
- 31.整数中1出现的次数（从1到n整数中1出现的次数）
- 32.把数组排成最小的数
- 33.丑数
- 34.第一个只出现一次的字符
- 35.数组中的逆序对
- 36.两个链表的第一个公共结点
- 37.
- 38.
- 39.
- 40.
- 41.
- 42.
- 43.
- 44.
- 45.
- 46.
- 47.
- 48.
- 49.
- 50.数组中重复的数字
- 51.
- 52.
- 53.
- 54.
- 55.
- 56.
- 57.二叉树的下一个结点
- 58.
- 59.
- 60.
- 61.
- 62.
- 63.
- 64.
- 65.矩阵中的路径 *
- 66.机器人的运动范围 *
1.二维数组中的查找
题目链接
题目描述
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
解题思路
该二维数组中的一个数，小于它的数一定在其左边，大于它的数一定在其下边。因此，从右上角开始查找，就可以根据 target 和当前元素的大小关系来缩小查找区间，当前元素的查找区间为左下角的所有元素。
解答代码
public class Solution {
public static void main(String[] args) {
int[][] array = {{1,4,7},{2,5,6},{3,6,9}};
System.out.println(Find(6,array));
}
public static boolean Find(int target, int [][] matrix) {
if (matrix == null || matrix.length <= 0 || matrix[0].length <= 0){
return false;
}
int row = matrix.length;
int col = matrix[0].length;
int r = 0;
int c = col - 1;
while(r < row && c >= 0){
if (target == matrix[r][c]){
return true;
}else if (target < matrix[r][c]){
c --;
}else{
r ++;
}
}
return false;
}
}
2.替换空格
题目链接
题目描述
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
解题思路
首先遍历字符串，当字符为空格时，在字符串尾部拼接两个字符（因为从' '变成'%20'要多两个字符长度），定义旧字符串的长度oldCount和新长度newCount，可以想到在我们完成替换后，oldCount应该是等于newCount的，所以while条件可以确定，具体解答如下：
解答代码
public class Solution {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("we are superman");
System.out.println(new Solution().replaceSpace(sb));
}
public String replaceSpace(StringBuffer str) {
int oldCount = str.length() - 1;
for (int i = 0 ; i <= oldCount ; i ++){
if (str.charAt(i) == ' '){
str.append(" ");
}
}
int newCount = str.length() - 1;
while (oldCount >= 0 && newCount >= oldCount){
if (str.charAt(oldCount) == ' '){
str.setCharAt(newCount--,'0');
str.setCharAt(newCount--,'2');
str.setCharAt(newCount--,'%');
}else{
str.setCharAt(newCount--, str.charAt(oldCount));
}
oldCount --;
}
return str.toString();
}
}
3.从尾到头打印链表
题目链接
题目描述
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
解题思路
将链表里的值存放在一个列表中，再将列表反转输出
解答代码
/**
* public class ListNode {
* int val;
* ListNode next = null;
*
* ListNode(int val) {
* this.val = val;
* }
* }
*
*/
import java.util.ArrayList;
public class Solution {
public static void main(String[] args) {
ListNode listNode = new ListNode(1);
ListNode listNode1 = new ListNode(2);
ListNode listNode2 = new ListNode(3);
listNode.next = listNode1;
listNode1.next = listNode2;
ArrayList<Integer> array = new Solution().printListFromTailToHead(listNode);
for (int i = 0 ; i < array.size() ; i ++)
System.out.println(array.get(i));
}
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
ArrayList<Integer> arrayList = new ArrayList<>();
ArrayList<Integer> array = new ArrayList<>();
while (listNode != null){
arrayList.add(listNode.val);
listNode = listNode.next;
}
for (int index = arrayList.size() - 1 ; index >=0 ; index --){
array.add(arrayList.get(index));
}
return array;
}
}
class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
使用栈
栈具有后进先出的特点，在遍历链表时将值按顺序放入栈中，最后出栈的顺序即为逆序。
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
Stack<Integer> stack = new Stack<>();
while (listNode != null) {
stack.add(listNode.val);
listNode = listNode.next;
}
ArrayList<Integer> ret = new ArrayList<>();
while (!stack.isEmpty())
ret.add(stack.pop());
return ret;
}
4.重建二叉树
题目链接
题目描述
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
解题思路
前序遍历的第一个值为根节点的值，使用这个值将中序遍历结果分成两部分，左部分为树的左子树中序遍历结果，右部分为树的右子树中序遍历的结果。
解答代码
import java.util.HashMap;
import java.util.Map;
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public static void main(String[] args) {
}
// 缓存中序遍历数组每个值对应的索引
private Map<Integer, Integer> indexForInOrders = new HashMap<>();
public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
for (int i = 0; i < in.length; i++)
indexForInOrders.put(in[i], i);
return reConstructBinaryTree(pre, 0, pre.length - 1, 0);
}
private TreeNode reConstructBinaryTree(int[] pre, int preL, int preR, int inL) {
if (preL > preR)
return null;
TreeNode root = new TreeNode(pre[preL]);
int inIndex = indexForInOrders.get(root.val);
int leftTreeSize = inIndex - inL;
root.left = reConstructBinaryTree(pre, preL + 1, preL + leftTreeSize, inL);
root.right = reConstructBinaryTree(pre, preL + leftTreeSize + 1, preR, inL + leftTreeSize + 1);
return root;
}
}
class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
5.用两个栈实现队列
题目链接
题目描述
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
解题思路
stack1 栈用来处理入栈（push）操作，stack2 栈用来处理出栈（pop）操作。一个元素进入 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() throws Exception{
if (stack2.isEmpty()){
while (!stack1.isEmpty()){
stack2.push(stack1.pop());
}
}
if (stack2.isEmpty()){
throw new Exception("queue is empty");
}
return stack2.pop();
}
}
6.旋转数组的最小数字
题目链接
题目描述
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
解题思路
注意输入的是一个已经旋转过的，若是没有旋转过输出第一个值，因为是非递减（递增）数组，如果旋转过，遍历时很容易找到
解答代码
import java.util.ArrayList;
/**
* 注意输入的是一个已经旋转过的，若是没有旋转过输出第一个值，因为是非递减（递增）数组，如果旋转过，遍历时很容易找到
*/
public class Solution {
public int minNumberInRotateArray(int [] array) {
if(array.length==0){
return 0;
}
if(array.length==1){
return array[0];
}
for(int i=0;i<array.length-1;i++){
// 前面的值大于后面的值，说明找到了反转的地方
if(array[i]>array[i+1]){
return array[i+1];
}else{
// 比对了倒数第二个值和最后一个值后说明没有反转，输出第一个值
if(i==array.length-2){
return array[0];
}
}
}
return 0;
}
}
7.斐波那契数列
题目链接
题目描述
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
n<=39
解题思路
斐波那契的值除了第一个和第二个数值外，其他的均为前两个数值的和。
解答代码
public class Solution {
public int Fibonacci(int n) {
int a = 1,b=1,c=0;
if (n <= 0){
return 0;
}else if (n == 1 || n == 2){
return 1;
}else{
for (int i = 3 ; i <= n ; i ++){
c = a + b;
a = b;
b = c;
}
return c;
}
}
}
8.跳台阶
题目链接
题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
解题思路
当 n = 1 时，只有一种跳法：
当 n = 2 时，有两种跳法：
跳 n 阶台阶，可以先跳 1 阶台阶，再跳 n-1 阶台阶；或者先跳 2 阶台阶，再跳 n-2 阶台阶。而 n-1 和 n-2 阶台阶的跳法可以看成子问题，该问题的递推公式为：
解答代码
public class Solution {
public int JumpFloor(int n) {
if (n <= 2)
return n;
int pre2 = 1, pre1 = 2;
int result = 1;
for (int i = 2; i < n; i++) {
result = pre2 + pre1;
pre2 = pre1;
pre1 = result;
}
return result;
}
}
9.变态跳台阶
题目链接
题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
解题思路
动态规划
import java.util.Arrays;
public class Solution {
public int JumpFloorII(int target) {
int[] dp = new int[target];
Arrays.fill(dp, 1);
for (int i = 1; i < target; i++)
for (int j = 0; j < i; j++)
dp[i] += dp[j];
return dp[target - 1];
}
}
数学推导：
跳上 n-1 级台阶，可以从 n-2 级跳 1 级上去，也可以从 n-3 级跳 2 级上去…，那么
f(n-1) = f(n-2) + f(n-3) + … + f(0)
同样，跳上 n 级台阶，可以从 n-1 级跳 1 级上去，也可以从 n-2 级跳 2 级上去… ，那么
f(n) = f(n-1) + f(n-2) + … + f(0)
综上可得
f(n) - f(n-1) = f(n-1)
即
f(n) = 2*f(n-1)
所以 f(n) 是一个等比数列
public int JumpFloorII(int target) {
return (int) Math.pow(2, target - 1);
}
10.矩形覆盖
题目链接
题目描述
我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
解题思路
当 n 为 1 时，只有一种覆盖方法：
当 n 为 2 时，有两种覆盖方法：
要覆盖 2n 的大矩形，可以先覆盖 21 的矩形，再覆盖 2*(n-1) 的矩形；或者先覆盖 22 的矩形，再覆盖 2(n-2) 的矩形。而覆盖 2*(n-1) 和 2*(n-2) 的矩形可以看成子问题。该问题的递推公式如下：
解答代码
public class Solution {
public int RectCover(int n) {
if (n <= 2)
return n;
int pre2 = 1, pre1 = 2;
int result = 0;
for (int i = 3; i <= n; i++) {
result = pre2 + pre1;
pre2 = pre1;
pre1 = result;
}
return result;
}
}
11.二进制中 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++;
n = n & (n - 1);
}
return count;
}
}
12.数值的整数次方
题目链接
题目描述
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
解题思路
下面的讨论中 x 代表 base，n 代表 exponent。
因为 (x*x)n/2 可以通过递归求解，并且每次递归 n 都减小一半，因此整个算法的时间复杂度为 O(logN)。
解答代码
public class Solution {
public double Power(double base, int exponent) {
if (exponent == 0)
return 1;
if (exponent == 1)
return base;
boolean isNegative = false;
if (exponent < 0) {
exponent = -exponent;
isNegative = true;
}
double pow = Power(base * base, exponent / 2);
if (exponent % 2 != 0)
pow = pow * base;
return isNegative ? 1 / pow : pow;
}
}
13.调整数组顺序使奇数位于偶数前面
题目链接
题目描述
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
解题思路
思路1：类似冒泡算法，前偶后奇数就交换。
思路2：再创建一个数组，遍历旧数组，遇见偶数，就保存到新数组，同时从原数组中删除，最后将新数组的数添加到老数组。
因为思路2中的数组长度不好处理，可以考虑定义两个list，一个存放奇数一个存放偶数，最后遍历重新写入数组。
解答代码
//第一种方式，冒泡排序
public class Solution {
public void reOrderArray(int [] array) {
for (int i = 1 ; i < array.length ; i ++){
for (int j = 0 ; j < array.length - i ; j ++){
if (array[j] % 2 == 0 && array[j + 1] % 2 == 1){
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}
}
//第二种方式
import java.util.ArrayList;
public class Solution {
public void reOrderArray(int [] array) {
ArrayList<Integer> arrayList1 = new ArrayList<>();
ArrayList<Integer> arrayList2 = new ArrayList<>();
for (int i : array){
if (i % 2 == 1){
arrayList1.add(i);
}else{
arrayList2.add(i);
}
}
int len = arrayList1.size();
for (int i = 0 ;i < arrayList1.size() ; i ++){
array[i] = arrayList1.get(i);
}
for (int i = 0 ;i < arrayList2.size() ; i ++){
array[len + i] = arrayList2.get(i);
}
}
}
14.链表中倒数第k个结点
题目链接
题目描述
输入一个链表，输出该链表中倒数第k个结点。
解题思路
将节点依次存入一个列表中，最后输出列表中位置为列表长度减k的值（即为倒数第k个节点）
注意要先对输入的值校验，head是否为空，k是否大于零小于列表长度等
解答代码
import java.util.ArrayList;
public class Solution {
public ListNode FindKthToTail(ListNode head,int k) {
if (head == null){
return null;
}
ArrayList<ListNode> list = new ArrayList<>();
list.add(head);
while(head.next != null){
head = head.next;
list.add(head);
}
if (k > list.size() || k <= 0)
return null;
return list.get(list.size() - k);
}
}
15.反转链表
题目链接
题目描述
输入一个链表，反转链表后，输出新链表的表头。
解题思路
核心是反转列表，这里我们先将链表依次存入栈中，再新建一个头结点，赋任意值，依次出栈复制给新的链表，再将头节点去掉，另外最后一个出栈的是我们传进来的头结点，它是有next的，而要作为我们返回的尾节点要没有next，所以要置为空。
解答代码
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
import java.util.Stack;
public class Solution {
public ListNode ReverseList(ListNode head) {
Stack stack = new Stack();
while (head != null){
stack.push(head);
head = head.next;
}
ListNode res = new ListNode(0);
ListNode tail = res;
int i = 0;
while (!stack.isEmpty()){
tail.next = (ListNode) stack.pop();
tail = tail.next;
i ++;
}
tail.next = null;
res = res.next;
return res;
}
}
16.合并两个排序的链表
题目链接
题目描述
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
解题思路
因为是两个递增的链表合并，依次比对插入即可。
解答代码
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode Merge(ListNode list1,ListNode list2) {
ListNode res = new ListNode(0);
ListNode tail = res;
while (list1 != null && list2 != null){
if (list1.val <= list2.val){
tail.next = list1;
tail = tail.next;
list1 = list1.next;
}else{
tail.next = list2;
tail = tail.next;
list2 = list2.next;
}
}
while (list1 != null){
tail.next = list1;
tail = tail.next;
list1 = list1.next;
}
while (list2 != null){
tail.next = list2;
tail = tail.next;
list2 = list2.next;
}
res = res.next;
return res;
}
}
17.树的子结构
题目链接
题目描述
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
解题思路
通过递归来解决
解答代码
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public static boolean HasSubtree(TreeNode tree1, TreeNode tree2) {
boolean result = false;
//当Tree1和Tree2都不为零的时候，才进行比较。否则直接返回false
if (tree1 != null && tree2 != null){
//如果找到了对应Tree2的根节点的点
if (tree1.val == tree2.val){
//以这个根节点为为起点判断是否包含Tree2
result = doesTree1HaveTree2(tree1,tree2);
}
//如果找不到，那么就再去root的左儿子当作起点，去判断是否包含Tree2
if (!result){
result = doesTree1HaveTree2(tree1.left,tree2);
}
//如果还找不到，那么就再去root的右儿子当作起点，去判断时候包含Tree2
if (!result){
result = doesTree1HaveTree2(tree1.right,tree2);
}
}
//返回结果
return result;
}
public static boolean doesTree1HaveTree2(TreeNode tree1, TreeNode tree2) {
//如果Tree2已经遍历完了都能对应的上，返回true
if (tree2 == null){
return true;
}
//如果Tree2还没有遍历完，Tree1却遍历完了。返回false
if (tree1 == null){
return false;
}
//如果其中有一个点没有对应上，返回false
if (tree1.val != tree2.val){
return false;
}
//如果根节点对应的上，那么就分别去子节点里面匹配
return doesTree1HaveTree2(tree1.left,tree2.left) && doesTree1HaveTree2(tree1.right,tree2.right);
}
}
18.二叉树的镜像
题目链接
题目描述
操作给定的二叉树，将其变换为源二叉树的镜像。
输入描述
二叉树的镜像定义：源二叉树
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) {
TreeNode temp;
if (root != null){
temp = root.left;
root.left = root.right;
root.right = temp;
if (root.left != null){
Mirror(root.left);
}
if (root.right != null){
Mirror(root.right);
}
}
}
}
19.顺时针打印矩阵
题目链接
题目描述
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 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 {
ArrayList result = new ArrayList();
public ArrayList<Integer> printMatrix(int [][] matrix) {
int tR = 0;
int tC = 0;
int dR = matrix.length - 1;
int dC = matrix[0].length - 1;
// 左上边界最多到达右下边界 用于判断是否还是剥圈打印
while (tR <= dR && tC <= dC){
printMatrix(matrix,tR++,tC++,dR--,dC--);
}
return result;
}
public void printMatrix(int[][] matrix, int tR, int tC, int dR, int dC) {
// 如果只是一横行 打印该行的列结束
if (tR == dR){
for (int i = tC ; i <= dC ; i ++){
result.add(matrix[tR][i]);
}
}else if (tC == dC){
// 如果只是一竖行，打印该竖行结束
for (int i = tR ; i <= dR ; i++){
result.add(matrix[i][tC]);
}
}else{
// 用2个变量储存 用于判断当前位置
int curR = tR;
int curC = tC;
// 上
while (curC != dC){
result.add(matrix[tR][curC]);
curC ++;
}
// 右
while (curR != dR){
result.add(matrix[curR][dC]);
curR ++;
}
// 下
while (curC != tC){
result.add(matrix[dR][curC]);
curC --;
}
// 左
while (curR != tR){
result.add(matrix[curR][tC]);
curR --;
}
}
}
}
20.包含min函数的栈
题目链接
题目描述
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
注意：这里要能做到在某个最小元素出栈后，min返回的就是次小的，所以定义一个min值是行不通的。
解题思路
应用一个辅助栈，压的时候，如果A栈的压入比B栈压入大，B栈不压，，，，小于等于，AB栈同时压入，出栈，如果，AB栈顶元素不等，A出，B不出。
解答代码
import java.util.Stack;
public class Solution {
// 存放数据的栈
Stack<Integer> stack = new Stack<>();
// 获取最小值的辅助栈
Stack<Integer> minStack = new Stack<>();
public void push(int node) {
stack.push(node);
if (minStack.isEmpty() || minStack.peek() >= node){
// 栈是后进先出的，这样能保证每次压入的都是栈中的最小值（可重复）
minStack.push(node);
}
}
public void pop() {
// 只有当出的值是最小值时，辅助栈才出栈
if (minStack != null && stack.peek() == minStack.peek()){
minStack.pop();
}
stack.pop();
}
public int top() {
return stack.peek();
}
public int min() {
// 栈顶的永远是最小值
return minStack.peek();
}
}
21.栈的压入、弹出序列
题目链接
题目描述
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
解题思路
定义一个栈，首先遍历第一个序列入栈，入栈的同时判断入栈的元素是否等于出栈的第j个元素（j初始值为0），如果等于执行出栈，同时j++，遍历完第一个序列，遍历第二个序列从j开始到最后的元素，栈顶元素等于第二个序列j位置的元素，出栈，j++，最后判断栈是否为空，返回true或false。
解答代码
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
public boolean IsPopOrder(int [] pushA,int [] popA) {
Stack stack = new Stack();
int j = 0;
for (int i = 0 ; i < pushA.length; i ++){
stack.push(pushA[i]);
if ((int)stack.peek() == popA[j]){
stack.pop();
j ++;
}
}
while (j < popA.length){
if ((int)stack.peek() == popA[j]){
stack.pop();
j ++;
}else{
break;
}
}
if (stack.isEmpty()){
return true;
}
return false;
}
}
22.从上往下打印二叉树
题目链接
题目描述
从上往下打印出二叉树的每个节点，同层节点从左至右打印。
解题思路
使用arraylist模拟一个队列来存储相应的TreeNode
解答代码
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 {
public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
ArrayList<Integer> list = new ArrayList<>();
ArrayList<TreeNode> queue = new ArrayList<>();
if(root == null){
return list;
}
queue.add(root);
while(queue.size() != 0){
TreeNode temp = queue.remove(0);
if(temp.left != null){
queue.add(temp.left);
}
if(temp.right != null){
queue.add(temp.right);
}
list.add(temp.val);
}
return list;
}
}
23.二叉搜索树的后序遍历序列
题目链接
题目描述
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
解题思路
思路（分治思想）：
已知条件：后序序列最后一个值为root；二叉搜索树左子树值都比root小，右子树值都比root大。
1、确定root；
2、遍历序列（除去root结点），找到第一个大于root的位置，则该位置左边为左子树，右边为右子树；
3、遍历右子树，若发现有小于root的值，则直接返回false；
4、分别判断左子树和右子树是否仍是二叉搜索树（即递归步骤1、2、3）。
解答代码
public class Solution {
public static void main(String[] args) {
// 这里测试123时返回的true是对的，因为2是3的左子树，1是2的左子树的情况
int[] arr = {1,2,3};
System.out.println(new Solution().VerifySquenceOfBST(arr));
}
public boolean VerifySquenceOfBST(int [] sequence) {
if (sequence.length <= 0){
return false;
}
return VerifySquenceOfBST(sequence,0,sequence.length - 1);
}
private boolean VerifySquenceOfBST(int[] sequence, int left, int right) {
if (left >= right){
return true;
}
// 后序遍历最后一个值为根节点
int root = sequence[right];
// 定位前序后序分界点（二叉搜索树前序都小于根节点，后序都大于根节点）
int j = left;
for (int i = left ; i < right ; i ++){
if (sequence[i] > root){
break;
}
j ++;
}
// 遍历后序中是否有小于前序的，如果有，返回false
for (int i = j+1 ; i < right ; i ++){
if (sequence[i] < root){
return false;
}
}
return VerifySquenceOfBST(sequence, left, j-1) && VerifySquenceOfBST(sequence, j, right-1);
}
}
24.二叉树中和为某一值的路径
题目链接
题目描述
输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)
解题思路
还是考察递归思想。
这里要注意将path添加到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> path = new ArrayList<>();
public ArrayList<ArrayList<Integer>> FindPath(TreeNode root, int target) {
if (root == null){
return res;
}
findPath(root, target);
return res;
}
private void findPath(TreeNode root, int target) {
// 因为在FindPath中做了非空判断，且下面的递归前也都做了非空判断，root一定不为空
path.add(root.val);
// 已经到达叶子节点，并且正好加出了target
if (root.val == target && root.left == null && root.right == null){
// 要将引用封装为对象，不然后面引用的值会变，这里加入的也变了，即每次加入的都为同一个值
res.add(new ArrayList<>(path));
}
// 如果左子树为空，遍历左子树
if (root.left != null){
findPath(root.left, target - root.val);
}
// 如果右子树非空，递归右子树
if (root.right != null){
findPath(root.right, target - root.val);
}
//无论当前路径是否加出了target，必须去掉最后一个，然后返回父节点，去查找另一条路径，最终的path肯定为null
// 回溯遍历，走完左子树要走右子树，不停回溯
path.remove(path.size() - 1);
return;
}
}
25.复杂链表的复制
题目链接
题目描述
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
解题思路
- 1、遍历链表，复制每个结点，如复制结点A得到A1，将结点A1插到结点A后面；
- 2、重新遍历链表，复制老结点的随机指针给新结点，如A1.random = A.random.next;
- 3、拆分链表，将链表拆分为原链表和复制后的链表
解答代码
/*
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;
}
RandomListNode currentNode = pHead;
//1、复制每个结点，如复制结点A得到A1，将结点A1插到结点A后面；
while(currentNode != null){
RandomListNode cloneNode = new RandomListNode(currentNode.label);
RandomListNode nextNode = currentNode.next;
currentNode.next = cloneNode;
cloneNode.next = nextNode;
currentNode = nextNode;
}
currentNode = pHead;
//2、重新遍历链表，复制老结点的随机指针给新结点，如A1.random = A.random.next;
while(currentNode != null) {
// 如A -> B 则 A1 -> B1(B的next) 所以是指向currentNode.random.next,而不是currentNode.random
currentNode.next.random = currentNode.random==null?null:currentNode.random.next;
currentNode = currentNode.next.next;
}
//3、拆分链表，将链表拆分为原链表和复制后的链表
currentNode = pHead;
RandomListNode pCloneHead = pHead.next;
while(currentNode != null) {
RandomListNode cloneNode = currentNode.next;
currentNode.next = cloneNode.next;
cloneNode.next = cloneNode.next==null?null:cloneNode.next.next;
currentNode = currentNode.next;
}
return pCloneHead;
}
}
26.二叉搜索树与双向链表
题目链接
题目描述
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
解题思路
将一个二叉搜索树转换为一个排序的双向链表，考虑二叉搜索树左子树 < 根节点 < 右子树的特点，其实就是进行二叉搜索树的中序遍历。
解答代码
public class Solution {
TreeNode node;
TreeNode realNode;
public TreeNode Convert(TreeNode pRootOfTree) {
ConvertSub(pRootOfTree);
return realNode;
}
private void ConvertSub(TreeNode pRootOfTree) {
if (pRootOfTree == null)
return;
// 遍历左节点
ConvertSub(pRootOfTree.left);
// 将节点值插入链表中
if (realNode == null){
// 若链表为空，则插入第一个节点，即为最后返回的头结点
node = pRootOfTree;
realNode = pRootOfTree;
}else{
// 将节点插入链表，即将当前尾节点的right（后置指针）指向当前值，同时将当前值的left（前置指针）指向当前尾节点，尾节点后移
node.right = pRootOfTree;
pRootOfTree.left = node;
node = node.right;
}
// 遍历右节点
ConvertSub(pRootOfTree.right);
}
}
27.字符串的排列
题目链接
题目描述
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
输入描述
输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。
解题思路
基于回溯法思想：
解答代码
import java.util.ArrayList;
import java.util.Collections;
public class Solution {
public ArrayList<String> Permutation(String str) {
ArrayList<String> res = new ArrayList<>();
if (str != null && str.length() > 0){
Permutation(str.toCharArray(), 0, res);
Collections.sort(res);
}
return res;
}
private void Permutation(char[] str, int i, ArrayList<String> list) {
if (i == str.length - 1){
String val = String.valueOf(str);
if (!list.contains(val)){
list.add(val);
}
} else {
for (int j = i ; j < str.length ; j ++){
swap(str, i, j);
Permutation(str, i+1, list);
swap(str, i, j);
}
}
}
private void swap(char[] str, int i, int j) {
char temp = str[i];
str[i] = str[j];
str[j] = temp;
}
}
28.数组中出现次数超过一半的数字
题目链接
题目描述
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
解题思路
用一个map记录下每个数字出现的次数就好了。
解答代码
import java.util.HashMap;
public class Solution {
public int MoreThanHalfNum_Solution(int [] array) {
if (array.length <= 0){
return 0;
}
if (array.length == 1){
return array[0];
}
HashMap<Integer,Integer> map = new HashMap<>();
int mid = array.length % 2 == 0 ? array.length / 2 + 1 : array.length / 2 + 1;
for (int i = 0 ; i < array.length ; i ++){
int key = array[i];
if (map.containsKey(key)){
int val = map.get(key);
map.put(key,val + 1);
if (val + 1 >= mid){
return key;
}
} else {
map.put(key,1);
}
}
return 0;
}
}
29.最小的K个数
题目链接
题目描述
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。
解题思路
使用快排排序再输出前k个即可。
解答代码
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
ArrayList<Integer> list = new ArrayList<>();
if (input == null || input.length <= 0 || input.length < k){
return list;
}
QuickSort(input, 0, input.length - 1);
for (int i = 0 ; i < k ; i ++){
list.add(input[i]);
}
return list;
}
private void QuickSort(int[] input, int left, int right) {
if (left < right){
int pivot = partion(input, left, right);
QuickSort(input, left, pivot - 1);
QuickSort(input, pivot + 1, right);
}
}
private int partion(int[] input, int left, int right) {
int pivot = left;
int index = left + 1;
for (int i = index ; i <= right ; i ++){
if (input[i] < input[pivot]){
swap(input, i, index);
index ++;
}
}
swap(input, pivot, index - 1);
return index - 1;
}
private void swap(int[] input, int a, int b) {
int temp = input[a];
input[a] = input[b];
input[b] = temp;
}
}
30.连续子数组的最大和
题目链接
题目描述
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)
解题思路
第一种直接遍历，将各种求和结果放入list，将list排序后输出最大值。这样时间复杂度为O(n^2)
第二种使用动态规划的思想：
使用动态规划
F（i）：以array[i]为末尾元素的子数组的和的最大值，子数组的元素的相对位置不变
F（i）=max（F（i-1）+array[i] ， array[i]）
res：所有子数组的和的最大值
res=max（res，F（i））
如数组[6, -3, -2, 7, -15, 1, 2, 2]
初始状态：
F（0）=6
res=6
i=1：
F（1）=max（F（0）-3，-3）=max（6-3，3）=3
res=max（F（1），res）=max（3，6）=6
i=2：
F（2）=max（F（1）-2，-2）=max（3-2，-2）=1
res=max（F（2），res）=max（1，6）=6
i=3：
F（3）=max（F（2）+7，7）=max（1+7，7）=8
res=max（F（2），res）=max（8，6）=8
i=4：
F（4）=max（F（3）-15，-15）=max（8-15，-15）=-7
res=max（F（4），res）=max（-7，8）=8
以此类推
最终res的值为8
解答代码1
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Solution {
public int FindGreatestSumOfSubArray(int[] array) {
List<Integer> list = new ArrayList<>();
for (int i = 0 ; i < array.length ; i ++){
int sum = 0;
for (int j = i ; j < array.length ; j ++){
sum += array[j];
list.add(sum);
}
}
Collections.sort(list);
return list.get(list.size() - 1);
}
}
解答代码2
public class Solution {
public int FindGreatestSumOfSubArray(int[] array) {
int sum = array[0]; //记录当前所有子数组的和的最大值
int tempSum = array[0]; //包含array[i]的连续数组最大值
for (int i = 1 ; i < array.length ; i++){
tempSum = Math.max(tempSum + array[i],array[i]);
sum = Math.max(sum, tempSum);
}
return sum;
}
}
31.整数中1出现的次数（从1到n整数中1出现的次数）
题目链接
题目描述
求出1 ~ 13的整数中1出现的次数,并算出100 ~ 1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。
解题思路
遍历每个数字，将数字转为字符数组遍历1出现的次数。
解答代码
public class Solution {
public int NumberOf1Between1AndN_Solution(int n) {
int count = 0;
for (int i = 1 ; i <= n ; i ++){
String str = String.valueOf(i);
char[] chars = str.toCharArray();
for (int j = 0 ; j < chars.length ; j ++){
if (chars[j] == '1'){
// 注意是1出现的次数 如11中1出现了两次
count ++;
}
}
}
return count;
}
}
32.把数组排成最小的数
题目链接
题目描述
输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
解题思路
- 先将整型数组转换成String数组，然后将String数组排序，最后将排好序的字符串数组拼接出来。关键就是制定排序规则。
- 排序规则如下：
- 若ab > ba 则 a > b，(这里ab是a拼接b)
- 若ab < ba 则 a < b，
- 若ab = ba 则 a = b；
- 解释说明：
- 比如 “3” < "31"但是 “331” > “313”，所以要将二者拼接起来进行比较
解答代码
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
public class Solution {
public String PrintMinNumber(int [] numbers) {
String[] strArr = new String[numbers.length];
for (int i = 0 ; i < numbers.length ; i ++){
strArr[i] = String.valueOf(numbers[i]);
}
Arrays.sort(strArr, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
String str1 = o1 + o2;
String str2 = o2 + o1;
return str1.compareTo(str2);
}
});
StringBuffer sb = new StringBuffer();
for (String string : strArr){
sb.append(string);
}
return sb.toString();
}
}
33.丑数
题目链接
题目描述
把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
解题思路
通俗易懂的解释：(C语言版)
首先从丑数的定义我们知道，一个丑数的因子只有2,3,5，那么丑数p = 2 ^ x * 3 ^ y * 5 ^ z，换句话说一个丑数一定由另一个丑数乘以2或者乘以3或者乘以5得到，那么我们从1开始乘以2,3,5，就得到2,3,5三个丑数，在从这三个丑数出发乘以2,3,5就得到4，6,10,6，9,15,10,15,25九个丑数，我们发现这种方法会得到重复的丑数，而且我们题目要求第N个丑数，这样的方法得到的丑数也是无序的。那么我们可以维护三个队列：
（1）丑数数组： 1
乘以2的队列：2
乘以3的队列：3
乘以5的队列：5
选择三个队列头最小的数2加入丑数数组，同时将该最小的数乘以2,3,5放入三个队列；
（2）丑数数组：1,2
乘以2的队列：4
乘以3的队列：3，6
乘以5的队列：5，10
选择三个队列头最小的数3加入丑数数组，同时将该最小的数乘以2,3,5放入三个队列；
（3）丑数数组：1,2,3
乘以2的队列：4,6
乘以3的队列：6,9
乘以5的队列：5,10,15
选择三个队列头里最小的数4加入丑数数组，同时将该最小的数乘以2,3,5放入三个队列；
（4）丑数数组：1,2,3,4
乘以2的队列：6，8
乘以3的队列：6,9,12
乘以5的队列：5,10,15,20
选择三个队列头里最小的数5加入丑数数组，同时将该最小的数乘以2,3,5放入三个队列；
（5）丑数数组：1,2,3,4,5
乘以2的队列：6,8,10，
乘以3的队列：6,9,12,15
乘以5的队列：10,15,20,25
选择三个队列头里最小的数6加入丑数数组，但我们发现，有两个队列头都为6，所以我们弹出两个队列头，同时将12,18,30放入三个队列；
……………………
疑问：
1.为什么分三个队列？
丑数数组里的数一定是有序的，因为我们是从丑数数组里的数乘以2,3,5选出的最小数，一定比以前未乘以2,3,5大，同时对于三个队列内部，按先后顺序乘以2,3,5分别放入，所以同一个队列内部也是有序的；
2.为什么比较三个队列头部最小的数放入丑数数组？
因为三个队列是有序的，所以取出三个头中最小的，等同于找到了三个队列所有数中最小的。
实现思路：
我们没有必要维护三个队列，只需要记录三个指针显示到达哪一步；“|”表示指针,arr表示丑数数组；
（1）1
|2
|3
|5
目前指针指向0,0,0，队列头arr[0] * 2 = 2, arr[0] * 3 = 3, arr[0] * 5 = 5
（2）1 2
2 |4
|3 6
|5 10
目前指针指向1,0,0，队列头arr[1] * 2 = 4, arr[0] * 3 = 3, arr[0] * 5 = 5
（3）1 2 3
2| 4 6
3 |6 9
|5 10 15
目前指针指向1,1,0，队列头arr[1] * 2 = 4, arr[1] * 3 = 6, arr[0] * 5 = 5
………………
这里我们的解题思路：我们只用比较3个数：用于乘2的最小的数、用于乘3的最小的数，用于乘5的最小的数。
解答代码
import java.util.ArrayList;
import java.util.List;
/**
* 思路： 我们只用比较3个数：用于乘2的最小的数、用于乘3的最小的数，用于乘5的最小的
*/
public class Solution {
public int GetUglyNumber_Solution(int index) {
if (index <= 0) return 0;
List<Integer> list = new ArrayList<>();
list.add(1);
int i2 = 0, i3 = 0, i5 = 0;
while (list.size() < index) {
int mul2 = list.get(i2) * 2;
int mul3 = list.get(i3) * 3;
int mul5 = list.get(i5) * 5;
int tar = Math.min(mul2, Math.min(mul3, mul5));
if (tar == mul2) i2++;
if (tar == mul3) i3++;
if (tar == mul5) i5++;
list.add(tar);
}
return list.get(list.size() - 1);
}
}
34.第一个只出现一次的字符
题目链接
题目描述
在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.
解题思路
暴力一点的解法是直接用一个map来解决即可。
另外因为题目是全部由字母组成，故一共有52中可能，可以用一个数组来存储每个字母出现的次数，可以快速找到只出现一次的字母，当然这里是找到第一个只出现一次的字符的位置，所以这种不适合这道题。
解答代码
import java.util.HashMap;
import java.util.Map;
public class Solution {
public int FirstNotRepeatingChar(String str) {
if (str.length() <= 1){
return -1;
}
Map<Character, Integer> map = new HashMap<>();
for (int i = 0 ; i < str.length(); i ++){
Character c = str.charAt(i);
if (map.containsKey(c)){
map.put(c,map.get(c) + 1);
} else {
map.put(c,1);
}
}
for (int i = 0 ; i < str.length() ; i ++){
int num = map.get(str.charAt(i));
if (num == 1){
return i;
}
}
return -1;
}
}
35.数组中的逆序对
题目链接
题目描述
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数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
解题思路
归并排序的改进，把数据分成前后两个数组(递归分到每个数组仅有一个数据项)，
合并数组，合并时，出现前面的数组值array[i]大于后面数组值array[j]时；则前面
数组array[i]~array[mid]都是大于array[j]的，count += mid+1 - i
参考剑指Offer，但是感觉剑指Offer归并过程少了一步拷贝过程。
还有就是测试用例输出结果比较大，对每次返回的count mod(1000000007)求余
(这道题啃了很久，还是不熟)
解答代码
public class Solution {
//统计逆序对的个数
int cnt;
public int InversePairs(int [] array) {
if(array.length != 0){
divide(array,0,array.length-1);
}
return cnt;
}
//归并排序的分治---分
private void divide(int[] arr,int start,int end){
//递归的终止条件
if(start >= end)
return;
//计算中间值，注意溢出
int mid = start + (end - start)/2;
//递归分
divide(arr,start,mid);
divide(arr,mid+1,end);
//治
merge(arr,start,mid,end);
}
private void merge(int[] arr,int start,int mid,int end){
int[] temp = new int[end-start+1];
//存一下变量
int i=start,j=mid+1,k=0;
//下面就开始两两进行比较，若前面的数大于后面的数，就构成逆序对
while(i<=mid && j<=end){
//若前面小于后面，直接存进去，并且移动前面数所在的数组的指针即可
if(arr[i] <= arr[j]){
temp[k++] = arr[i++];
}else{
temp[k++] = arr[j++];
//a[i]>a[j]了，那么这一次，从a[i]开始到a[mid]必定都是大于这个a[j]的，因为此时分治的两边已经是各自有序了
cnt = (cnt+mid-i+1)%1000000007;
}
}
//各自还有剩余的没比完，直接赋值即可
while(i<=mid)
temp[k++] = arr[i++];
while(j<=end)
temp[k++] = arr[j++];
//覆盖原数组
for (k = 0; k < temp.length; k++)
arr[start + k] = temp[k];
}
}
36.两个链表的第一个公共结点
题目链接
题目描述
解题思路
解答代码
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.数组中重复的数字
题目链接
题目描述
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。
解题思路
利用HashSet判断是否已有该数据，有的话返回，没有的话添加。
解答代码
public boolean duplicate(int[] nums, int length, int[] duplication) {
if(nums == null || nums.length <= 0){
return false;
}
HashSet hashSet = new HashSet();
for (int i = 0 ; i < nums.length ; i ++){
if (hashSet.contains(nums[i])){
duplication[0] = nums[i];
return true;
}else{
hashSet.add(nums[i]);
}
}
return false;
}
51.
52.
53.
54.
55.
56.
57.二叉树的下一个结点
题目链接
题目描述
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
解题思路
- 如果一个节点的右子树不为空，那么该节点的下一个节点是右子树的最左节点；
- 否则，向上找第一个左链接指向的树包含该节点的祖先节点。
解答代码
/*
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.right != null){
TreeLinkNode rNode = pNode.right;
while(rNode.left != null){
rNode = rNode.left;
}
return rNode;
}else{
while (pNode.next != null){
TreeLinkNode parent = pNode.next;
if (parent.left == pNode){
return parent;
}
pNode = pNode.next;
}
}
return null;
}
}
class TreeLinkNode {
int val;
TreeLinkNode left = null;
TreeLinkNode right = null;
TreeLinkNode next = null;
TreeLinkNode(int val) {
this.val = val;
}
}
58.
59.
60.
61.
62.
63.
64.
65.矩阵中的路径 *
题目链接
题目描述
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。 例如 a b c e s f c s a d e e 这样的3 X 4 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。
解题思路
- 根据给定数组，初始化一个标志位数组，初始化为false，表示未走过，true表示已经走过，不能走第二次
- 根据行数和列数，遍历数组，先找到一个与str字符串的第一个元素相匹配的矩阵元素，进入judge
- 根据i和j先确定一维数组的位置，因为给定的matrix是一个一维数组
- 确定递归终止条件：越界，当前找到的矩阵值不等于数组对应位置的值，已经走过的，这三类情况，都直接false，说明这条路不通
- 若k，就是待判定的字符串str的索引已经判断到了最后一位，此时说明是匹配成功的
- 下面就是本题的精髓，递归不断地寻找周围四个格子是否符合条件，只要有一个格子符合条件，就继续再找这个符合条件的格子的四周是否存在符合条件的格子，直到k到达末尾或者不满足递归条件就停止。
- 走到这一步，说明本次是不成功的，我们要还原一下标志位数组index处的标志位，进入下一轮的判断。
解答代码
public class Solution {
public boolean hasPath(char[] matrix, int rows, int cols, char[] str)
{
//标志位，初始化为false
boolean[] flag = new boolean[matrix.length];
for(int i=0;i<rows;i++){
for(int j=0;j<cols;j++){
//循环遍历二维数组，找到起点等于str第一个元素的值，再递归判断四周是否有符合条件的----回溯法
if(judge(matrix,i,j,rows,cols,flag,str,0)){
return true;
}
}
}
return false;
}
//judge(初始矩阵，索引行坐标i，索引纵坐标j，矩阵行数，矩阵列数，待判断的字符串，字符串索引初始为0即先判断字符串的第一位)
private boolean judge(char[] matrix,int i,int j,int rows,int cols,boolean[] flag,char[] str,int k){
//先根据i和j计算匹配的第一个元素转为一维数组的位置
int index = i*cols+j;
//递归终止条件
if(i<0 || j<0 || i>=rows || j>=cols || matrix[index] != str[k] || flag[index] == true)
return false;
//若k已经到达str末尾了，说明之前的都已经匹配成功了，直接返回true即可
if(k == str.length-1)
return true;
//要走的第一个位置置为true，表示已经走过了
flag[index] = true;
//回溯，递归寻找，每次找到了就给k加一，找不到，还原
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。请问该机器人能够达到多少个格子？
解题思路
回溯法
- 从(0,0)开始走，每成功走一步标记当前位置为true,然后从当前位置往四个方向探索，
返回1 + 4 个方向的探索值之和。 - 探索时，判断当前节点是否可达的标准为：
1） 当前节点在矩阵内；
2）当前节点未被访问过；
3）当前节点满足limit限制。
解答代码
public class Solution {
public int movingCount(int threshold, int rows, int cols) {
boolean[][] visited = new boolean[rows][cols];
return countingSteps(threshold,rows,cols,0,0,visited);
}
public int countingSteps(int limit,int rows,int cols,int r,int c,boolean[][] visited){
if (r < 0 || r >= rows || c < 0 || c >= cols
|| visited[r][c] || bitSum(r) + bitSum(c) > limit) return 0;
visited[r][c] = true;
return countingSteps(limit,rows,cols,r - 1,c,visited)
+ countingSteps(limit,rows,cols,r,c - 1,visited)
+ countingSteps(limit,rows,cols,r + 1,c,visited)
+ countingSteps(limit,rows,cols,r,c + 1,visited)
+ 1;
}
public int bitSum(int t){
int count = 0;
while (t != 0){
count += t % 10;
t /= 10;
}
return count;
}
}