二叉树的概念与基本操作

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

概念：

节点的度：一个节点含有的子树的个数称为该节点的度
树的度：一棵树中，最大的节点的度称为树的度
叶子节点或终端节点：度为0的节点称为叶节点
双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点
孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点
根结点：一棵树中，没有双亲结点的结点
节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推
树的高度或深度：树中节点的最大层次

 二叉树

1.概念：一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉
树组成。
2.二叉树的特点：

1.  每个结点最多有两棵子树，即二叉树不存在度大于 2 的结点。
2.  二叉树的子树有左右之分，其子树的次序不能颠倒。

3.二叉树的基本形态

4. 两种特殊的二叉树

• 1. 完全二叉树: 完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。

对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。

• 2. 满二叉树: 一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。

也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。

二叉树的深度优先遍历（前中后序遍历）

1.前中后序的两种视角：

• 按固定路线进行：第一次遇到就打印的为前序，第二次遇到就打印的为中序，第三次遇到就打印的为后序。
• 将二叉树分为三部分：根，左子树，右子树。

1. NLR前序遍历(Preorder Traversa）：根 + 左子树的前序遍历 + 右子树的前序遍历
2. LNR中序遍历(Inorder Traversal)：左子树的中序遍历 + 根 + 右子树的中序遍历
3. LRN后序遍历(Postorder Traversal)：左子树的后序遍历 + 右子树的后序遍历 + 根

练习：

二叉树的操作：

思路:递归

 

import java.util.ArrayList;
import java.util.List;
public class BinaryTree {
    // 静态内部类定义二叉树
    private static class Node{
        private char val;
        private Node left;
        private Node right;

        private Node (char val){
            this.val = val;
        }
        @Override
        public String toString(){
            return String.format("{%c}",val);
        }
    }
    // 创建二叉树
    public static Node buildTree(){
        Node a = new Node('A');
        Node b = new Node('B');
        Node c = new Node('C');
        Node d = new Node('D');
        Node e = new Node('E');
        Node f = new Node('F');
        Node g = new Node('G');
        Node h = new Node('H');
        a.left = b;
        a.right = c;
        b.left = d;
        b.right = e;
        e.right = h;
        c.left = f;
        c.right = g;
        return a;
    }
    //前序遍历1:遍历思路
    public static void preorderTraversal1(Node root){
        if(root == null){
            return ;
        }
        System.out.println(root);
        preorderTraversal1(root.left);
        preorderTraversal1(root.right);
    }
    // 前序遍历2：汇总
    public static List<Character> preorderTraversal2(Node root){
        if(root == null){
            return new ArrayList<>();
        }
        List<Character> list = new ArrayList<>();
        list.add(root.val);
        list.addAll(preorderTraversal2(root.left));
        list.addAll(preorderTraversal2(root.right));
        return list;
    }
    //中序遍历1:遍历思路
    public static void inorderTraversal1(Node root){
        if(root == null){
            return;
        }
       inorderTraversal1(root.left);
        System.out.println(root);
       inorderTraversal1(root.right);
    }
    // 中序遍历2：汇总
    public static List<Character> inorderTraversal2(Node root){
        if(root == null){
            return new ArrayList<>();
        }
        List<Character> list = new ArrayList<>();
        list.addAll(inorderTraversal2(root.left));
        list.add(root.val);
        list.addAll(inorderTraversal2(root.right));
        return list;
    }
    // 后序遍历1:遍历思路
    public static void postorderTraversal1(Node root){
        if(root == null){
            return;
        }
        postorderTraversal1(root.left);
        postorderTraversal1(root.right);
        System.out.println(root);
    }
    //后序遍历2：汇总
    public static List<Character> postorderTraversal2(Node root){
        if(root == null){
            return new ArrayList<>();
        }
        List<Character> list = new ArrayList<>();
        list.addAll(postorderTraversal2(root.left));
        list.addAll(postorderTraversal2(root.right));
        list.add(root.val);
        return list;
    }
    // 遍历思路-求结点个数
    public static int count = 0;
    public static void getSize1(Node root){
        if(root == null){
            return ;
        }
        count++;
        getSize1(root.left);
        getSize1(root.right);
    }
    // 子问题思路-求结点个数,汇总
    public static int getSize2(Node root){
        if(root == null){
            return 0;
        }
        return getSize2(root.left) + getSize2(root.right) + 1;
    }
    // 遍历思路-求叶子结点个数
    public static int leafSize = 0;
    public static void getLeafSize1(Node root){
        if(root == null){
            return;
        }
        if(root.left == null && root.right == null){
            leafSize++;
        }
        getLeafSize1(root.left);
        getLeafSize1(root.right);
    }
     //（汇总）子问题思路-求叶子结点个数
    public static int getLeafSize2(Node root){
        if(root == null){
            return 0;
        }
        if(root.left == null && root.right == null){
            return 1;
        }
        return getLeafSize2(root.left) + getLeafSize2(root.right);
    }
    // （汇总）子问题思路-求第 k 层结点个数
    public static int getKLevelSize(Node root,int k){
        if(root == null){
            return 0;
        }
        if(k == 1){
            return 1;
        }
        return getKLevelSize(root.left,k - 1) + getKLevelSize(root.right,k - 1);
    }
    // 求树的深度（高度）
    public static 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;
    }
    // 查找 val 所在结点，没有找到返回 null
    public static Node find(Node root, int val){
        if(root == null){
            return null;
        }
        if(root.val == val){
            return root;
        }
       Node left = find(root.left,val);
        if(left != null){
            return left;
        }
        Node right = find(root.right,val);
        if(right != null){
            return right;
        }
        return null;
    }
    // 判断二叉树中是否含有值为 val 的结点，若有返回 true
    public static boolean find2(Node root,int val){
        if(root == null){
            return false;
        }
        if(root.val == val){
            return true;
        }
        if(find2(root.left,val)){
            return true;
        }
        if(find2(root.right,val)){
            return true;
        }
        return false;
    }
    public static void main(String[] args) {//测试
        Node root = buildTree();
        System.out.println("前序遍历为：");
        preorderTraversal1(root);
        System.out.println("----------");
        System.out.println(preorderTraversal2(root));
        System.out.println("中序遍历为：");
        inorderTraversal1(root);
        System.out.println("----------");
        System.out.println(inorderTraversal2(root));
        System.out.println("后序遍历为：");
        postorderTraversal1(root);
        System.out.println("----------");
        System.out.println(postorderTraversal2(root));
        System.out.println("----------");
        count = 0;//每次清零，否则1下次会从原来结果上继续加
        getSize1(root);
        System.out.println("节点个数为： "+ count);
        System.out.println("节点个数为： "+getSize2(root));
        leafSize = 0;
        getLeafSize1(root);
        System.out.println("叶子节点个数为： "+ leafSize);
        System.out.println("叶子节点个数为： "+getLeafSize2(root));
        System.out.println("第4层结点个数为："+getKLevelSize(root,4));
        System.out.println("树的高度为："+getHeight(root));
        System.out.println(find(root,'F'));
        System.out.println("----------");
        System.out.println(find2(root,'p'));
    }
}

