二叉树相关的算法(一)

最新推荐文章于 2022-10-22 00:11:53 发布

原创最新推荐文章于 2022-10-22 00:11:53 发布 · 160 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #二叉树 #递归

数据结构与算法专栏收录该内容

13 篇文章

订阅专栏

本文深入探讨了二叉树的基本定义及其操作，包括字符串转换、遍历方式（先序、中序、后序）、最大深度计算等核心内容，并提供了详细的Java实现代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

二叉树的定义

// java
public class TreeNode {
     int val;
     TreeNode left;
     TreeNode right;
     TreeNode(int x) { val = x; }
}

把字符串转为二叉树, 字符串形式[1,2,3]

public static TreeNode stringToTreeNode(String input) {
        input = input.trim();
        input = input.substring(1, input.length() - 1);
        if (input.length() == 0) {
            return null;
        }
    
        String[] parts = input.split(",");
        String item = parts[0];
        TreeNode root = new TreeNode(Integer.parseInt(item));
        Queue<TreeNode> nodeQueue = new LinkedList<>();
        nodeQueue.add(root);
    
        int index = 1;
        while(!nodeQueue.isEmpty()) {
            TreeNode node = nodeQueue.remove();
    
            if (index == parts.length) {
                break;
            }
    
            item = parts[index++];
            item = item.trim();
            if (!item.equals("null")) {
                int leftNumber = Integer.parseInt(item);
                node.left = new TreeNode(leftNumber);
                nodeQueue.add(node.left);
            }
    
            if (index == parts.length) {
                break;
            }
    
            item = parts[index++];
            item = item.trim();
            if (!item.equals("null")) {
                int rightNumber = Integer.parseInt(item);
                node.right = new TreeNode(rightNumber);
                nodeQueue.add(node.right);
            }
        }
        return root;
    }

把二叉树转为字符串形式

public static String treeNodeToString(TreeNode root) {
        if (root == null) {
            return "[]";
        }
    
        String output = "";
        Queue<TreeNode> nodeQueue = new LinkedList<>();
        nodeQueue.add(root);
        while(!nodeQueue.isEmpty()) {
            TreeNode node = nodeQueue.remove();
    
            if (node == null) {
              output += "null, ";
              continue;
            }
    
            output += String.valueOf(node.val) + ", ";
            nodeQueue.add(node.left);
            nodeQueue.add(node.right);
        }
        return "[" + output.substring(0, output.length() - 2) + "]";
    }

二叉树的先序遍历
迭代

public List<Integer> preorderTraversal(TreeNode root) {
        
        if(root == null) return new ArrayList<Integer>();
        
        List<Integer> list = new ArrayList<Integer>();
        
        Stack<TreeNode> stack = new Stack<TreeNode>();
        
        // 根节点压栈
        stack.push(root);
        
        while(!stack.empty()){
            
            TreeNode node = stack.pop();
            list.add(node.val);
            
            if(node.right != null){
                stack.push(node.right);
            }
            
            if(node.left != null){
                stack.push(node.left);
            }
        }
        return list;
    }

递归

public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        preorderTraversal1(root, list);
        
        return list;
        
    }
    public void preorderTraversal1(TreeNode root, List<Integer> list){
        
        if(root == null) return;
        list.add(root.val);
        preorderTraversal1(root.left,list);
        preorderTraversal1(root.right,list);
    }

二叉树的中序遍历
迭代

public List<Integer> inorderTraversal(TreeNode root) {
        
        if(root == null) return new ArrayList<Integer>();
        
        List<Integer> list = new ArrayList<Integer>();
        
        Stack<TreeNode> stack = new Stack<TreeNode>();
        
        do{
            
            while(root != null){
                stack.push(root);
                root = root.left;
            }
            
            if(!stack.isEmpty()){
                
                TreeNode node = stack.pop();
                list.add(node.val);
                
                root = node.right;
            }
            
        }while(!stack.isEmpty() || root != null);
        
        return list;
    }

递归

public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        inorderTraversal1(root, list);
        
        return list;
        
    }
    
    public void inorderTraversal1(TreeNode root, List<Integer> list){
        
        if(root == null) return;
        inorderTraversal1(root.left,list);
        list.add(root.val);
        inorderTraversal1(root.right,list);
    }

二叉树的后序遍历
迭代

public List<Integer> postorderTraversal(TreeNode root) {
        
        if(root == null) return new ArrayList<Integer>();
        
        List<Integer> list = new ArrayList<Integer>();
        
        Stack<TreeNode> stack = new Stack<TreeNode>();
        
        // 根节点压栈
        stack.push(root);
        
        while(!stack.empty()){
            
            TreeNode node = stack.pop();
            
            if(node.left != null) {
                stack.push(node.left);
            }
            
            if(node.right != null) {
                stack.push(node.right);
            }
            // 
            list.add(0,node.val);
        }
        
        return list;
     
    }

递归

public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        postorderTraversal1(root, list);
        
        return list;
        
    }
    
    public void postorderTraversal1(TreeNode root, List<Integer> list){
        
        if(root == null) return;
        postorderTraversal1(root.left,list);
        postorderTraversal1(root.right,list);
        list.add(root.val);
    }

二叉树的最大深度
迭代

public int maxDepth(TreeNode root) {
        
        if(root == null) return 0;
        
        int height = 0;
        
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        height = root == null ? 0 : 1;
        int num = height, sum = height;
        while(!queue.isEmpty()){
            num = sum;
            sum = 0;
            for(int i = 0; i < num; i++){
                TreeNode node = queue.poll(); 
                
                if(node.left != null){
                    queue.offer(node.left);
                    sum++;
                }
                
                if(node.right != null){
                    queue.offer(node.right);
                    sum++;
                }
            }
             height++;
        
        }
        
        return height == 0 ? 0 : height - 1;
        
    }

递归

public int maxDepth(TreeNode root) {
        if(root == null) return 0;
        return Math.max(maxDepth(root.left),maxDepth(root.right)) + 1;
    }