剑指offer刷题笔记day2-3

05 替换空格

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

示例 1：

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

限制：

0 <= s 的长度 <= 10000

很快做出来惹，但是执行的时间太长了啊…

 public String replaceSpace(String s) {
        String ss="";
        for (int i=0;i<s.length();i++){
            if (s.charAt(i)!=' '){
                ss+=s.charAt(i);
                continue;
            }
            ss+="%20";
        }
        return ss;
    }

用自带的函数

public static String replace(String s){
        return s.replace(" ","%20");
    }

C的解法（在原字符串上进行操作）
① 在字符串尾部填充任意字符，使得字符串的长度等于替换之后的长度。因为一个空格要替换成三个字符（%20），所以当遍历到一个空格时，需要在尾部填充两个任意字符。

② 令 P1 指向字符串原来的末尾位置，P2 指向字符串现在的末尾位置。P1 和 P2 从后向前遍历，当 P1 遍历到一个空格时，就需要令 P2 指向的位置依次填充 02%（注意是逆序的），否则就填充上 P1 指向字符的值。从后向前遍是为了在改变 P2 所指向的内容时，不会影响到 P1 遍历原来字符串的内容。

③ 当 P2 遇到 P1 时（P2 <= P1），或者遍历结束（P1 < 0），退出。

public String replaceSpace(StringBuffer str) {
    int P1 = str.length() - 1;
    for (int i = 0; i <= P1; i++)
        if (str.charAt(i) == ' ')
            str.append("  ");

    int P2 = str.length() - 1;
    while (P1 >= 0 && P2 > P1) {
        char c = str.charAt(P1--);
        if (c == ' ') {
            str.setCharAt(P2--, '0');
            str.setCharAt(P2--, '2');
            str.setCharAt(P2--, '%');
        } else {
            str.setCharAt(P2--, c);
        }
    }
    return str.toString();
}

06 从尾到头打印链表

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

示例 1：

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

限制：

0 <= 链表长度 <= 10000

俺自己的方法有点笨，但是蛮好想

在牛客上看了一种方法，比较简单，用到了list里面的一个add函数，但这是第一次见且比较容易出错，把一篇相关的博客贴到这
转载自：https://blog.csdn.net/qq_27093465/article/details/55211722

add（index ， element）。这个不仅仅是把index位置的数据给替换啦，而且把之前这个位置的数据给依次向后移动啦

import java.util.*;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list = new ArrayList<>();
        ListNode tmp = listNode;
        while(tmp!=null){
            list.add(0,tmp.val);
            tmp = tmp.next;
        }
        return list;
    }
}

用栈来实现：

 public static int[] reversebystack(ListNode listNode){
        Stack<Integer> stack=new Stack();
        ListNode tmp=listNode;
        while (tmp!=null){
            int n=tmp.val;
            tmp=tmp.next;
            stack.push(n);
        }
        int[] r=new int[stack.size()];
        for (int i = 0; i <r.length ; i++) {
            r[i]= stack.pop();
        }
        return r;
    }

递归：

public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
    ArrayList<Integer> ret = new ArrayList<>();
    if (listNode != null) {
        ret.addAll(printListFromTailToHead(listNode.next));
        ret.add(listNode.val);
    }
    return ret;
}

07 重建二叉树(medium)

输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]

返回如下的二叉树：

    3
   / \
  9  20
    /  \
   15   7

限制：

0 <= 节点个数 <= 5000

考研的时候经常做，不过那是手动模拟…第一次正儿八经做树的题目
思路：前序遍历的第一个值为根节点的值，使用这个值将中序遍历结果分成两部分，左部分为树的左子树中序遍历结果，右部分为树的右子树中序遍历的结果。然后分别对左右子树递归地求解。（很容易明白但是俺就是不会写出来）

代码：

public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder.length==0||inorder.length==0){
            return null;
        }
        TreeNode treeNode=new TreeNode(preorder[0]);
        int index=-1;
        for (int i = 0; i <inorder.length ; i++) {
            if (inorder[i]==preorder[0]) {//在中序中找到前序的根
                index = i;
                break;
            }
        }
        treeNode.left=buildTree(Arrays.copyOfRange(preorder,1,index+1),Arrays.copyOfRange(inorder,0,index));
        //注意 copyOfRange 函数，左闭右开
        treeNode.right=buildTree(Arrays.copyOfRange(preorder,index+1,preorder.length),Arrays.copyOfRange(inorder,index+1,inorder.length));
        return treeNode;
    }

09 用两个栈实现队列

之前做过，这里就再敲一遍熟悉一下

public class CQueue {
    /**
     * Your CQueue object will be instantiated and called as such:
     * CQueue obj = new CQueue();
     * obj.appendTail(value);
     * int param_2 = obj.deleteHead();
     */
    private Stack<Integer> stackin=new Stack<Integer>();
    private Stack<Integer> stackout=new Stack<Integer>();
    public CQueue() {

    }

    public void appendTail(int value) {//在队尾插入整数
        stackin.push(value);

    }

    public int deleteHead() {//在队头删除整数
        if(stackin.empty()&&stackout.empty()){
            return -1;
        }
        if (stackout.empty())
            while (!stackin.empty())
                stackout.push(stackin.pop());

        return stackout.pop();
        }

    }

10-1 斐波那契数列

写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项。斐波那契数列的定义如下：

F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.

斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

示例 1：

输入：n = 2
输出：1

示例 2：

输入：n = 5
输出：5

提示：

0 <= n <= 100

非递归的普通想法比较简单，循环求余法：

 public int fib(int n) {
       
       if (n<=1) return n;
        long f=0,g=1,res=0;
        for (int i = 2; i <= n ; i++) {
            res=(f+g)%1000000007;
            f=g;
            g=res;
        }
        return (int)res;
    }

用递归会超时，用动态规划的话在牛客上运行没有问题（n<=39），在这个n太大了了要考虑大数的问题（ps:我压根没看到让取余）

10-2 青蛙跳台阶问题

一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

示例 1：

输入：n = 2
输出：2

示例 2：

输入：n = 7
输出：21

提示：

0 <= n <= 100

就是菲波那切数列变了个样子

public static int num(int n){
        if (n<=1){
            return 1;
        }
        int f=1,b=1,r=0;
        for (int i=2;i<=n;i++){
            r=(f+b)%1000000007;
            f=b;
            b=r;
        }
        return r;
    }

11 旋转数组的数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。

示例 1：

输入：[3,4,5,1,2]
输出：1

示例 2：

输入：[2,2,2,0,1]
输出：0

我直接写的没有啥技巧，但是看题解很多用了二分法
贴个题解在这
https://cyc2018.github.io/CS-Notes/#/notes/11.%20%E6%97%8B%E8%BD%AC%E6%95%B0%E7%BB%84%E7%9A%84%E6%9C%80%E5%B0%8F%E6%95%B0%E5%AD%97