【第二天】

替换空格

题目

请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

解题

第一种：可以定义一个StringBuffer 对象 ret，然后 遍历参数 str，一个个添加到 ret中，遇到空格添加 “%20”

第二种：先计算空格的数量，然后将参数 str 的长度设置为 str.length + space_count * 2；最后两个指针（一个是原字符串的长度 - 1，一个是新长度 - 1），最后从后向前遍历，不是空格就复制到后面，是空格就添加 “%20”

public String replaceSpace(StringBuffer str) {
        int count = 0; // 空格次数
        for (int i = 0; i < str.length(); i++) {
            if(str.charAt(i) == ' ') {
                count++;
            }
        }

        int new_length = str.length() + count * 2;
        int old_end = str.length()-1;
        int new_end = new_length-1;
        str.setLength(new_length);  // 设置str的长度，String类没有此方法
        while(old_end>=0 && new_end>=0) {
            if(str.charAt(old_end) == ' ') {
                str.setCharAt(new_end--,'0');
                str.setCharAt(new_end--,'2');
                str.setCharAt(new_end--,'%');
                old_end--;
            } else {
                str.setCharAt(new_end,str.charAt(old_end));
                new_end--;
                old_end--;
            }
        }

        return str.toString();
    }

从尾到头打印链表

题目

输入一个链表，按链表从尾到头的顺序返回一个ArrayList。

example

解题

第一种：借助栈

第二种：直接用ArrayList存，然后 Collections.reverse(ArrayList)

第三中：递归

public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list = new ArrayList<>();
        printListFromTailToHeadHelper(listNode,list);

        return list;
    }

    private void printListFromTailToHeadHelper(ListNode listNode, ArrayList<Integer> list) {
        if(listNode == null) {
            return;
        }
        printListFromTailToHeadHelper(listNode.next,list);
        list.add(listNode.val);
    }

斐波那契数列

题目

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。

example

解题

第一种：迭代遍历（最推荐）

第二种：递归（空间复杂度极高，一般OJ都会超时）

第三种：递归 + 剪枝（避免重复计算，将计算过的内容进行存储，需要用的时候直接取）

private HashMap<Integer,Integer> map = new HashMap<>(); // 用map来存

    public int Fibonacci(int n) {
        if(n == 0) return 0;
        if(n == 1 || n == 2) return 1;

        int prev = 0;  // fib(n-1)
        if(map.get(n-1) == null) {
            // 如果n-1的对于的value没有值，就代表没存过，就要计算，然后存储
            prev = Fibonacci(n-1);
            map.put(n-1,prev);
        } else {
            // 找到就直接拿出来
            prev = map.get(n-1);
        }

        int pprev = 0;  // fib(n-2)
        if(map.get(n-2) == null) {
            pprev = Fibonacci(n-2);
            map.put(n-2,pprev);
        } else {
            // 找到就直接拿出来
            pprev = map.get(n-2);
        }

        return pprev + prev;
    }

重建二叉树

题目

输入一棵二叉树的 前序遍历 + 中序遍历，来构建原二叉树

example

解题

分治的思想，利用前序遍历是从 root 开始的，来在 中序遍历中分出根节点的 左树和右数，然后递归构建 root.left + root.right

注意：递归的时候，前序遍历的区间

// 闭区间
    public TreeNode reConstructBinaryTreeHelper(int[] pre, int pre_start, int pre_end,
                                                int[] vin, int vin_start, int vin_end) {
        // 递归出口
        if(pre_start > pre_end || vin_start > vin_end) {
            return null;
        }

        // 1. 先根据前序遍历拿到根节点
        TreeNode root = new TreeNode(pre[pre_start]);
        // 2. 在中序遍历中，查找root所在的下标
        for (int i = vin_start; i <= vin_end; i++) {
            if(vin[i] == pre[pre_start]) {
                // [vin_start,i-1]这是左子树
                // i 根节点
                // [i+1,vin_end] 这是右子树
                root.left = reConstructBinaryTreeHelper(pre, pre_start+1, pre_start+i-vin_start,
                                                        vin, vin_start, i-1);
                // 前序的起始下标：左子树的结束下标+1
                root.right = reConstructBinaryTreeHelper(pre, pre_start+i-vin_start + 1, pre_end,
                                                        vin, i+1, vin_end);
                break;
            }
        }
        return root;
    }

    public TreeNode reConstructBinaryTree(int [] pre,int [] vin) {
        if(pre == null || vin == null) {
            return null;
        }

        if(pre.length == 0 || vin.length == 0 || pre.length != vin.length) {
            return null;
        }

        return reConstructBinaryTreeHelper(pre, 0, pre.length-1, vin, 0, vin.length-1);
    }