剑指offer【Java版】持续更新中

03 数组中重复的数字

class Solution {
    public int findRepeatNumber(int[] nums) {
        // 数组的length是属性
        int n = nums.length;
        for(int i = 0; i < n; ){
            if(nums[i] != i && nums[nums[i]] != nums[i]){
                //交换
                int t = nums[nums[i]];
                nums[nums[i]] = nums[i];
                nums[i] = t;
            }else if(nums[i] != i && nums[nums[i]] == nums[i]) return nums[i];
            else if(nums[i]==i) i++;
        }
        return -1;

    }
}

04 二维数组中的查找

class Solution {
    public boolean findNumberIn2DArray(int[][] matrix, int target) {
        // 从右上角或者左下角开始 此处从右上角开始
        int m = matrix.length;
        if(m==0) return false;
        int n = matrix[0].length;
        int i = 0, j = n-1; 
        while(i < m && j >= 0){
            if(matrix[i][j] > target) j--;
            else if(matrix[i][j] < target) i++;
            else return true;
        }
        return false;
    }
}

替换空格

class Solution {
    public String replaceSpace(String s) {
        int n = s.length();
        String res = "";
        for(int i = 0; i < n; i++){
            if(s.charAt(i) !=' '){
                res += s.charAt(i);
            }else res+="%20";
        }
        return res;
    }
}

从尾到头打印链表

• 考点:链表
• 思路:反转链表，用递归实现逆序

class Solution {
    ArrayList<Integer> list = new ArrayList<>();
    public int[] reversePrint(ListNode head) {
        //用递归实现逆序
        reverse(head);
        int[] temp = new int[list.size()];
        for(int i = 0; i < list.size(); i++){
            temp[i] = list.get(i);
        }
       return temp;
    }
    void reverse(ListNode head){
        if(head == null) return;
        reverse(head.next);
        list.add(head.val);
    }
}

07. 重建二叉树

• 注意边界
• 先对中序遍历存储值和下标的映射，可以提高效率

class Solution {
    int[] preorder;
    int[] inorder;
    HashMap<Integer, Integer> mp;

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        //重建二叉树
        this.preorder = preorder;
        this.inorder = inorder;
        mp = new HashMap<>();

        for(int i = 0; i < inorder.length; i++){
            mp.put(inorder[i], i);
        }
        return dfs(0, preorder.length-1, 0, inorder.length-1);
    }

    public TreeNode dfs( int pl, int pr, int il, int ir){
        if(pl > pr) return null;

        TreeNode root = new TreeNode(preorder[pl]);
        int k = mp.get(root.val);

        int left = k - il;
        root.left = dfs(pl+1, pl+left, il, k-1);
        root.right = dfs(pl+left+1, pr, k+1, ir);
        return root;
    }
}

09. 用两个栈实现队列

• 考点：栈和队列

class CQueue {
    Stack<Integer> stk, cache;
    public CQueue() {
        stk = new Stack<>();
        cache = new Stack<>();
    }

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

    public int deleteHead() {
        if(stk.isEmpty()) return -1;
        copy(stk, cache);
        int res = cache.pop();
        copy(cache, stk);
        return res;
    }
    void copy(Stack<Integer> stk, Stack<Integer> cache){
        while(!stk.isEmpty()){
            cache.push(stk.pop());
        }
    }
}

10- I. 斐波那契数列

class Solution {
    /*100以内的斐波那契数列可以用long处理*/
    final int MOD = 1000000007;
    long [] f = new long[103];
    public int fib(int n) {
        f[0] = 0;
        f[1] = 1;
        for(int i = 2; i <= n; ++i){
            f[i] = (f[i-1] + f[i-2]) % MOD;
        }
        return (int)f[n];
    }
}

10- II. 青蛙跳台阶问题

class Solution {
    /*100以内的斐波那契数列可以用long处理*/
    final int MOD = 1000000007;
    long [] f = new long[103];
    public int numWays(int n) {
        f[0] = 1;
        f[1] = 1;
        f[2] = 2;
        for(int i = 2; i <= n; ++i){
            f[i] = (f[i-1] + f[i-2]) % MOD;
        }
        return (int)f[n];
    }
}

11. 旋转数组的最小数字

• 考点：二分法
• 注意：收尾存在重复数值，需要先将数组变成分段的形式才能使用二分。

