Java实现Leetcode题（二叉树）

打怪兽的Sea

已于 2023-12-26 22:40:41 修改

阅读量778

点赞数 7

分类专栏：数据结构文章标签： java leetcode linux

于 2023-12-21 21:42:19 首次发布

本文链接：https://blog.csdn.net/weixin_47059164/article/details/135139269

版权

数据结构专栏收录该内容

12 篇文章 0 订阅

订阅专栏

Leetcode144(前序遍历)

	//递归
    public static List<Integer> inorderTraversal(TreeNode root){
		List<Integer> list = new ArrayList<>();
		inorder(root,list);
		return list;
	}
	public static void inorder(TreeNode root,List<Integer> list) {
		if(root==null) {
			return;
		}
		list.add(root.val);
		inorder(root.left,list);
		inorder(root.right,list);
	}
    
    //迭代
    public static List<Integer> preorderTraversal(TreeNode root){
		List<Integer> list = new ArrayList<Integer>();
		Deque<TreeNode> de = new LinkedList<>();
		if(root==null) {
			return list;
		}
		de.addFirst(root);
		while(!de.isEmpty()) {
			TreeNode temp = de.peekFirst();
			de.pollFirst();
			list.add(temp.val);
			if(temp.right!=null) {
				de.addFirst(temp.right);
			}
			if(temp.left!=null) {
				de.addFirst(temp.left);
			}
		}
		return list;
	}

Leetcode145（后序遍历）

//迭代法
public static List<Integer> postorderTraversal(TreeNode root){
		List<Integer> list = new ArrayList<>();
		Deque<TreeNode> de = new LinkedList<>();
		if(root==null) {
			return list;
		}
		de.addFirst(root);
		while(!de.isEmpty()) {
			TreeNode temp = de.peekFirst();
			de.pollFirst();
			list.add(temp.val);
			if(temp.left!=null) {
				de.addFirst(temp.left);
			}
			if(temp.right!=null) {
				de.addFirst(temp.right);
			}
		}
		Collections.reverse(list);
		return list;
	}

   //递归
    public static List<Integer> postorderTraversal(TreeNode root){
		List<Integer> list = new ArrayList<>();
		postorder(root,list);
		return list;
	}
	public static void postorder(TreeNode root,List<Integer> list) {
		postorder(root.left,list);
		postorder(root.right,list);
		list.add(root.val);
	}

Leetcode94（中序遍历）

//迭代
public static List<Integer> inorderTraversal(TreeNode root){
		List<Integer> list = new ArrayList<>();
		Deque<TreeNode> de = new LinkedList<>();
		if(root == null) {
			return list;
		}
		TreeNode cur = root;
		while(cur!=null||!de.isEmpty()) {
			if(cur!=null) {
				de.addFirst(cur);
				cur = cur.left;
			}else {
				cur = de.peekFirst();
				list.add(cur.val);
				de.pollFirst();
				cur = cur.right;
			}
		}
		return list;
	}
    //递归
    public static List<Integer> inorderTraveral(TreeNode root){
		List<Integer> list = new ArrayList<>();
		inorder(root,list);
		return list;	
	}
	
	public static void inorder(TreeNode root,List<Integer>list) {
		if(root==null) {
			return;
		}
		inorder(root.left,list);
		list.add(root.val);
		inorder(root.right,list);
	}

Leetcode102(层序遍历)

 public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new LinkedList<>();
        Deque<TreeNode> de = new LinkedList<>();
        if(root == null){
            return result;
        }
        de.add(root);
        while(!de.isEmpty()){
            int size = de.size();
            List<Integer> list = new LinkedList<>();
            while(size-->0){
                TreeNode temp =  de.pollFirst();
                list.add(temp.val);
                if(temp.left!=null){
                    de.addLast(temp.left);
                }
                if(temp.right!=null){
                    de.addLast(temp.right);
                }
            }
            result.add(list);
        }
        return result;
    }

Leetcode107（层序遍历II）

public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> result = new LinkedList<>();
        Deque<TreeNode> de = new LinkedList<>();
        if(root == null){
            return result;
        }
        de.add(root);
        while(!de.isEmpty()){
            int size = de.size();
            List<Integer> list = new LinkedList<>();
            while(size-->0){
                TreeNode temp =  de.pollFirst();
                list.add(temp.val);
                if(temp.left!=null){
                    de.addLast(temp.left);
                }
                if(temp.right!=null){
                    de.addLast(temp.right);
                }
            }
            result.add(list);
        }
       Collections.reverse(result);
       return result;
    }

Leetcode199(二叉树的右视图)

public class LeetCode199 {
	 public List<Integer> rightSideView(TreeNode root) {
		 List<Integer> list = new LinkedList<>();
		 Deque<TreeNode> de = new LinkedList<>();
		 if(root==null) {
			 return list;
		 }
		 de.add(root);
		 while(!de.isEmpty()) {
			 int size = de.size();
			 while(size-->0) {
				 TreeNode temp = de.pollFirst();
				 if(size==0) {
					 list.add(temp.val);
				 }
				 if(temp.left!=null){
	                    de.addLast(temp.left);
	                }
	                if(temp.right!=null){
	                    de.addLast(temp.right);
	                }
			 }
			 
		 }
		 return list;
	 }
}

