剑指offer（二）

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第3天，点击查看活动详情

第四题 二位数组中的查找：

class Solution {
    // 线性查找
    public boolean findNumberIn2DArray(int[][] matrix, int target) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return false;
        }
        int rows = matrix.length, columns = matrix[0].length;
        int row = 0, column = columns - 1;
        while (row < rows && column >= 0) {
            int num = matrix[row][column];
            if (num == target) {
                return true;
            } else if (num > target) {
                column--;
            } else {
                row++;
            }
        }
        return false;
    }
}

第五题 替换字符串：

class Solution {
        public String replaceSpace(String s) {
            return s.replace(" ", "%20");
        }
    }

书上解法：

第六题：从头到尾打印链表

class Solution {
    public int[] reversePrint(ListNode head) {
            if(head == null) {
                return new int[0];
            } 
            // 1.3.2
            List<ListNode> list = new ArrayList<>();
            while(head.next != null) {
                list.add(head);
                head = head.next;
            }
            list.add(head);
            int[] res = new int[list.size()];
            int index = 0;
            for(int i = list.size()-1; i>=0;i--) {
                res[index] = (list.get(i).val);
                index++;
            }
            return res;
        }
}

书上写法：

第七题：重建二叉树

树的结构不记得了，直接背答案

class Solution {
    private Map<Integer, Integer> indexMap;

    public TreeNode myBuildTree(int[] preorder, int[] inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right) {
        if (preorder_left > preorder_right) {
            return null;
        }

        // 前序遍历中的第一个节点就是根节点
        int preorder_root = preorder_left;
        // 在中序遍历中定位根节点
        int inorder_root = indexMap.get(preorder[preorder_root]);

        // 先把根节点建立出来
        TreeNode root = new TreeNode(preorder[preorder_root]);
        // 得到左子树中的节点数目
        int size_left_subtree = inorder_root - inorder_left;
        // 递归地构造左子树，并连接到根节点
        // 先序遍历中「从 左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素
        root.left = myBuildTree(preorder, inorder, preorder_left + 1, preorder_left + size_left_subtree, inorder_left, inorder_root - 1);
        // 递归地构造右子树，并连接到根节点
        // 先序遍历中「从 左边界+1+左子树节点数目 开始到 右边界」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素
        root.right = myBuildTree(preorder, inorder, preorder_left + size_left_subtree + 1, preorder_right, inorder_root + 1, inorder_right);
        return root;
    }

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int n = preorder.length;
        // 构造哈希映射，帮助我们快速定位根节点
        indexMap = new HashMap<>();
        for (int i = 0; i < n; i++) {
            indexMap.put(inorder[i], i);
        }
        return myBuildTree(preorder, inorder, 0, n - 1, 0, n - 1);
    }

}

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }
}

第九题：用两个栈实现队列

栈是先进后出，队列是先进先出

static class CQueue {
    Deque<Integer> s1;
    Deque<Integer> s2;

    public CQueue() {
        s1 = new ArrayDeque<Integer>();
        s2 = new ArrayDeque<Integer>();
    }

    public void appendTail(int value) {
        s1.push(value);
    }

    public int deleteHead() {
        if(s2.isEmpty()){
            if(s1.isEmpty()){
                return -1;
            }
            while(!s1.isEmpty()){
                s2.push(s1.pop());
            }
        }

        return s2.pop();


    }
}

第十题：斐波那契数列

这题注意超时，所以采用滑动窗口算法，并且在每一次计算之后就取模（取模前后加减法不变）

class Solution {
    
    public int fib(int n) {
        final int MOD = 1000000007;
        int a = 0;
        int b = 0;
        int c = 1;
        if(n==0) return 0;
        else if(n==1) return 1;
        for(int i=2;i<=n;i++){
            a=b;
            b=c;
            c = (a + b) % MOD;
        }
        return c;
    }
}