LeetCode剑指Offer刷题总结(一)

LeetCode过程中值得反思的细节

以下题号均指LeetCode剑指offer题库中的题号

本文章将每周定期更新,当内容达到10题左右时将会开下一节。

二维数组越界问题04

public static void main(String[] args) {
    int[][]x = {{}};
    System.out.println(x.length+" "+x[0].length);
    int[][]y = {{1}};
    System.out.println(y.length+" "+y[0].length);
    int[][]z = {};
    System.out.println(z.length);
}

image-20210331232106168

在遇到二维数组时,要注意为空的不同情况

String和char[]的相互转换05

char[] s = {'a','b','c'};
String s1 = new String(s); //这里为String的构造函数
String s2 = "abc";
System.out.println(s1.equals(s2));
System.out.println(s1.equals(s));
System.out.println(s2.equals(s));

char[] s3 = new char[8];
s3[0]='a';s3[1]='b';s3[2]='c';
String s4 = new String(s3);
System.out.println(s4.equals(s2));
System.out.println(s2.equals(s4.trim()));//或者括号内为new String(s3,0,3)   String(char[],off,length)

注意,char[]强制转换为String,相互比较结果不经处理恒为false。

原因:由equals源码决定

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String aString = (String)anObject;
        if (!COMPACT_STRINGS || this.coder == aString.coder) {
            return StringLatin1.equals(value, aString.value);
        }
    }
    return false;
}

String对象的内部也是一个char数组,通过char数组创建String时,如果不指定start和count,会将使用整个数组,即连同后面的空字符,输出结果不会受到影响。另外,String.trim()就是删除String 的char数组 前后的空白字符和空字符,使用trim()后再比较就得到值完全一样的String了。

集合数组互转06

    // int[] 转 List<Integer>
    List<Integer> list1 = Arrays.stream(data).boxed().collect(Collectors.toList());
    // Arrays.stream(arr) 可以替换成IntStream.of(arr)。
    // 1.使用Arrays.stream将int[]转换成IntStream。
    // 2.使用IntStream中的boxed()装箱。将IntStream转换成Stream<Integer>。
    // 3.使用Stream的collect(),将Stream<T>转换成List<T>,因此正是List<Integer>。
 
    // int[] 转 Integer[]
    Integer[] integers1 = Arrays.stream(data).boxed().toArray(Integer[]::new);
    // 前两步同上,此时是Stream<Integer>。
    // 然后使用Stream的toArray,传入IntFunction<A[]> generator。
    // 这样就可以返回Integer数组。
    // 不然默认是Object[]。
 
    // List<Integer> 转 Integer[]
    Integer[] integers2 = list1.toArray(new Integer[0]);
    //  调用toArray。传入参数T[] a。这种用法是目前推荐的。
    // List<String>转String[]也同理。
 
    // List<Integer> 转 int[]
    int[] arr1 = list1.stream().mapToInt(Integer::valueOf).toArray();
    // 想要转换成int[]类型,就得先转成IntStream。
    // 这里就通过mapToInt()把Stream<Integer>调用Integer::valueOf来转成IntStream
    // 而IntStream中默认toArray()转成int[]。
 
    // Integer[] 转 int[]
    int[] arr2 = Arrays.stream(integers1).mapToInt(Integer::valueOf).toArray();
    // 思路同上。先将Integer[]转成Stream<Integer>,再转成IntStream。
 
    // Integer[] 转 List<Integer>
    List<Integer> list2 = Arrays.asList(integers1);
    // 最简单的方式。String[]转List<String>也同理。
 
    // 同理
    String[] strings1 = {"a", "b", "c"};
    // String[] 转 List<String>
    List<String> list3 = Arrays.asList(strings1);
    // List<String> 转 String[]
    String[] strings2 = list3.toArray(new String[0]);

ArrayList.get(); ArrayList.set(index,value);

重建二叉树的两种方法07

根据先序和中序递归还原二叉树

先序:根节点,{左子树},{右子树}

中序:{左子树},根节点,{右子树}

两种思路:递归和迭代

递归:

class Solution {
    private HashMap<Integer,Integer> indexmap = new HashMap<>();

    public TreeNode myBuildTree(int[] preorder, int[] inorder, int preorderleft,int preorderright,int inorderleft,int inorderright){
        if(preorderleft>preorderright)
            return null;
        TreeNode root = new TreeNode(preorder[preorderleft]);
        int inorderroot = indexmap.get(preorder[preorderleft]);
        int prelen = inorderroot - inorderleft;
        root.left = myBuildTree(preorder,inorder,preorderleft+1,preorderleft+prelen,inorderleft,inorderroot-1);
        root.right = myBuildTree(preorder,inorder,preorderleft+prelen+1,preorderright,inorderroot+1,inorderright);
        return root;
    }


    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int len = preorder.length;
        for(int i = 0 ; i < len ; i++){
            indexmap.put(inorder[i],i);
        }
        return myBuildTree(preorder,inorder,0,len-1,0,len-1);
    }
}

