替换空格、从尾到头打印链表、重建二叉树

替换空格

/**
*@Description: 将字符串中所有的空格替换为%
*@Author： dyy
*/

public class ReplaceSpace {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str1 = sc.nextLine();
        System.out.println(replaceSpace1(new StringBuffer(str1)));
        System.out.println(replaceSpace2(new StringBuffer(str1)));
    }

    //解法一
    public static String replaceSpace1(StringBuffer str){
        //将StringBuffer转化为String
        String string =  str.toString();
        //将String类型转化为数组类型
        char[] ch = string.toCharArray();
        //定义初始化新的StringBuffer
        StringBuffer sb = new StringBuffer();
        for(int i = 0; i <ch.length;i++){
            //若未空格，则令新StringBuffer中的元素变为“%20”
            if(ch[i]==' '){
                sb.append("%20");
            }else{
                //非空格直接拼接
                sb.append(ch[i]);
            }
        }
        //将StringBuffer类型转化为String类型
        return sb.toString();
    }

//解法二
    public static String replaceSpace2(StringBuffer str){
        //直接将StringBuffer类型转化成String类型，使用替换函数replaceAll
        return str.toString().replaceAll(" ","%20");
    }
}

从尾到头打印单链表

import java.util.ArrayList;
import java.util.Stack;

/**
*@Description: 从尾到头打印链表
*@Author： dyy
*/
class ListNode {
    int val;
    ListNode next = null;
    ListNode(int val) {
        this.val = val;
    }
}
public class PrintListFromTailToHead {
    public static void main(String[] args) {
    }
//解法一：利用栈的特性（先进后出）——我们可以先遍历单链表使得其入栈，而后进行出栈操作
    public ArrayList<Integer> printListFromTailToHead1(ListNode listNode){
        //创建栈
        Stack<Integer> stack = new Stack<>();
        //创建新的ArrayList用来保存出栈元素
        ArrayList<Integer> list = new ArrayList<>();
        ListNode temp = listNode;
        while (temp!=null){
            //入栈操作
            stack.push(temp.val);
            temp = temp.next;
        }
        while (!stack.isEmpty()){
            //栈非空，进行出栈操作并向list中插入元素
            list.add(stack.pop());
        }
        return list;
    }


    //解法二：利用递归操作实现
    ArrayList<Integer> list = new ArrayList<>();
    public ArrayList<Integer> printListFromTailToHead2(ListNode listNode){
        if(listNode!=null){
            //进行递归，直至listNode==null（递归出口）
            this.printListFromTailToHead2(listNode.next);
            list.add(listNode.val);
        }
        return list;
    }
}

重建二叉树

/**
*@Description: 重建二叉树
*@Author： dyy
*/
class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;
    public TreeNode(int x){
        val = x;
    }
}
public class ReConstructBinaryTree {
    public static void main(String[] args) {

    }
    //重建二叉树（pre为先序遍历数组，in为中序遍历数组）
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        //当先序、中序序列一个为空或先序和中序序列长度不一样时，则无法进行重建，返回null
        if(pre.length==0||in.length==0||pre.length!=in.length){
            return null;
        }
        //树的根节点（一定是先序遍历的第一个节点）
        TreeNode root = new TreeNode(pre[0]);
        //根据中序遍历将其划分为左子树和右子树的两个中序遍历
        //用来记录左子树序列的长度
        int len = 0;
        //在中序遍历中找根节点，来进行划分
        while (in[len]!=root.val){
            len++;
        }
        //新的先序遍历左子树
        int[] preLeft = new int[len];
        //新的中序遍历左子树
        int[] inLeft = new int[len];
        //新的先序遍历右子树
        int[] preRight = new int[pre.length-len-1];
        //新的中序遍历右子树
        int[] inRight = new int[in.length-len-1];
        //进行赋值操作
        for(int j = 0; j < in.length;j++){
            if(j<len){
                preLeft[j] = pre[j+1];
                inLeft[j] = in[j];
            }else if(j>len){
                preRight[j-len-1] = pre[j];
                inRight[j-len-1] = in[j];
            }
        }
        //分别在左右子树中进行递归
        root.left = reConstructBinaryTree(preLeft,inLeft);
        root.right = reConstructBinaryTree(preRight,inRight);
        return root;
    }
}