class Solution {
    public int minArray(int[] nums) {
        int end = nums.length-1;
        if(end==-1) return -1;
        while(end >= 0 && nums[0]==nums[end]) --end;
        int i = 0, j = end;
        while(i < j){
            int mid = (i + j) >> 1;
            if(nums[mid] <= nums[end]) j = mid;
            else i = mid + 1;
        }
        return nums[i];
    }
}

12. 矩阵中的路径

• 考点：深搜+回溯
• 注意：第一点，只有找到满足条件的才返回，没满足条件继续搜。第二点，当前进入dfs的元素要先判断，再考虑四个方向。

class Solution {
    /**
     * 深度搜索+回溯
     * */
    public boolean exist(char[][] board, String word) {
        for(int i = 0; i < board.length; ++i){
            for(int j = 0; j < board[i].length; ++j){
                if(dfs(board, word, i, j, 0)) return true;
            }
        }
        return false;
    }
    int dx[] = {1, -1, 0, 0};
    int dy[] = {0, 0, 1, -1};
    boolean dfs(char[][] board, String word, int x, int y, int u){
        /**
         * 只有一个元素时，进来就要先判断，在处理四周的元素。
         * */
        if(board[x][y] != word.charAt(u)) return false;
        if(u == word.length()-1) return true;
        char c = board[x][y];
        board[x][y] = '.';
        for(int i = 0; i < 4; ++i){
            int a = dx[i] + x;
            int b = dy[i] + y;
            if(a >= 0 && a < board.length && b >= 0 && b < board[a].length){
                if(dfs(board, word, a, b, u+1)) return true;
            }
        }
        board[x][y] = c;
        return false;
    }
}

剑指 Offer 13. 机器人的运动范围

• 思路
  • 不需要回溯

class Solution {
public:
    int dx[4]={1,-1,0,0};
    int dy[4]={0,0,1,-1};
    int res = 0;
    int st[105][105];
    int movingCount(int m, int n, int k) {
            
        memset(st, 0, sizeof st);
        dfs(m, n, 0, 0, k);
        return res;
    }
    void dfs(int m, int n, int x, int y, int k){
        if(x < 0 || x >= m || y < 0 || y >= n || getBitSum(x, y) > k || st[x][y]) return;
        res ++;
        st[x][y] = true;
        for(int i = 0; i < 4; i++){
            int a = dx[i] + x;
            int b = dy[i] + y;
            dfs(m, n, a, b, k);
        }
    }
    int getBitSum(int x, int y){
        return x/100 + x%100/10 + x%10 + y/100 + y%100/10 + y%10;
    }
};

剑指 Offer 14- I. 剪绳子

• 数学思维：智力题

class Solution {
public:
    int cuttingRope(int n) {
        /*数学题  只包含2和3 并且最多两个2  ni >= 5  3*(ni-3) >= ni 4 = 2*2  2*2*2 < 3 * 3 */
        if(n <= 3) return n - 1;
        int res = 1;
        if(n % 3 == 1) res*=4, n-=4;
        if(n % 3 == 2) res*=2, n-=2;
        while(n) res*=3, n-=3;
        return res;
        
    }
};

剑指 Offer 14- II. 剪绳子 II

• 注意转换为long long再取模，不然会溢出。

class Solution {
public:
    const int MOD = 1e9+7; 
    int cuttingRope(int n) {
        if(n <= 3) return n-1;
        
        long long res = 1;
        
        if(n%3==1) res*=4, n-=4;
        if(n%3==2) res*=2, n-=2;
        
        while(n) res=res*3 % MOD, n-=3;
        return res;
    }
};

剑指 Offer 15. 二进制中1的个数

• 一行代码

class Solution {
public:
    int hammingWeight(uint32_t n) {
        return bitset<32>(n).count();
    }
};

• 多行代码

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int count = 0;
        for(int i = 0; i < 32; i++){
            if((n>>i)&1) count++;
        }
        return count;
    }
};

剑指 Offer 16. 数值的整数次方

• 快速幂
• 把指数值转换成了二进制的位数，极大的加快了计算速度。logn

class Solution {
public:
    double myPow(double x, int n) {
        //快速幂
        if(n==0) return 1.0;
        long long t = n > 0 ? n: -(long long) n;
        double res = 1;
        while(t){
            if(t&1) res *= x;
            x *= x;
            t >>= 1;
        }
        if(n < 0) res = 1/res;
        return res;
    }
};

