剑指offer------栈队列、算法篇

本文链接：https://blog.csdn.net/qqq3117004957/article/details/105008049

剑指offer 思路总结

1、栈和队列

1.1 用两个栈实现队列

题目概述：用两个栈实现一个队列，实现它的两个函数，分别在队列尾部插入结点，和队列头部删除结点。

思路：其中一个栈用作插入结点元素（只要是添加元素，都只往这个栈放），另外一个栈用作队列头删除元素（删除元素时，先判断该栈是否为空，若为空，把第一个栈的所有元素往此战填充，在进行删除元素）。

class CQueue {
    Stack<Integer> stack1;
    Stack<Integer> stack2;
    public CQueue() {
         stack1 = new Stack<>();
         stack2 = new Stack<>();
    }   
    public void appendTail(int value) {
         stack1.push(value);
    }  
    public int deleteHead() {
         if(stack1.isEmpty() && stack2.isEmpty())
            return -1;
         if(stack2.isEmpty()){
             while(!stack1.isEmpty())
                 stack2.push(stack1.pop());
         }   
         return stack2.pop();
    }
}

1.2 包含min函数的栈

题目概述：定义栈的数据结构，实现一个得到栈最下元素min的函数。在栈中，调用min,push及pop的时间复杂度都是O（1）。

思路：一个栈保存数据，一个栈存放当前最小值，当压入栈的元素比第二栈小时，就把他压入同时压入两个栈；当小时，就只把压入数据站，第二栈压入一个栈顶元素。

class MinStack {
    Stack<Integer> stack1;
    Stack<Integer> stack2;
    public MinStack() {
        stack1 = new Stack<>();
        stack2 = new Stack<>();
    }
    
    public void push(int x) {
        stack1.push(x);
        if(stack2.isEmpty())
           stack2.push(x);
        else{
            if(x < stack2.peek())
               stack2.push(x);
            else 
               stack2.push(stack2.peek());   
        }   
    }
    
    public void pop() {
        stack1.pop();
        stack2.pop();
    }
    
    public int top() {
        return stack1.peek();
    }
    
    public int min() {
       return stack2.peek();
    }
}

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。需要注意访问过的结点，判断递归结束的条件等。

class Solution {
    public boolean exist(char[][] board, String word) {
        char[] words = word.toCharArray();
        for(int i = 0; i < board.length; i++) {
            for(int j = 0; j < board[0].length; j++) {
                if(dfs(board, words, i, j, 0)) return true;
            }
        }
        return false;
    }
    boolean dfs(char[][] board, char[] word, int i, int j, int k) {
        if(i >= board.length || i < 0 || j >= board[0].length || j < 0 || board[i][j] != word[k]) return false;
        if(k == word.length - 1) return true;
        char tmp = board[i][j];
        board[i][j] = '/';
        boolean res = dfs(board, word, i + 1, j, k + 1) || dfs(board, word, i - 1, j, k + 1) || 
                      dfs(board, word, i, j + 1, k + 1) || dfs(board, word, i , j - 1, k + 1);
        board[i][j] = tmp;
        return res;
    }
}

2.3 机器人的运动范围（回溯法）

题目大致描述：一个m行n列的方格，一个机器人从坐标（0,0）开始，可以向上下左右移动一格，但不能进入坐标的数位和大于k的格子。求机器人最多可以进入多少个格子。

思路：可以利用回朔法，从（0,0）开始进行递归，没走一步就判断是否符合条件。注意的就是需要定义一个辅助二维数组标记是否重复计算，并定义一个全局变量，记录符合条件的格子。

//统计到达的数量
int counts=0;
public int movingCount(int m, int n, int k) {
    //辅助数组 用来标记是否统计过
    int[][] visited = new int[m][n];
    //从 0,0位置开始统计
    helper(visited,0,0,m-1,n-1,k);
    return counts;
}

/**
*传入i,j两点 判断当前点是否符合规则 符合规则下继续对下右两个方向递归判断
*/
private void helper(int[][] visited,int i,int j,int m,int n,int k){
    if(i<=m&&j<=n&&visited[i][j]!=1&&(indexSum(i)+indexSum(j))<=k){
        counts++;
        visited[i][j]=1;
        helper(visited,i+1,j,m,n,k);
        helper(visited,i,j+1,m,n,k);
    }
}

/**
*根据传入的数 求出各位上的数字累加和
*/
private int indexSum(int index){
    int sum = index%10;
    int tmp = index/10;
    while(tmp>0){
        sum+=tmp%10;
        tmp/=10;
    }
    return sum;
}

