【数据结构】二叉树练习题

二叉树练习题

求二叉树的高度-只能汇总思想

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

求二叉树第K层结点的个数

汇总：
1.利用递归求左子树第K-1层的结点个数；
2利用递归求右子树第 K-1层的结点个数；
3.整棵树第K层的结点个数= left+right
出口：
root==null   return 0
root!=null&&k==1   return 1

k>=1
int getKLevel(Node root,int k)
{
    if(root==null)
    {
        return 0;
    }
    if(k==1)
    {
        return 1;
    }
    int left=getKLevel(root,k-1);
    int right=getKLevel(root,k-1);
    return left
}

// 查找 val 所在结点，没有找到返回 null
// 按照 根 -> 左子树 -> 右子树的顺序进行查找
// 一旦找到，立即返回，不需要继续在其他位置查找

Node find(Node root, int val)
{
    if(root==null)
    {
        return null;
    }
    if(root.val==val)
    {
        return root;
    }
    Node n=find(root.left,val);
    if(n!=null)
    {
        return n;
    }
    n=find(root.right,val)
    if(n!=null)
    {
        return n;
    }
    return null;
}    

判断val 是否在结点中

boolean find(Node root,int val)
{
    if(root==null)
    {
        return false;
    }
    if(root.val==val)
    {
        return true;
    }
    if(find(root.left,val))
    {
        return true;
    }
    else
    {
        return false;
    }
}

判断是否为相同的二叉树

 public boolean isSameTree(TreeNode p, TreeNode q)
    {
        if(p==null&&q==null)
        {
            return true;
        }
        if(p==null||q==null)
        {
            return false;
        }
        return p.val==q.val&&isSameTree(p.left,q.left)&&isSameTree(p.right,q.right);
    
    }

判断二叉树是否为镜像二叉树

boolean isMirrorTree(Node p,Node q)
{
    if(p==null&&q==null)
    {
        return true;
    }
    if(p==null||q==null)
    {
        return false;
    }
    return p.val==q.val&&isMirrorTree(p.left,q.right)&&isMirrorTree(p.right,q.left);
}

判断二叉树是否为对称二叉树

private boolean isMirrorTree(TreeNode p,TreeNode q)
{
    if(p==null&&q==null)
    {
        return true;
    }
    if(p==null||q==null)
    {
        return false;
    }
    return p.val==q.val&&isMirrorTree(p.left,q.right)&&isMirrorTree(p.right,q.left);
}
    public boolean isSymmetric(TreeNode root)
     {
        if(root==null)
        {
            return true;
        }
        return isMirrorTree(root.left,root.right);
    }

判断一个树是否是另一个树的子树

思想：
一个树是另一个树的子树 则
1）要么这两个树相等；
2）要么这个树是左树的子树
3）要么这个树是右树的子树

private boolean isSameTree(TreeNode p, TreeNode q)
{
        if(p==null&&q==null)
        {
            return true;
        }
        if(p==null||q==null)
        {
            return false;
        }
        return p.val==q.val&&isSameTree(p.left,q.left)&&isSameTree(p.right,q.right);
    
    }
    public boolean isSubtree(TreeNode s, TreeNode t) {
       if(s==null&&t==null)
       {
           return true;
       }
        if(s==null||t==null)
        {
            return false;
        }
        return isSameTree(s,t)||isSubtree(s.left,t)||isSubtree(s.right,t);
    }

判断是否为平衡二叉树
平衡二叉树：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

思想： 
根：左右子树高度差的绝对值不超过1 
左子树：是平衡的
右子树：是平衡的
 private int getHeight(TreeNode root)
 {
    if(root==null)
    {
        return 0;
    }
    int left=getHeight(root.left);
    int right=getHeight(root.right);
    return Math.max(left,right)+1;   
}
public boolean isBalanced(TreeNode root)
{
        if(root==null)
        {
            return true;
        }
        if(!isBalanced(root.left))
        {
            return false;
        }
        if(!isBalanced(root.right))
        {
            return false;
        }
        int left=getHeight(root.left);
        int right=getHeight(root.right);
        int diff=left-right;
        if(diff>=-1&&diff<=1)
        {
            return true;
        } 
        return false;
}

前中后序的非递归遍历

//前序遍历
public static void preorder(Node root)
{
    statck<Node>stack=new stack<>();
    Node cur=root;
    while(cur!=null||!statck.isEmpty())
    {
         while(cur!=null)
         {
              System.out.println(cur.val);
              stack.push(cur);
              cur=cur.left
         }
         Node top=stack.pop();
         cur=top.right;
}
//中序遍历
public static void Inorder(Node root)
{
    statck<Node>stack=new stack<>();
    Node cur=root;
    while(cur!=null||!statck.isEmpty())
    {
         while(cur!=null)
         {
              stack.push(cur);
              cur=cur.left
         }
         Node top=stack.pop();
         System.out.println(top.val)
         cur=top.right
}
//后序遍历
public static void postorder(Node root)
{
    statck<Node>stack=new stack<>();
    Node cur=root;
    Node last=null;//上次被遍历完的结点
    while(cur!=null||!statck.isEmpty())
    {
         while(cur!=null)
         {
              stack.push(cur);
              cur=cur.left
         }
         Node top=stack.peek();
         if(top.right==null||top.right==last)
         {
             System.out.println(top.val);
             stack.pop();
             last=top;
         }
         else
         {
             cur=top.right;
         }
}

二叉树的层序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution 
{
    public List<List<Integer>> levelOrder(TreeNode root) 
    {
        // 创建二维数组接收每层的结点
        List<List<Integer>> ans = new ArrayList<>();
        if (root == null) 
        {
            return ans;
        }
        // 创建队列依次存放每层的结点
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        while (!q.isEmpty()) 
        {
            // 创建数组来接收出队的结点，存放的是每层的结点
            List<Integer> tmp =  new ArrayList<>();
            int len = q.size();
            for (int i = 0; i < len; i++) 
            {
                // 定义 node 接收出队结点，然后加入数组 tmp 中
                TreeNode node = q.poll();
                tmp.add(node.val);
                // 如果有左右孩子，就依次入队、出队、进数组
                if (node.left != null) 
                {
                    q.add(node.left);
                }
                if (node.right != null) 
                {
                    q.add(node.right);
                }
            }
            // 数组每次都是放的一层的结点，然后一层一层的放入二维数组中
            ans.add(tmp);
        }
        return ans;
    }
}