算法题day02

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

解：思路：由于java中字符串是不可修改的，所以应选用stringbuilder来操作字符串，当遍历过程中遇见空格，则加入%20
时间复杂度：O(n)。遍历字符串 s 一遍。
空间复杂度：O(n)。额外创建字符数组，长度为 s 的长度的 3 倍。

class Solution {
    public String replaceSpace(String s) {
        StringBuilder res = new StringBuilder();
        for(Character c :s.toCharArray()){
            if(c == ' '){
                res.append("%20");
            }else{
                res.append(c);
            }
        }
        return res.toString();
    }
}

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

解：方法1递归法，利用链表的下一个节点是否为空作为判断条件，然后不断回溯，将节点值加入到列表中，然后讲列表转换为数组
时间复杂度 O(N)O(N)： 遍历链表，递归 NN 次。
空间复杂度 O(N)O(N)： 系统递归需要使用 O(N)O(N) 的栈空间。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    ArrayList<Integer> temp = new ArrayList<Integer>();
    public int[] reversePrint(ListNode head) {
        rec(head);
        int[] res = new int[temp.size()];
        for(int i = 0;i<res.length;i++){
            res[i] = temp.get(i);
        }
        return res;
    }
    public void rec(ListNode head){
        if(head == null){
            return ;
        }else{
            rec(head.next);
            temp.add(head.val);
        }
    }
}

方法2利用栈的特性，先进后出，正好可以倒序输出输入的内容
时间复杂度：O(n)O(n)。正向遍历一遍链表，然后从栈弹出全部节点，等于又反向遍历一遍链表。
空间复杂度：O(n)O(n)。额外使用一个栈存储链表中的每个节点。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
        Stack<ListNode> stack = new Stack<ListNode>();
        ListNode temp = head;
        while (temp != null) {
            stack.push(temp);
            temp = temp.next;
        }
        int size = stack.size();
        int[] print = new int[size];
        for (int i = 0; i < size; i++) {
            print[i] = stack.pop().val;
        }
        return print;
    }
}

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

解：使用递归方式，
问题：
①如何构建Tree？
<1>节点value
<2>构建left节点
<3>构建right节点
②如何构建left、right节点？
找到两搁节点的前序数组+中序数组
思路：
<1>构建一个找根的index函数
<2>写递归表达式
<3>写递归出口

/**
 - Definition for a binary tree node.
 - public class TreeNode {
 -     int val;
 -     TreeNode left;
 -     TreeNode right;
 -     TreeNode(int x) { val = x; }
 - }
 */
class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder == null||preorder.length == 0){
            return null;
        }
        //1.获取根节点的value值
        TreeNode root = new TreeNode(preorder[0]);
        
        int index = findIndex(preorder,inorder);
        //2.构建左子树和右子树
        root.left = buildTree(Arrays.copyOfRange(preorder,1,index+1),
                              Arrays.copyOfRange(inorder,0,index));
        root.right = buildTree(Arrays.copyOfRange(preorder,index+1,preorder.length),
                               Arrays.copyOfRange(inorder,index+1,inorder.length));
        return root;
    }
    //构建在中序数组中找根的index函数
    public int findIndex(int[] preorder,int[] inorder){
        for(int i = 0;i<inorder.length;i++){
            if(inorder[i] == preorder[0]){
                return i;
            }
        }
        return -1;
    }
}

4.用两个栈实现队列
用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

解：

• 维护两个栈，第一个栈支持插入操作，第二个栈支持删除操作。
  根据栈先进后出的特性，我们每次往第一个栈里插入元素后，第一个栈的底部元素是最后插入的元素，第一个栈的顶部元素是下一个待删除的元素。为了维护队列先进先出的特性，我们引入第二个栈，用第二个栈维护待删除的元素，在执行删除操作的时候我们首先看下第二个栈是否为空。如果为空，我们将第一个栈里的元素一个个弹出插入到第二个栈里，这样第二个栈里元素的顺序就是待删除的元素的顺序，要执行删除操作的时候我们直接弹出第二个栈的元素返回即可。
  成员变量
  维护两个栈 stack1 和 stack2，其中 stack1 支持插入操作，stack2 支持删除操作 构造方法
  初始化 stack1 和 stack2 为空 插入元素
  插入元素对应方法 appendTail
  stack1 直接插入元素 删除元素
  删除元素对应方法 deleteHead
  如果 stack2 为空，则将 stack1 里的所有元素弹出插入到 stack2 里 如果 stack2 仍为空，则返回 -1，否则从
  stack2 弹出一个元素并返回

class CQueue {
    LinkedList<Integer> A, B;
    public CQueue() {
        A = new LinkedList<Integer>();
        B = new LinkedList<Integer>();
    }
    public void appendTail(int value) {
        A.addLast(value);
    }
    public int deleteHead() {
        if(!B.isEmpty()) return B.removeLast();
        if(A.isEmpty()) return -1;
        while(!A.isEmpty())
            B.addLast(A.removeLast());
        return B.removeLast();
    }
}