LeetCode637（二叉树的层平均值）

public class LeetCode637 {
	public List<Double> averageOfLevels(TreeNode root) {
		List<Double> result = new LinkedList<>();
		Deque<TreeNode> de = new LinkedList<>();
		if(root==null) {
			return result;
		}
		de.add(root);
		while(!de.isEmpty()) {
			int size = de.size();
			int num = size;
			double sum = 0;
			while(size-->0) {
				TreeNode temp = de.peekFirst();
				de.pollFirst();
				sum+=temp.val;
				if(temp.left!=null) {
					de.addLast(temp.left);
				}
				if(temp.right!=null) {
					de.addLast(temp.right);
				}
			}
			double total = sum/num;
			result.add(total);
		}
		return result;
    }
}

LeetCode429（N叉树的层序遍历）

package tree;

import java.util.Deque;
import java.util.LinkedList;
import java.util.List;

public class LeetCode429 {
	public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> result = new LinkedList<>();
        Deque<Node> de = new LinkedList<>();
        if(root == null) {
        	return result;
        }
        de.add(root);
        while(!de.isEmpty()) {
        	int size = de.size();
        	List<Integer> list = new LinkedList<>();
        	while(size-->0) {
        		Node temp = de.pollFirst();
        		list.add(temp.val);
        		if(temp.children!=null) {
        			for(int i = 0;i<temp.children.size();i++) {
        				de.addLast(temp.children.get(i));
        			}
        		}
        	}
        	result.add(list);
        }
        return result;
        
        
    }
}
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};

LeetCode515（在每个树行中找最大值）

public class LeetCode515 {
	 public List<Integer> largestValues(TreeNode root) {
        List<Integer> result = new LinkedList<>();
        Deque<TreeNode> de = new LinkedList<>();
        if(root==null) {
        	return result;
        }
        de.add(root);
        while(!de.isEmpty()) {
        	int size = de.size();
        	int max = Integer.MIN_VALUE;
        	while(size-->0) {
        		TreeNode temp = de.pollFirst();
        		max = temp.val>max?temp.val:max;
        		if(temp.left!=null) {
        			de.addLast(temp.left);
        		}
        		if(temp.right!=null) {
        			de.addLast(temp.right);
        		}
        	}
        	result.add(max);
        }
        return result;
   }
}

LeetCode116（填充每个节点的下一个右节点）

package tree;

import java.util.Deque;
import java.util.LinkedList;
import java.util.List;

public class LeetCode116 {
	 public Node_116 connect(Node_116 root) {
        Deque<Node_116> de = new LinkedList<>();
        if(root==null){
            return root;
        }
        de.add(root);
        while(!de.isEmpty()) {
        	int size = de.size();
        	while(size-->0) {
        		Node_116 temp = de.pollFirst();
        		if(size!=0) {
        			temp.next = de.peekFirst();
        		}
        		if(temp.left!=null) {
        			de.addLast(temp.left);
        		}
        		if(temp.right!=null) {
        			de.addLast(temp.right);
        		}
        	}
        }
        return root;
      
 }
}
class Node_116 {
    public int val;
    public Node_116 left;
    public Node_116 right;
    public Node_116 next;

    public Node_116() {}
    
    public Node_116(int _val) {
        val = _val;
    }

    public Node_116(int _val, Node_116 _left, Node_116 _right, Node_116 _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};

LeetCode117（填充每个节点的下一个右节点II）同上

LeetCode104（二叉树的最大深度）

package tree;

import java.util.Deque;
import java.util.LinkedList;

public class LeetCode104 {
	public int maxDepth(TreeNode root) {
		Deque<TreeNode> de = new LinkedList<>();
		int len = 0;
		if(root==null) {
			return 0;
		}
		de.add(root);
		while(!de.isEmpty()) {
			int size = de.size();
			len++;
			while(size-->0) {
				TreeNode temp = de.pollFirst();
				if(temp.left!=null) {
					de.addLast(temp.left);
				}
				if(temp.right!=null) {
					de.addLast(temp.right);
				}
			}
		}
		return len;
    }
}
//递归
class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        } else {
            int leftHeight = maxDepth(root.left);
            int rightHeight = maxDepth(root.right);
            return Math.max(leftHeight, rightHeight) + 1;
        }
    }
}

LeetCode111（二叉树的最小深度）

class Solution {
    public int minDepth(TreeNode root) {
        if(root==null){
            return 0;
        }
        if(root.left==null&&root.right==null){
            return 1;
        }
        int min_Depth = Integer.MAX_VALUE;
        if(root.left!=null){
            min_Depth = Math.min(minDepth(root.left),min_Depth);
        }
         if(root.right!=null){
            min_Depth = Math.min(minDepth(root.right),min_Depth);
        }
        return min_Depth+1;

    }
}