剑指 Offer 17. 打印从1到最大的n位数

• 太简单

class Solution {
public:
    vector<int> printNumbers(int n) {
        vector<int> v;
        const int t = pow(10, n);
        for(int i = 1; i < t; i++){
            v.push_back(i);
        }
        return v;
    }
};

剑指 Offer 18. 删除链表的节点

• 考点：链表

class Solution {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        // 注意处理删除的是头节点
        auto dummy = new ListNode(0);
        dummy->next = head;
        auto p = dummy;
        while(p && p->next){
            if(p->next->val == val){
                p->next = p->next->next;
            }
            p = p->next;
        }
        return dummy->next;
    }
};

剑指 Offer 19. 正则表达式匹配

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

class Solution {
public:
    vector<int> exchange(vector<int>& nums) {
        int i = 0, j = nums.size()-1;
        while(i < j){
            if(!(nums[i]&1)){
                swap(nums[i], nums[j--]);
            }else i++;
        }
        return nums;
    }
};

剑指 Offer 22. 链表中倒数第k个节点

class Solution {
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
        auto dummy = new ListNode(0);
        dummy->next = head;
        auto p = dummy, q = dummy;
        while(k--){
            p = p->next;
        }
        while(p){
            p = p->next;
            q = q->next;
        }
        return q;
    }
};

剑指 Offer 24. 反转链表

• 链表

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* nxt , *pre = nullptr;
        while(head){
            nxt = head->next;
            head->next = pre;
            pre = head;
            head = nxt;
        }
        return pre;
        
    }
};

剑指 Offer 25. 合并两个排序的链表

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        auto dummy = new ListNode(0);
        auto p = dummy;
        
        while(l1 && l2){
            if(l1->val < l2->val) {
                p->next = l1;
                l1 = l1->next;
            }else{
                p->next = l2;
                l2 = l2->next;
            }
            p = p->next;
        }
        if(l1) p->next = l1;
        if(l2) p->next = l2;
        return dummy->next;
    }
};

剑指 Offer 26. 树的子结构

• 二叉树

class Solution {
public:
    bool isSubStructure(TreeNode* A, TreeNode* B) {
        if(!B || !A) return false;
        if(isPart(A, B)) return true;
        return isSubStructure(A->left, B) || isSubStructure(A->right, B);
              
    }
    bool isPart(TreeNode* p, TreeNode* q){
        if(!q) return true; // q只是p的一个部分 可以空
        if(!p || p->val != q->val) return false;
        return isPart(p->left, q->left) && isPart(p->right, q->right);
    }
};

剑指 Offer 27. 二叉树的镜像

• 二叉树

class Solution {
public:
    TreeNode* mirrorTree(TreeNode* root) {
        if(!root) return nullptr;
        mirrorTree(root->left);
        mirrorTree(root->right);
        swap(root->left, root->right);
        return root;
    }
};

剑指 Offer 28. 对称的二叉树

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(!root) return true; //空树是对称的
        return isSame(root->left, root->right);
    }
    bool isSame(TreeNode* p, TreeNode* q){
        if(!p || !q) return p == q;
        if(p->val != q->val) return false;
        return isSame(p->left, q->right) && isSame(p->right, q->left);
    }
};

剑指 Offer 52. 两个链表的第一个公共节点

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        auto p = headA, q = headB;
        while(p != q){
            if(!p) p = headB;
            else p = p->next;
            
            if(!q) q = headA;
            else q = q->next;
        }
        return p;
    }
};

找到两个只出现一次的数字

• 思路：异或这两个数字，找到第一个不同的位，以这个位作为划分规则。

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param array int整型一维数组
     * @return int整型一维数组
     */
    public int[] FindNumsAppearOnce (int[] array) {
        int ans = 0;
        for(int i = 0; i < array.length; i++){
            ans ^= array[i];
        }
        int t = ans, k = 0;
        while(t != 0){
            if(t%2==1){
                break;
            }
            t /= 2;
            k++;
        }
        int sum = 0;
        for(int i = 0; i < array.length; i++){
            if(((array[i]>>>k)&1)==1) sum ^= array[i];
        }
        int a = Math.min(sum, ans^sum);
        int b = Math.max(sum, ans^sum);
        return new int[]{a, b};
    }
}