java实现基本二叉树操作

无脑递归就是牛

package 树.basic;

import java.util.*;

/**
 * @Auther: Caojc
 * @Date: 2022/3/19 - 03 - 19 - 13:24
 * @Description: 树.basic
 * @version: 1.0
 */
public class TreeBasic {
    //定义二叉树的存储结构
    static class TreeNode{
        String val;
        TreeNode left;
        TreeNode right;

        public TreeNode() {
        }

        public TreeNode(String val) {
            this.val = val;
        }

        public TreeNode(String val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
    //打印输出
    public static void print(List<String> s){
        for (String str:s){
            if(str.equals(s.get(s.size()-1))){
                System.out.print(str);
               break;
            }
            System.out.print(str+",");
        }
    }
    //构建二叉树
    public static TreeNode createTree(String[] s){
        if(s[0].equals("null")) return null;
        TreeNode root = new TreeNode(s[0]);
        Deque<TreeNode> queue = new LinkedList<>();
        queue.addLast(root);
        int index=1;
        String str;
        while(!queue.isEmpty()){
            TreeNode node=queue.removeFirst();
            if(index==s.length) break;
            str=s[index++].trim();
            if(!"null".equals(str)){
                node.left = new TreeNode(str);
                queue.addLast(node.left);
            }
            if(index==s.length) break;
            str=s[index++].trim();
            if(!"null".equals(str)){
                node.right = new TreeNode(str);
                queue.addLast(node.right);
            }

        }
        return root;

    }
    //层序遍历二叉树
    public static List<String> sequenceTraverse(TreeNode root){
        List<String> res = new ArrayList<>();
        Deque<TreeNode> queue = new LinkedList<>();
        queue.addLast(root);
        while(!queue.isEmpty()){
            TreeNode node=queue.removeFirst();
            res.add(node.val);
            if(node.left!=null) queue.addLast(node.left);
            if(node.right!=null) queue.addLast(node.right);
        }
        return res;
    }
    //先序遍历二叉树递归
    public static List<String> preOrderTraverse(TreeNode root){
        List<String> res = new ArrayList<>();
        preOrder(root,res);
        return res;
    }
    public static void preOrder(TreeNode root,List<String> res){
        if(root==null||root.val.equals("null")) return;
        res.add(root.val);
        preOrder(root.left,res);
        preOrder(root.right,res);
    }
    //先序遍历二叉树迭代
    public static List<String> preOrderTraverse1(TreeNode root){
        if(root.val.equals("null")) return null;
        List<String> res = new ArrayList<>();
        Deque<TreeNode> stack = new LinkedList<>();
        TreeNode node=root;
        while(!stack.isEmpty()||node!=null) {
            while (node != null) {
                res.add(node.val);
                stack.push(node);
                node = node.left;
            }
            node=stack.pop();
            node=node.right;
        }
        return res;
    }
    //中序遍历二叉树递归
    public static List<String> inOrderTraverse(TreeNode root){
        List<String> res = new ArrayList<>();
        inOrder(root,res);
        return res;

    }
    public static void inOrder(TreeNode root,List<String> res){
        //规范点可以抛出异常
        if(root==null||root.val.equals("null")) return;
        inOrder(root.left,res);
        res.add(root.val);
        inOrder(root.right,res);
    }
    //中序遍历二叉树迭代
    public static List<String> inOrderTraverse1(TreeNode root){
        if(root==null||root.val.equals("null")) return null;
        List<String> res = new ArrayList<>();
        Deque<TreeNode> stack=new LinkedList<>();
        TreeNode node=root;
        while (!stack.isEmpty() || node != null) {
            while(node!=null){
                stack.push(node);
                node=node.left;
            }
            node=stack.pop();
            res.add(node.val);
            node=node.right;
        }
        return res;
    }
    //后序遍历二叉树递归
    public static List<String> postOrderTraversal(TreeNode root){
        List<String> res = new ArrayList<>();
        postOrder(root,res);
        return res;

    }
    public static void postOrder(TreeNode root,List<String> res){
        //规范点可以抛出异常
        if(root==null||root.val.equals("null")) return;
        postOrder(root.left,res);
        postOrder(root.right,res);
        res.add(root.val);
    }
    //后序遍历迭代
    public static List<String> postOrderTraversal1(TreeNode root){
        if(root.val.equals("null")) return null;
        List<String> res = new ArrayList<>();
        Deque<TreeNode> stack=new LinkedList<>();
        TreeNode node=root,prev=null;
        while (!stack.isEmpty() || node != null) {
            while(node!=null){
                stack.push(node);
                node=node.left;
            }
            node=stack.pop();
            if(node.right==null||node.right==prev)
            {
                res.add(node.val);
                prev=node;
                node=null;
            }else{
                stack.push(node);
                node=node.right;
            }
        }
        return res;
    }

}

package 树.basic;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

/**
 * @Auther: Caojc
 * @Date: 2022/3/19 - 03 - 19 - 15:51
 * @Description: 树.basic
 * @version: 1.0
 */
public class TreeBasicTest{
    TreeBasic.TreeNode root = new TreeBasic.TreeNode();
    @BeforeEach
    public void init() {
        TreeBasic tree = new TreeBasic();
        String[] s = {"1", "null", "2", "null", "3", "4"};
        root = TreeBasic.createTree(s);
    }
    @Test
    public void testCreate(){
        System.out.println("测试树是否构建成功,并层序遍历输出");
        TreeBasic.print(TreeBasic.sequenceTraverse(root));
    }
    @Test
    public void testPreorderTraverse(){
        System.out.println("测试树的递归和迭代先序遍历是否成功");
        TreeBasic.print(TreeBasic.preOrderTraverse(root));
        System.out.println();
        TreeBasic.print(TreeBasic.preOrderTraverse1(root));
        //Assertions
    }
    @Test
    public void testInOrderTraversal(){
        System.out.println("测试树的递归和迭代中序遍历是否成功");
        TreeBasic.print(TreeBasic.inOrderTraverse(root));
        System.out.println();
        TreeBasic.print(TreeBasic.inOrderTraverse1(root));
    }
    @Test
    public void testPostOrderTraversal(){
        System.out.println("测试树的递归和迭代后序遍历是否成功");
        TreeBasic.print(TreeBasic.postOrderTraversal(root));
        System.out.println();
        TreeBasic.print(TreeBasic.postOrderTraversal1(root));
    }

}