二叉树前中后序非递归遍历：

public class Tree {
    private class Node{
        private Node left = null;
        private Node right = null;
        private int val;
    }
    public static void preOrder(Node root){
        Stack<Node> stack = new Stack<Node>();
        Node cur = root;
        while(cur != null || !stack.isEmpty()){
            while(cur != null){
                System.out.print(cur.val+" ");
                stack.push(cur);
                cur = cur.left;
            }
            Node top = stack.pop();
            cur = top.right;
        }

    }
    public static void inOrder(Node root){
        Stack<Node> stack = new Stack<Node>();
        Node cur = root;
        while(cur != null || !stack.isEmpty()){
            while(cur != null){
                stack.push(cur);
                cur = cur.left;
            }
            Node top = stack.pop();
            System.out.print(top.val+" ");
            cur =top.right;
        }
    }
    public static void postOrder(Node root){
        Stack<Node> stack = new Stack<Node>();
        Node cur = root;
        Node last = null;// 上一次被完全遍历完的结点
        while(cur != null || !stack.isEmpty()){
            while(cur != null){
                stack.push(cur);
                cur = cur.left;
            }
            Node top = stack.peek();
            if(top.right == null || top.right == last){
                System.out.print(top.val+" ");
                stack.pop();
                last = top;
            } else{
                cur = top.right;
            }
        }
    }
}