2.4 剪绳子（动态规划，贪心算法）

题目大致描述：一根长度为n的绳子，请把绳子剪成m段（m>0）,求绳子最大乘积。

思路一：采用动态规划法

思路二：采用贪婪算法

class Solution {
    public int cuttingRope(int n) {
        if(n <= 3) return n - 1;
        int a = n / 3, b = n % 3;
        if(b == 0) return (int)Math.pow(3, a);
        if(b == 1) return (int)Math.pow(3, a - 1) * 4;
        return (int)Math.pow(3, a) * 2;
    }
}

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];
    }
}

题目二：给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数。你可以对一个单词进行如下三种操作：插入一个字符、删除一个字符、替换一个字符。

思路：动态规划。

class Solution {
  public int minDistance(String word1, String word2) {
    int n = word1.length();
    int m = word2.length();

    // 有一个字符串为空串
    if (n * m == 0)
      return n + m;

    // DP 数组
    int [][] D = new int[n + 1][m + 1];

    // 边界状态初始化
    for (int i = 0; i < n + 1; i++) {
      D[i][0] = i;
    }
    for (int j = 0; j < m + 1; j++) {
      D[0][j] = j;
    }

    // 计算所有 DP 值
    for (int i = 1; i < n + 1; i++) {
      for (int j = 1; j < m + 1; j++) {
        int left = D[i - 1][j] + 1;
        int down = D[i][j - 1] + 1;
        int left_down = D[i - 1][j - 1];
        if (word1.charAt(i - 1) != word2.charAt(j - 1))
          left_down += 1;
        D[i][j] = Math.min(left, Math.min(down, left_down));

      }
    }
    return D[n][m];
  }
}

2.7 数据流中的中位数（堆排序）

题目描述：从一个数据流中得到中位数。

思路：可以采用两个堆，一个是大顶堆存放数据流前半的数据，一个是小顶堆，存放数据的后半段数据。

class MedianFinder {

    PriorityQueue<Integer> minHeap ;
    PriorityQueue<Integer> maxHeap ;
    /** initialize your data structure here. */
    public MedianFinder() {
       minHeap = new PriorityQueue<>();
       maxHeap = new PriorityQueue<>(new Comparator<Integer>(){
           public int compare(Integer t1 , Integer t2){
               return t2 - t1;
           }
       });
    }
    int count = 0;
    public void addNum(int num) {
        count++;
        if(count % 2 == 0){
            if(!maxHeap.isEmpty() && num < maxHeap.peek()){
                maxHeap.add(num);
                num = maxHeap.poll();
            }
            minHeap.add(num);
        }else{
            if(!minHeap.isEmpty() && num > minHeap.peek()){
                minHeap.add(num);
                num = minHeap.poll();
            }
            maxHeap.add(num);
        }
    }
    
    public double findMedian() {
        if(count == 0)
            throw new RuntimeException("操作失败，请先插入数据。");
        if(minHeap.size() == maxHeap.size())
           return (minHeap.peek()+maxHeap.peek())/2.0;
        else if(maxHeap.size()>minHeap.size())
            return maxHeap.peek()/1.0;
        else
            return minHeap.peek()/1.0; 
    }
}

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 第一个只出现一次的字符

题目概述：求字符串中第一个只出现一次的字符。

思路：可以采用空间换时间的方法。借助一个辅助数组，依次遍历字符串计算每个字符的数量，然后找出第一个。

class Solution {
    public char firstUniqChar(String s) {
        char res = ' ';
        if(s == null || s == "")
           return res;
        int[] temp = new int[256];
        for(int i = 0; i < s.length(); ++i){
            temp[s.charAt(i)] += 1;
        }   
        for(int i = 0; i < s.length(); ++i){
            if(temp[s.charAt(i)] == 1){
                res = s.charAt(i);
                break;
            }
        }
        return res;
    }
}

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～10为数字本身，A为1，J为11，Q为12，K为13，而大、小王为 0 ，可以看成任意数字。A 不能视为 14。

思路：先对扑克进行排序，然后计算即可。

class Solution {
    public boolean isStraight(int[] nums) {
        Arrays.sort(nums);
        int zeroCnt=0,diff=0;
        for(int i=0;i<nums.length-1;i++){
            if(nums[i]==0){
                zeroCnt++;
            }else{
                if(nums[i]==nums[i+1]) return false;
                if(nums[i]+1!=nums[i+1]){
                    diff+=nums[i+1]-nums[i]-1;
                }
            }
        }
        return zeroCnt>=diff;
    }
}

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;
    }
}