leetcode剑指offer

数组中重复的数字

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

**package leetcode;


import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class Solution {
    public int findRepeatNumber(int[] nums) {
        //第一种方法，使用set容器
//        Set<Integer> set =new HashSet<>();
//        for(int num : nums)
//        {
//            if(set.contains(num))return num;
//            set.add(num);
//        }
//        return -1;
        //第二种方法，原地交换。因为题目中提到数字大小小于数组长度，所以采用数组index作为“中间人”，先将数字放入对应的下标下，如果再找到相同的数字，则返回即可。
        int size=nums.length;
        int i=0;
        while(i<size){
            if(nums[i]==i)
            {
                i++;
                continue;
            }
            if(nums[nums[i]]==nums[i]){
                return nums[i];
            }
            //刚开始交换的时候，还是像交换a,b,c 一样写。然后运行不出来，后来发现这两个需要交换的变量之间有关联，在交换时一定要将temp变量替换到位。
            int temp =nums[i];
            nums[i]=nums[temp];
            nums[temp]=temp;
        }
        return -1;
    }

    public static void main(String[] args) {
        Solution a= new Solution();
        int[] nums={2, 3, 1, 0, 2, 5, 3};
        System.out.println(a.findRepeatNumber(nums));
    }
}
**

二维数组中的查找

在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
示例:

现有矩阵 matrix 如下：

[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]
给定 target = 5，返回 true。

给定 target = 20，返回 false。

    //题目所给数组是有序数组，从右上角或者坐下角进行排序
    public boolean findNumberIn2DArray(int[][] matrix, int target) {
        //题目显示数组越界，当输入为[]时。这是二维数组不为空，判断长度是否为0，为0直接返回即可。
        if(matrix.length==0) return false;
        int i=0;
        int j=matrix[0].length-1;
        while(i<matrix.length&&j>=0){
            if(matrix[i][j]==target)return true;
            if(matrix[i][j]>target)j--;
            else if(matrix[i][j]<target)i++;
        }
        return false;
    }

替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

示例 1：

输入：s = “We are happy.”
输出：“We%20are%20happy.”
方法一：

    public String replaceSpace(String s) {
        //将空格替换为“%20”,最终数组长度一定小于3倍的字符串长度
        char[] arry=new char[s.length()*3];
        int i=0,j=0;
        while(i<s.length())
        {
            if(s.charAt(i)!=' '){
                arry[j++]=s.charAt(i);
            }
            else{
                arry[j]='%';
                arry[j+1]='2';
                arry[j+2]='0';
                j=j+3;
            }
            i++;
        }
        String newStr=new String(arry,0,j);
        return newStr;
    }

最后将字符数组转化为字符串时遇到了一点问题，下面直接看

方法二：

    public String replaceSpace(String s) {
        StringBuffer str=new StringBuffer();
        for(int i=0;i<s.length();i++){
            if(s.charAt(i)==' ')str.append("%20");
            else str.append(s.charAt(i));
        }
        String newStr=str.toString();
        return newStr;
    }

关于String、StringBuffer、StringBuilder的区别

从尾到头打印链表

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

示例 1：

输入：head = [1,3,2]
输出：[2,3,1]

   public int[] reversePrint(ListNode head) {
        Stack<ListNode> stack=new Stack<>();
        while(head!=null)
        {
            stack.push(head);
            head=head.next;
        }
        int[] array=new int[stack.size()];
        int i=0;
        while(stack.size()!=0){
            array[i++]=stack.pop().val;
        }
        return array;
    }

重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请构建该二叉树并返回其根节点。

假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
Output: [3,9,20,null,null,15,7]
示例 2:

Input: preorder = [-1], inorder = [-1]
Output: [-1]
下面贴的是大佬的代码

HashMap<Integer, Integer> map = new HashMap<>();//标记中序遍历
    int[] preorder;//保留的先序遍历，方便递归时依据索引查看先序遍历的值

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        this.preorder = preorder;
        //将中序遍历的值及索引放在map中，方便递归时获取左子树与右子树的数量及其根的索引
        for (int i = 0; i < inorder.length; i++) {
            map.put(inorder[i], i);
        }
        //三个索引分别为
        //当前根的的索引
        //递归树的左边界，即数组左边界
        //递归树的右边界，即数组右边界
        return recur(0,0,inorder.length-1);
    }

    TreeNode recur(int pre_root, int in_left, int in_right){
        if(in_left > in_right) return null;// 相等的话就是自己
        TreeNode root = new TreeNode(preorder[pre_root]);//获取root节点
        int idx = map.get(preorder[pre_root]);//获取在中序遍历中根节点所在索引，以方便获取左子树的数量
        //左子树的根的索引为先序中的根节点+1
        //递归左子树的左边界为原来的中序in_left
        //递归左子树的右边界为中序中的根节点索引-1
        root.left = recur(pre_root+1, in_left, idx-1);
        //右子树的根的索引为先序中的 当前根位置 + 左子树的数量 + 1
        //递归右子树的左边界为中序中当前根节点+1
        //递归右子树的右边界为中序中原来右子树的边界
        root.right = recur(pre_root + (idx - in_left) + 1, idx+1, in_right);
        return root;

    }