1. 二叉树的前序遍历。
2. 二叉树中序遍历 。
3. 二叉树的后序遍历 。
4. 检查两颗树是否相同。
5. 另一颗树的子树。
6. 二叉树最大深度。
7. 判断一颗二叉树是否是平衡二叉树。
8. 对称二叉树。
9.层序遍历
10.判断一棵树是不是完全二叉树
//给你二叉树的根节点 root ,返回它节点值的 前序,中序,后序 遍历。把遍历结果放入顺序表中
*/
//层序遍历二叉树(孩子树)
void levelOrderTraversal1(Node root){
Queue<Node> queue=new LinkedList<>();
if(root==null){
return ;
}
queue.offer(root);
while (!queue.isEmpty()){
Node ret=queue.poll();
System.out.print(ret.val);
if(ret.left!=null){
queue.offer(ret.left);
}
if(ret.right!=null){
queue.offer(ret.right);
}
}
}
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> result=new ArrayList<>();
if(root==null){
return result;
}
result.add(root.val);
result.addAll(preorderTraversal(root.left));
result.addAll(preorderTraversal(root.right));
return result;
}
}
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> result=new ArrayList<>();
if(root==null){
return result;
}
result.addAll(inorderTraversal(root.left));
result.add(root.val);
result.addAll(inorderTraversal(root.right));
return result;
}
}
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> result=new ArrayList<>();
if(root==null){
return result;
}
result.addAll(postorderTraversal(root.left));
result.addAll(postorderTraversal(root.right));
result.add(root.val);
return result;
}
}
//给定一个二叉树,找出其最大深度。
//二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
//说明: 叶子节点是指没有子节点的节点。
class Solution {
public int maxDepth(TreeNode root) {
if(root==null){
return 0;
}
return 1+max(maxDepth(root.left),maxDepth(root.right));
}
public int max(int a,int b){
return a>b ? a:b;
}
}
//给你两棵二叉树的根节点 p 和 q ,编写一个函数来检验这两棵树是否相同。
//如果两个树在结构上相同,并且节点具有相同的值,则认为它们是相同的。
class Solution {
public boolean isSameTree(TreeNode p, TreeNode q) {
if(p==null&&q==null){
return true;
}
if(p==null||q==null){
return false;
}
if(p.val!=q.val){
return false;
}
return isSameTree(p.left,q.left)&&isSameTree(p.right,q.right);
}
}
给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在,返回 true ;否则,返回 false 。
二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。
class Solution {
public boolean isSubtree(TreeNode root, TreeNode subRoot) {
if (root == null && subRoot == null) {
return true;
}
if (root == null || subRoot == null) {
return false;
}
boolean ret = false;
if (root.val == subRoot.val) {
ret = isSameTree(root, subRoot);
}
if (!ret) {
ret = isSubtree(root.right, subRoot);
}
if (!ret) {
ret = isSubtree(root.left, subRoot);
}
return ret;
}
public boolean isSameTree(TreeNode p, TreeNode q) {
if (p == null && q == null) {
return true;
}
if (p == null || q == null) {
return false;
}
if (p.val != q.val) {
return false;
}
return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
}
}
//给定一个二叉树,判断它是否是高度平衡的二叉树。
//本题中,一棵高度平衡二叉树定义为:
//一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。
class Solution {
public boolean isBalanced(TreeNode root) {
if(root==null){
return true;
}
int rootleft=maxDeep(root.left);
int rootright=maxDeep(root.right);
if(rootleft-rootright>1||rootleft-rootright<-1){
return false;
}
return isBalanced(root.left)&&isBalanced(root.right);
}
public int maxDeep(TreeNode root) {
if(root==null){
return 0;
}
return 1+max(maxDeep(root.left),maxDeep(root.right));
}
public int max(int a,int b){
return a>b ? a:b;
}
}
//给定一个二叉树,检查它是否是镜像对称的。
class Solution {
public boolean isSymmetric(TreeNode root) {
if(root==null){
return true;
}
return ismid(root.left,root.right);
}
public boolean ismid(TreeNode r1,TreeNode r2){
if(r1==null&&r2==null){
return true;
}
if(r1==null||r2==null){
return false;
}
if(r1.val!=r2.val){
return false;
}
return ismid(r1.left,r2.right)&&ismid(r1.right,r2.left);
}
}
// 判断一棵树是不是完全二叉树
boolean isCompleteTree(Node root) {
Queue<Node> queue = new LinkedList<>();
if (root == null) {
return true;
}
queue.offer(root);
boolean step = false;
while (!queue.isEmpty()) {
Node node = queue.poll();
if (!step) {
if (node.left != null && node.right != null) {
queue.offer(node.left);
queue.offer(node.right);
} else if (node.left != null && node.right == null) {
queue.offer((node.left));
step = true;
} else if (node.left == null && node.right != null) {
return false;
} else {
step = true;
}
} else if (step) {
if (node.left != null || node.right != null) {
return false;
}
}
}
return true;
}