树与二叉树的代码实现

树

定义：
树是一种非线性的数据结构，它是由n（n >= 0）个有限节点组成一个具有层次关系的集合，把它叫做树是因为他的结构像一颗倒挂的树，树根朝上，叶片朝下。

特点：
他的主要特点是，每个节点有0个或者多个子节点，没有父结点的结点称为根结点，而每个非根结点只有一个父结点，除了父结点外，每个子结点可以分为多个不相交的子树。

相关概念：
节点的度：一个节点含有的子树的个数
树的度：一棵树中，最大的节点的度
叶子结点或终端结点：度为0的结点，称为叶子结点
双亲节点或父结点：一个结点若有子结点，那么这个节点称为该子结点的父结点
孩子节点或子结点：一个节点含有的子树的根节点称为该节点的子节点
根节点：一棵树中没有双亲结点的结点称为根结点
节点的层次：从根开始定义起，根为第一层，根的子节点为第二层
树的高度或深度：树中结点的最大层次

孩子双亲表示法表示树的结构：

class Node {
	int value;
	Node firstNode;//第一个孩子的引用
	Node nextBrother;//下一个孩子的引用
]

二叉树

概念：
一颗二叉树是一个结点的集合，该集合或者为空，或者是由一个根结点加上两颗别称为左子树和右子树的二叉树组成。

特点：

• 每个节点最多有两个子树，即二叉树不存在度大于2的结点
• 二叉树的子树有左右之分，顺序不能颠倒。

完全二叉树：
完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。

满二叉树：
一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。

二叉树的相关操作

前序遍历（preorderTraversal）：
访问根结点的操作发生在遍历其左右子树之前。
中序遍历（inorderTraversal）：
访问根结点的操作发生在遍历其左右子树之中
后序遍历（postorderTraversal）：
访问根结点的操作发生在遍历其左右子树之后

代码实现：
root代表一个二叉树的根结点。

//定义结点
class Node {
    String val;
    //左子树
    Node left; 
    //右子树
    Node right; 

    public Node(String val) {
        this.val = val;
    }
}

public class BinaryTree {
    //根结点
    Node root; 

    // 前序遍历
    void preOrderTraversal(Node root) {
        if(root == null) {
            return;
        }
        System.out.print(root.val+ " ");
        preOrderTraversal(root.left);
        preOrderTraversal(root.right);
    };
    // 中序遍历
    void inOrderTraversal(Node root) {
        if(root == null) {
            return;
        }
        inOrderTraversal(root.left);
        System.out.print(root.val + " ");
        inOrderTraversal(root.right);
    };
    // 后序遍历
    void postOrderTraversal(Node root) {
        if(root == null) {
            return;
        }
        postOrderTraversal(root.left);
        postOrderTraversal(root.right);
        System.out.print(root.val + " ");
    };
    // 遍历思路-用静态变量求结点个数
	
    static int size = 0;

    void getSize1(Node root) {
        if(root == null) {
            return;
        }
        size++;
        getSize1(root.left);
        getSize1(root.right);
    };

    // 子问题思路-不用静态变量求结点个数
    int getSize2(Node root) {
        if(root == null) {
            return 0;
        }
        return 1 + getSize2(root.left) + getSize2(root.right);
    };

    // 遍历思路-用静态变量求叶子结点个数
    static int leafSize = 0;

    void getLeafSize1(Node root) {
        if(root == null) {
            return;
        }
        if(root.left == null && root.right == null) {
            leafSize++;
            return;
        }
        getLeafSize1(root.left);
        getLeafSize1(root.right);
    };
    // 子问题思路-不用静态变量求叶子结点个数
    int getLeafSize2(Node root) {
        if(root == null) {
            return 0;
        }
        if(root.left == null && root.right == null) {
            return 1;
        }
        return getLeafSize2(root.left) + getLeafSize2(root.left);
    };
    // 子问题思路-求第 k 层结点个数
    int getKLevelSize(Node root,int k ) {
        if(root == null || k < 1) {
            return 0;
        }
        if(k == 1) {
            return 1;
        }
        return getKLevelSize(root.left,k-1) + getKLevelSize(root.right,k-1);
    };
    // 查找 val 所在结点，没有找到返回 null
// 按照 根 -> 左子树 -> 右子树的顺序进行查找
// 一旦找到，立即返回，不需要继续在其他位置查找
    Node find(Node root, String val) {
        if(root == null) {
            return null;
        }
        if(root.val.equals(val)) {
            return root;
        }
        Node left = findNode(root.left, val);
        Node right = findNode(root.right, val);
        return left == null ? right : left;
    };

    public static void main(String[] args) {
    }
}