将以上算法后四个参数 (int preorderleft,int preorderright,int inorderleft,int inorderright) 分别称为A,B,C,D,则A和B相当于建立的树的先序遍历的左边指针和右边指针,C和D相当于中序遍历的左指针和右指针,用来标记多次遍历过程的左子树边界和右子树边界。

迭代思路中,则需要用到栈stack

可利用deque接口实现stack

  • deque支持两端元素插入和移除的线性集合。 名称deque是“双端队列”的缩写,通常发音为“deck”。 大多数Deque实现对它们可能包含的元素的数量没有固定的限制,但是该接口支持容量限制的deques以及没有固定大小限制的deques。
Deque<TreeNode> stack = new LinkedList<TreeNode>();

stack.peek()取栈顶元素,不弹出

stack.push()压入元素

stack.pop()取栈顶元素,并弹出

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder == null || preorder.length == 0)
            return null;
        int len = preorder.length;
        int index = 0;   //中序遍历的指针
        Deque<TreeNode> stack = new LinkedList<>();
        TreeNode root = new TreeNode(preorder[0]);
        stack.push(root);
        TreeNode node;
        for(int i = 1 ; i < len ; i++){
            if((node = stack.peek()).val != inorder[index]){
                node.left = new TreeNode(preorder[i]);
                stack.push(node.left);
            }
            else{
                while(!stack.isEmpty() && stack.peek().val==inorder[index]){ //stack存当前构造树的左节点,可能会有多个构造的树
                    node = stack.pop();
                    index++;
                }
                node.right = new TreeNode(preorder[i]);
                stack.push(node.right);
            }
        }
        return root;
    }
}

在这个思路中,主要应用中序遍历的第一个元素将是树的左边界,以先序遍历的顺序与该元素进行比较,若根节点与其相同,则无左子树;不同的话即为压入栈的栈顶元素的左节点。这个思路主要在于先序遍历和中序遍历的过程特点,递归主要利用的是先序和中序的结构特点。

重要在于理解:每次遍历过程中,操作的是栈顶元素,而遍历的当前i在栈顶元素的后面。

利用两个栈实现队列 09

队列要实现的是先进先出,而栈实现的是先进后出,所以可以建立两个stack

栈1负责压入元素,而当需要删除的时候,只需将栈1中的元素转入栈2

stack2.push(stack1.pop());

这样的话,栈2中,栈顶元素为最开始添加进去的元素,为队列头,直至栈2删除完后,若栈1还有元素,继续转移,若没有,则返回0。


斐波那契数列 10

此题非常简单,但是实现过程需要注意,利用递归会造成大量的重复计算

建议使用动态规划,开辟两个Int空间记录状态

根据状态转移方程进行计算

Java中int的取值范围为-2147483648到+2147483647,4个字节32位,可思考补码和原码的相关知识

旋转数组的最小数组11(二分查找)

本题乍一看就会考虑到遍历,但是时间复杂度有些高O(n),思考一下有没有更加快的方法

public static int minArray(int[] numbers) {
    int len = numbers.length;
    int low = 0,high = len-1;
    int mid ;
    while(low != high){
        mid = low + (high - low)/2;
        System.out.println(mid);
        if(numbers[mid]>numbers[high])
            low = mid+1;
        if(numbers[mid]<numbers[high])   //正确答案为前加else 
            high = mid;
        else
            high--;
    }
    System.out.println(low+" "+high+" "+len);
    return numbers[low];
}

注意,这个例子容易犯错,在实现if的时候,第一个if判断之后,进行第二个判断,low改变mid却没有改变,注意else

本题的二分查找应用于,numbers[high]这个元素,大于它的一定是ans左边的,小于它的一定是ans右边的,而等于它时,说明numbers[high]不是最小值,将high向左调一位。

矩阵中的路径12(DFS)

这个例子是典型的深度搜索,思路比较容易想到

但是需要注意的点为:

每次深搜结束后,需要还原矩阵,不然的话假如本次搜索返回false,下次搜索的时候矩阵已经改变,结果不正确。

机器人运动范围13(BFS)

首先涉及到一个知识点,Java中的break在多重循环中只能跳出所在循环

public static void main(String[] args) {
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            if(j<2)
                System.out.println(i+" "+j);
            else
                break;
        }
    }
}

输出结果为:

此题需要注意的是,范围必须是从[0, 0]出发可达的。本题还是利用一个栈或队列,将新搜索的点添加进去,再出元素,重新搜索。同时需要建立标志位,搜索过的位置就不需要再次搜索。

posted @ 2021-04-10 22:01  GaoYuan206  阅读(46)  评论(0编辑  收藏  举报