【数据结构】二叉树

二叉树

树的基本知识：
概念：树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。
特点：1. 每个结点有零个或多个子结点；
　　　2. 没 有父结点的结点称为根结点；
　　　3. 每一个非根结点有且只有一个父结点；
　　　4. 除了根结点外，每个子结点可以分为多个不相交的子树

二叉树
概念：一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。
特点：1. 每个结点最多有两棵子树，即二叉树不存在度大于 2 的结点。
　　　2. 二叉树的子树有左右之分，其子树的次序不能颠倒。
满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。
即：一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。
满二叉树的高度（h）和结点个数（n）的关系：n=2^h-1
完全二叉树：对于深度为K的，有n 个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全 二叉树。

遍历方式
分为两类遍历方式
1.深度遍历：前中后序遍历
2.广度遍历：层序遍历
前中后序的视角
前序：根+左子树的前序遍历+右子树的前序遍历
中序：左子树的中序遍历+根+右子树的中序遍历
后序：左子树的后序遍历+右子树的后序遍历+根
二叉树的表示形式：

class Node
{
    int val;      // 数据域   
    Node left;    // 左孩子的引用，常常代表左孩子为根的整棵左子树     
    Node right;   // 右孩子的引用，常常代表右孩子为根的整棵右子树  
    Node parent;  // 可选的，双亲的引用 
}
Node root = null;   // 表示没有结点，如果是树的根，则表示根一个结点都没有，即空树

递归前序遍历：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public List<Integer> preorderTraversal(TreeNode root)
{
    if(root==null)
    {
        return new ArrayList<>();
    }
    List<Integer>left=preorderTraversal(root.left);
    List<Integer>right=preorderTraversal(root.right);
    List<Integer>list=new ArrayList<>();
   list.add(root.val);
   list.addAll(left);
   list.addAll(right);
   return list;
} 

递归中序遍历：

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

递归后序遍历：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public List<Integer> postorderTraversal(TreeNode root)
{
    if(root==null)
    {
        return new ArrayList<>();
    }
    List<Integer> list=new ArrayList<>();
    List<Integer> left=postorderTraversal(root.left);
    List<Integer> right=postorderTraversal(root.right);
    list.addAll(left);
    list.addAll(right);
    list.add(root.val);
    return list;
}

二叉树的层序遍历 广度优先遍历 （队列）
层序遍历：

public class LevelOrder 
{
    private static class Node 
	{
        char val;
        Node left;
        Node right;

        Node(char val) 
        {
            this.val = val;
        }
    }
public static void levelOrder (Node root)
{
    if(root==null)
    {
        return ;
    }
    Queue<Node> queue = new LinkedList<>();
    queue.offer(root);
    while(!queue.isEmpty())
    {
        Node front=queue.poll();
        System.out.println(front.val);
        if(front.left!=null)
        {
            queue.offer(front.left);
        }
        if(front.right!=null)
        {
            queue.offer(front.right);
        }
    }

遍历思想-求结点个数：

//遍历思想：
1）记录的位置独立于遍历的过程之外
2）每次都需要重置记录变量
public static int count=0;
public void getSize(Node root)
{
    if(root==null)
    {
        return;
   }
   count++;
   getSize(root.left);
   getSize(root.right);
}
count=0;
getSize(root);
System.out.println("结点个数"+count);

汇总思想-求结点个数：

public int getSize(root)
{
    if(root==null)
    {
        return 0;
    }
    return getSize(root.left)+getSize(root.right)+1;
}

求叶子结点个数

static int leafSize = 0;
void getLeafSize1(Node root)
{
    if(root==null)
    {
        return ;
    }
    if(root.left==null&&root.right==null)
    {
        leafSize++;
    }
    getLeafSize1(root.left);
    getLeafSize1(root.right);
}
leafSize=0;
getLeafSize(root);
System.out.println("叶子结点个数"+leafSize);

汇总思想-求叶子结点个数：

static int leafSize = 0;
int getLeafSize2(Node root)
{
    if(root==null)
    {
        return 0;
    }
    if(root.left==null&&root.right==null)
    {
        return 1;
    }
    int left=getleafSize2(root.left);
    int right=getleafSize2(root.right)
    return left+right;
}