剑指offer刷题第二天

1.剑指 Offer 09. 用两个栈实现队列

思路：先append是数据一定是存在栈底的，所以要删除的话，就必须要取出来，不能直接删，可以先将数据从栈中pop出来，然后Push到另一个栈中，这样就变成栈顶元素了，然后pop栈顶元素就可以了。增加尾部数据的话，直接就在第一个栈中加就行了。

代码：

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(stack2.isEmpty()){
            if(stack1.isEmpty()){
                return -1;
            }
            while(!stack1.isEmpty){
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }
}

2.剑指 Offer 10- I. 斐波那契数列

思路：如果用传统的递归，如果深度过大则会导致栈溢出，可以采用动态规划，将前面两个和存起来。

代码：

class Solution{
    public int fib(int n){
        int a = 0,b=1,sum;
        for(int i=0;i<n;i++){
            sum=(a+b)%1000000007;
            a=b;
            b=sum;
        }
        return a;
    }
}

3.剑指 Offer 10- II. 青蛙跳台阶问题

思路：和上上述方法思路差不多，但是有一点要注意，现在没有取余条件

代码：

class Solution{
    public int fib(int n){
        int a = 0,b=0,sum=1;
        for(int i=0;i<n;i++){
            a=b;
            b=sum;
            sum=a+b;
        }
        return sum;
    }
}

4.剑指 Offer 11. 旋转数组的最小数字

思路：这个数组是可以有重复的，如果中间值小于右边值，说明右边是一个递增的数组，那么分界点肯定在左边，由于此时中间值也可能是最小值，所以右指针只能移到中间值来；如果中间值大于了右指针值，则说明分界点肯定在右边，那么将左指针右移；如果中间值等于右指针，这个时候不能判断分界点在哪个区间，所以可以先将右指针减一，再继续二分法。

代码：（有重复数组）

class Solution {
    public int minArray(int[] numbers) {
		int low = 0;
        int hight = numbers.length-1;
        if(hight==0){
            return numbers[0];
        }
        while(low<hight){
            int mid = low + (hight-low)/2;
            if(numbers[mid]<numbers[hight]){
                hight = mid;
            }else if(numbers[mid]>numbers[hight]){
                low = mid+1;
            }else {
                hight=hight-1;
            }
        }
        return numbers[low];
    }
}

无重复数组：

class Solution {
    public int findMin(int[] nums) {
        int left=0,right=nums.length-1;
        while(left<right){
            int mid = left + ((right-left)>>1);
            if(nums[mid]<nums[right]){
                right = mid;
            }else if(nums[mid] >=nums[right]){
                left = mid +1;
            }
        }
        return nums[left];

    }
}

5.剑指 Offer 12. 矩阵中的路径

思路：设函数表示判断以网格的 (i, j)(i,j) 位置出发，能否搜索到单词，其中word[k…] 表示字符串 从第 kk 个字符开始的后缀子串。如果能搜索到，则返回true，反之返回 false。函数check(i,j,k) 的执行步骤如下：

• 如果board[i][j]不等于s[k],则返回false
• 如果当前已经访问到字符串的末尾，且对应字符依然匹配，此时直接返回 true
• 否则，遍历当前位置的所有相邻位置。如果从某个相邻位置出发，能够搜索到子串word[k+1…]，则返回 true，否则返回 false
• 这样，我们对每一个位置 (i,j)(i,j) 都调用函数 check(i,j,0) 进行检查：只要有一处返回 true，就说明网格中能够找到相应的单词，否则说明不能找到。
• 为了防止重复遍历相同的位置，需要额外维护一个与 board 等大的visited 数组，用于标识每个位置是否被访问过。每次遍历相邻位置时，需要跳过已经被访问的位置。

代码：

class Solution {
    public boolean exist(char[][] board, String word) {
        int h=board.length;
        int w=board[0].length;
        boolean[][] visited = new boolean[h][w];
        for(int i=0;i<h;i++){
            for(int j=0;j<w;j++){
                boolean flag= check(board,visited,i,j,word,0);
                if(flag){
                    return true;
                }
            }
        }
        return false;
    }
    
    public boolean check(char[][] board,boolean[][] visited,int i,int j,String s,int k){
        if(board[i][j] != s.charAt(k)){
            return false;
        }else if(k==s.length()-1){
            return true;
        }
        visited[i][j] = true;
        int[][] directions = {{0,1},{0,-1},{1,0},{-1,0}};
        boolean result = false;
        for(int[] dir:directions){
            int newi = i+dir[0];
            int newj = j+dir[1];
           if (newi >= 0 && newi < board.length && newj >= 0 && newj < board[0].length) {
                if (!visited[newi][newj]) {
                    boolean flag = check(board, visited, newi, newj, s, k + 1);
                    if (flag) {
                        result = true;
                        break;
                    }
                }
            }
        }
        visited[i][j] = false;
        return result;
    }
}

或者

    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;
        board[i][j] = '\0';
        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] = word[k];
        return res;
    }