剑指offer 思路总结
1、栈和队列
1.1 用两个栈实现队列
题目概述：用两个栈实现一个队列，实现它的两个函数，分别在队列尾部插入结点，和队列头部删除结点。
思路：其中一个栈用作插入结点元素（只要是添加元素，都只往这个栈放），另外一个栈用作队列头删除元素（删除元素时，先判断该栈是否为空，若为空，把第一个栈的所有元素往此战填充，在进行删除元素）。
1.2 包含min函数的栈
题目概述：定义栈的数据结构，实现一个得到栈最下元素min的函数。在栈中，调用min,push及pop的时间复杂度都是O（1）。
思路：一个栈保存数据，一个栈存放当前最小值，当压入栈的元素比第二栈小时，就把他压入同时压入两个栈；当小时，就只把压入数据站，第二栈压入一个栈顶元素。
1.3 栈的压入和弹出序列。
题目概述：给定两个数组，第一个是栈的压入顺序，第二个是栈的一个弹出序列，判断第二个数组是否为栈的一个弹出序列。
思路：借助一个辅助栈，然后依次遍历进栈，如果遇到与第二数组相等的，就出栈。
import java.util.Stack;
public class Solution {
public boolean IsPopOrder(int [] pushA,int [] popA) {
if(pushA.length == 0 || popA.length == 0)
return false;
Stack<Integer> temp = new Stack<>();
int popIndex = 0;
for(int i = 0 ; i < pushA.length; i++){
temp.push(pushA[i]);
while(!temp.isEmpty() && temp.peek() == popA[popIndex]){
temp.pop();
popIndex++;
}
}
return temp.isEmpty();
}
}1.4 队列的最大值
题目概述：给定一个数组和一个窗口的大小，求滑动窗口里的最大值。
思路：借助一个双向队列，每遍历一个元素进行一次逻辑操作。
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
if(nums.length == 0 )
return nums;
Deque<Integer> deque=new ArrayDeque<>();
int[] ans = new int[nums.length-k+1];
for(int i=0;i<nums.length;i++){
if(!deque.isEmpty() && deque.peekFirst()<i-(k-1))
deque.removeFirst();
while(!deque.isEmpty() && nums[deque.peekLast()]<nums[i])
deque.removeLast();
deque.offerLast(i);
if(i>=k-1){
ans[i-(k-1)]=nums[deque.peekFirst()];
}
}
return ans;
}
}2、算法与数据操作
2.1 斐波那契数列（递归、动态规划）
题目一概述：求斐波那契数列的第n项。
思路： 采用动态规划，第n个值由前面两个项得来，所以用两个变量记录动态前两个项即可。
题目二概述：青蛙跳台阶的问题（一只青蛙一次可以跳一级台阶，也可以跳上两级台阶，求该青蛙跳上一个n级台阶总共有多少种跳法）
思路：采用动态规划，第n个值由前面两个项得来，所以用两个变量记录动态前两个项即可。
2.2 矩阵中的路径（回溯法）
题目描述：给出一个字符串矩阵，判断矩阵中是否存在给出字符串的路径（每一步只能左右上下，不能重复）
思路：采用回溯法，从第一个元素进行递归判断，如果不符合条件直接返回false。需要注意访问过的结点，判断递归结束的条件等。
//核心代码
private boolean bfs(char[][] board, int i, int j, boolean[][] isVisited, char[] chs, int index) {
if (index == chs.length) {
return true;
}
if (i < 0 || j < 0 || i == board.length || j == board[0].length || isVisited[i][j] || board[i][j] != chs[index]) {
return false;
}
isVisited[i][j] = true;
boolean res = bfs(board, i + 1, j, isVisited, chs, index + 1)
|| bfs(board, i - 1, j, isVisited, chs, index + 1)
|| bfs(board, i, j + 1, isVisited, chs, index + 1)
|| bfs(board, i, j - 1, isVisited, chs, index + 1);
isVisited[i][j] = false;
return res;
}2.3 机器人的运动范围（回溯法）
题目大致描述：一个m行n列的方格，一个机器人从坐标（0,0）开始，可以向上下左右移动一格，但不能进入坐标的数位和大于k的格子。求机器人最多可以进入多少个格子。
思路：可以利用回朔法，从（0,0）开始进行递归，没走一步就判断是否符合条件。注意的就是需要定义一个辅助二维数组标记是否重复计算，并定义一个全局变量，记录符合条件的格子。
2.4 剪绳子（动态规划，贪心算法）
题目大致描述：一根长度为n的绳子，请把绳子剪成m段（m>0）,求绳子最大乘积。
思路一：采用动态规划法
思路二：采用贪婪算法
2.5 二进制中一的个数（与运算）
题目大致概述：统计一个整数中的二进制中一的个数。
思路：把一个整数减一之后再与原来的整数做位与运算，得到的结果相当于把整数的二进制中最右边的1变成0。
2.6 正则表达式匹配
题目大致概述：给出一个字符串和一个模式，判断两者是否匹配。‘*’可以匹配任意次他前面的元素，‘.’可匹配一个任意元素。
思路一：递归法，以第二个字符是否为"*"进行分析，然后采用递归法。
思路二：采用动态规划法，采用一个二维数组，记录F(x,y)表示，字符串前x位是否与匹配模式前y位匹配。
class Solution {
public boolean isMatch(String s, String p) {
if (s == null || p == null) return false;
int m = s.length();
int n = p.length();
boolean[][] dp = new boolean[m+1][n+1];
dp[0][0] = true;
char[] pp = p.toCharArray();
char[] ss = s.toCharArray();
for(int i = 2; i <= n; i += 2){
if(pp[i-1] == '*') dp[0][i] = dp[0][i-2];
}
for(int i = 1; i <= m; i++){
for(int j = 1; j <= n; j++){
if(pp[j-1] == '*'){ //判断当前否为“*”
if(pp[j-2] != ss[i-1] && pp[j-2] != '.') //判断双方前一个字符是否匹配
dp[i][j] = dp[i][j-2]; //不匹配只能对消
else { //匹配，分三种情况
dp[i][j] = (dp[i-1][j])||(dp[i][j-1])||(dp[i][j-2]);
}
}
else if (pp[j-1] == '.' || pp[j-1] == ss[i-1]) {
dp[i][j] = dp[i-1][j-1];
}
}
}
return dp[m][n];
}
}2.7 数据流中的中位数（堆排序）
题目描述：从一个数据流中得到中位数。
思路：可以采用两个堆，一个是大顶堆存放数据流前半的数据，一个是小顶堆，存放数据的后半段数据。
2.8 丑数
题目概述：只包含因子2,3,5的数称作丑数。求1500个丑数。其中1默认为第一个丑数。
思路：可以采用空间换时间的方法。
public class Ugly {
public int isUgly(int index){
if(index <= 0)
return 0;
int[] temp = new int[index]; //创建一个数组存放丑数
temp[0] = 1;
int md2 = 0;
int md3 = 0;
int md5 = 0;
int mid = 1;
for(int i = 1; i < index; ++i){ //依次计算求值
mid = Math.min(temp[md2] * 2 , Math.min(temp[md3] * 3 , temp[md5] * 5));
if(mid == temp[md2] * 2)
md2++;
if(mid == temp[md3] * 3)
md3++;
if(mid == temp[md5] * 5)
md5++;
temp[i] = mid;
}
return temp[index - 1];
}
}2.9 第一个只出现一次的字符
题目概述：求字符串中第一个只出现一次的字符。
思路：可以采用空间换时间的方法。借助一个辅助数组，依次遍历字符串计算每个字符的数量，然后找出第一个。
2.10 n个骰子的点数。（动态规划）
题目概述：把n个骰子扔在地上，所有骰子朝上一面的点数之和为s。输入n，打印所有可能值的概率。
思路：n个骰子，每个骰子6个面，总情况数为6^n；
设F(n,s)F(n,s)为当骰子数为n，和为s的情况数量。
当n=1时，F(1,s)=1,其中s=1,2,3,4,5,6当n=1时，F(1,s)=1,其中s=1,2,3,4,5,6
当n≥2时，F(n,s)=F(n−1,s−1)+F(n−1,s−2)+F(n−1,s−3)+F(n−1,s−4)+F(n−1,s−5)+F(n−1,s−6)
class Solution {
public double[] twoSum(int n) {
int [][]dp = new int[n+1][6*n+1];
//边界条件
for(int s=1;s<=6;s++)
dp[1][s]=1;
for(int i=2;i<=n;i++){
for(int s=i;s<=6*i;s++){
//求dp[i][s]
for(int d=1;d<=6;d++){
if(s-d<i-1) break;//为0了
dp[i][s]+=dp[i-1][s-d];
}
}
}
double total = Math.pow((double)6,(double)n);
double[] ans = new double[5*n+1];
for(int i=n;i<=6*n;i++){
ans[i-n]=((double)dp[n][i])/total;
}
return ans;
}
}
2.11 扑克牌中的顺子
题目概述：从扑克牌中随机抽取5张，判断是不是一个顺子，即这五张牌是不是连续的。
思路：先对扑克进行排序，然后计算即可。
2.12 约瑟夫环问题（圆圈中最后剩下的数字）
题目描述：0-n排成一个圆圈，从数字0开始，每次从这个圆圈中删除第m个数字。求剩下的最后一个数字。
思路一：构建链表。
class Solution {
public int lastRemaining(int n, int m) {
ArrayList<Integer> list = new ArrayList<>(n);
for (int i = 0; i < n; i++) {
list.add(i);
}
int idx = 0;
while (n > 1) {
idx = (idx + m - 1) % n; //每次减一后取模
list.remove(idx);
n--;
}
return list.get(0);
}
}
思路二：采用数学法。
class Solution {
public int lastRemaining(int n, int m) {
int ans = 0;
// 最后一轮剩下2个人，所以从2开始反推
for (int i = 2; i <= n; i++) {
ans = (ans + m) % i;
}
return ans;
}
}
