力扣_树
二叉树的最大深度
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
//深度优先遍历
//方法可以参考一棵只有三个节点的树（完全二叉树）
// class Solution {
// public int maxDepth(TreeNode root) {
// if(root == null){
// return 0;
// }else{
// int leftmax = maxDepth(root.left);
// int rightmax = maxDepth(root.right);
// //返回到左右子树的父节点，要求最高树，因此要返回左右子树高度的最大值并且高度要加1
// return Math.max(leftmax,rightmax) + 1;
// }
// }
// }
//广度优先遍历
//按照层次遍历，每遍历一层高度加1
//遍历的过程中要将每层的下一层的所有的节点存入在队列中
class Solution {
public int maxDepth(TreeNode root) {
//特殊情况
if(root == null){
return 0;
}
//高度
int high = 0;
//设置队列,队列Queue的存入是offer，取出是poll
Queue<TreeNode> queue = new LinkedList<TreeNode>();
//从根节点开始
queue.offer(root);
//循环结束的条件是队列为空
while(!queue.isEmpty()){
//每一层的节点个数
int size = queue.size();
while(size > 0){
TreeNode node = queue.poll();
//先判断node指针的左右节点是否为空再判断是否是要存，不然会出现空指针异常
if(node.left != null){
queue.offer(node.left);
}
if(node.right != null){
queue.offer(node.right);
}
--size;
}
++high;
}
return high;
}
}
验证二叉搜索树
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
//这题可以用中序遍历先将树的值都存下来，这里建议用队列
//然后判断队列是否后一项的值大于前一项的，如果中间存在不是后一项大于前一项，则不是二叉搜索树
// class Solution {
// public boolean isValidBST(TreeNode root) {
// Queue<TreeNode> queue = null;
// queue = isOrderTraversal(root);
// //求队列的长度
// int length = queue.size();
// //判断是否前一项的值小于后一项的值
// while(!queue.isEmpty()){
// TreeNode t1 = queue.poll();
// int t11 = t1.val;
// TreeNode t2 = queue.poll();
// int t22 = t2.val;
// if(t11 > t22){
// return false;
// }
// }
// return true;
// }
// //中序遍历
// public Queue<TreeNode> isOrderTraversal(TreeNode node){
// //设置队列用于保存中序遍历过程中存下的值
// Queue<TreeNode> queue = new LinkedList<TreeNode>();
// if(node == null){
// return null;
// }else{
// isOrderTraversal(node.left);
// queue.offer(node);
// isOrderTraversal(node.right);
// }
// return queue;
// }
// }
//不使用递归的中序遍历
class Solution {
public boolean isValidBST(TreeNode root) {
Deque<TreeNode> stack = new LinkedList<TreeNode>();
double cur = -Double.MAX_VALUE;
while(root != null || !stack.isEmpty()){
while(root != null){
stack.push(root);
root = root.left;
}
root = stack.pop();
//必须带等号
if(root.val <= cur){
return false;
}
cur = root.val;
root = root.right;
}
return true;
}
}
对称二叉树
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
//判断该二叉树是否为对称二叉树
//可以设置内层判断和外层判断
//从上往下判断，当出现任意一次不对称，则该二叉树就不是对称二叉树
class Solution {
public boolean isSymmetric(TreeNode root) {
return Compare(root.left,root.right);
}
//判断是否为对称二叉树
public boolean Compare(TreeNode left,TreeNode right){
if(left == null && right != null){
return false;
}
if(left != null && right == null){
return false;
}
if(left == null && right == null){
return true;
}
if(left.val != right.val){
return false;
}
//判断外层
boolean out = Compare(left.left,right.right);
//判断内层
boolean in = Compare(left.right,right.left);
return out && in;
}
}
二叉树的层序遍历
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
//层次遍历需要注意的是每次都要将保存下来的串保存下来，是个二维的串
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
//设置二维的串用于保存一维的串
List<List<Integer>> ll = new ArrayList<List<Integer>>();
if(root == null){
return ll;
}
//设置队列用于保存一层的节点，队列Queue要和LinkedList搭配使用
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.offer(root);
while(!queue.isEmpty()){
//求这一层的长度
int n = queue.size();
//设置一维的串用于保存该层的元素值
List<Integer> l = new ArrayList<Integer>();
while(n > 0){
//先取出才能得到值
TreeNode node = queue.poll();
l.add(node.val);
if(node.left != null){
queue.offer(node.left);
}
if(node.right != null){
queue.offer(node.right);
}
n--;
}
//将一维的串存入在二维的串中
ll.add(l);
}
return ll;
}
}
将有序数组转换为二叉搜索树
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
//从上往下存入，每次将有序数组的中间节点当做父节点
//父节点的左孩子为左半子树的中间节点
//父节点的右孩子为右半子树的中间节点
class Solution {
public TreeNode sortedArrayToBST(int[] nums) {
return dfs(nums,0,nums.length - 1);
}
public TreeNode dfs(int[] nums,int l,int r){
if(l > r){
return null;
}
//中间节点的值存入在树中
int mid = (l+r)/2;
TreeNode root = new TreeNode(nums[mid]);
//存入中间节点的左子树节点和右子树节点
root.left = dfs(nums,l,mid - 1);
root.right = dfs(nums,mid + 1,r);
return root;
}
}
浙公网安备 33010602011771号