二叉树的实现,遍历,性质等

关键词解释:

节点的度 :

一个节点拥有的子节点个数被称为该节点的度

树的度 :

一颗树中,所有节点中最大的度被称为树的度

叶子节点/终端节点

度为0的节点被称为叶节点,也就是最底下的节点

分支节点或非终端节点

度不为0的节点.

兄弟节点

具有相同父节点的节点互称为兄弟节点

堂兄弟节点

双亲在同一层的节点 H J 就是堂兄弟节点

树的深度和高度

深度:从上往下
高度,从下往上
树中节点最大层次

树的形式:

有双亲表示法,孩子表示法,还孩子兄弟表示法

孩子兄弟表示法

class Node {
	int value;
	Node firstChild;
	Node nextBrother;
}

二叉树的性质

二叉树的特点

1. 每个节点最多有两个子节点,即二叉树所有节点的度都不大于
2. 二叉树的子树有左右之分,子树的次序不能颠倒,因此二叉树是有序树.

图中是二叉树的5种基本形态:
 从左到右依次是,空树,只有根节点的二叉树,只有左子树的节点,只有右子树的节点,左右子树都存在的节点.
 一般二叉树都是由上述5中基本形态组合而成的.

特殊的二叉树

1. 满二叉树
    一个二叉树,如果每一层的节点都达到最大值,则这个二叉树就是满二叉树.也就是说,如果一个二叉树的层数为K,且节点总数是 2^K -1.那么它就是满二叉树
2. 完全二叉树
    对于深度为K,有n个节点的二叉树,当且晋档每一个节点都与深度为K的满二叉树中编号为1到N的节点一一完全对应的时候被称为完全二叉树,满二叉树也被算为一种完全二叉树.
   

数字性质

1. 如果规定根节点的层数为1,则,一个非空二叉树的第K层最多有 2^(K-1) 个节点 (i>1).
2. 若规定只有根节点的二叉树深度为1,则深度为K的二叉树最大节点数为 (2^K) -1
3. 对任何一个二叉树老说,如果其叶节点个数为 n0,度为2的非叶节点个数为 n2 则有n0 = n2 +1
4. 具有n个节点的完全二叉树的深度K 为 log2(n+1)向上取整.

遍历形式

1. 先序遍历

诸如根左右的顺序遍历

		System.out.print(root.val + " ");
        preOrder(root.left);
        preOrder(root.right);

2. 中序遍历

诸如左根右的形式

   		 inOrder(root.left);
        System.out.print(root.val + " ");
        inOrder(root.right);

把树投影下来就是中序遍历的顺序

3. 后序遍历

诸如左右根的形式

		postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.val + " ");

4. 层序遍历

通过队列,先将头节点存入,如果队列不为空输出当前节点的值,当前节点的左节点和右节点不为空就依次存入队列,接着删除当前结点,以此循环.

 		Queue<Node> queue = new LinkedList<>();
        if (root != null) {
            queue.offer(root);
        }
        while (!queue.isEmpty()){
            System.out.println(queue.element().val);
            if(queue.element().left != null){
                queue.offer(queue.element().left);
            }
            if(queue.element().right != null){
                queue.offer(queue.element().right);
            }
            queue.remove();
        }

给定前序 中序,或者中序后序进行还原二叉树.

二叉树的实现:

package 课堂代码.数据结构.课件练习.二叉树;

import 寒假作业.day01.练习.B;

class Node {
    String val;
    Node left;
    Node right;

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

public class BinaryTree {
    //和类一起加载了
    public static Node build() {
        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");

        a.left = b;
        a.right = c;
        b.left = d;
        b.right = e;
        e.left = g;
        c.right = f;
        return a;
    }

    //先序遍历
    public static void preOrder(Node root) {
        if (root == null) {
            return;
        }
        System.out.print(root.val + " ");
        preOrder(root.left);
        preOrder(root.right);
    }

    //中序遍历
    public static void inOrder(Node root) {
        if (root == null) {
            return;
        }
        inOrder(root.left);
        System.out.print(root.val + " ");
        inOrder(root.right);
    }

    //后序遍历
    public static void postOrder(Node root) {
        if (root == null) {
            return;
        }
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.val + " ");
    }

    //使用成员变量求树的元素个数
    public static int count = 0;

    public static void length(Node root) {
        if (root == null) {
            return;
        }
        count++;
        length(root.left);
        length(root.right);
    }


    //递归求树的元素个数
    public static int length2(Node root) {
        if (root == null) {
            return 0;
        }
        return 1 + length2(root.left) + length2(root.right);
    }

    //求有多少个叶子结点
    public static int leafSize = 0;

    public static void getLeafSize(Node root) {
        if (root == null) {
            return;
        }
        if (root.left == null && root.right == null) {
            leafSize++;
        }
        getLeafSize(root.left);
        getLeafSize(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);
    }

    //递归求某一层节点个数
    public static int getKLevelSize(Node root, int k) {
        if (root == null) {
            return 0;
        }
        if (root != null && 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 1 + (left > right ? left : right);
    }

    //查找根据字段返回节点地址
    public static Node find(Node root, String toFind) {
        if (root == null) {
            return null;
        }
        if (root.val == toFind) {
            return root;
        }
        Node nodeleft = find(root.left, toFind);
        if (nodeleft != null) {
            return nodeleft;
        } else {
            return find(root.right, toFind);
        }
    }

    public static void main(String[] args) {
        Node root = BinaryTree.build();
//        BinaryTree.preOrder(root);
//        System.out.println("\n=======================");
//        BinaryTree.inOrder(root);
//        System.out.println("\n=======================");
//        BinaryTree.postOrder(root);
//        BinaryTree.length(root);
//        System.out.println(count);
//        System.out.println(BinaryTree.length2(root));
//        BinaryTree.getLeafSize(root);
//        System.out.println(leafSize);
//        System.out.println(BinaryTree.getLeafSize2(root));
//        System.out.println(BinaryTree.getKLevelSize(root, 4));
//        System.out.println(BinaryTree.getHeight(root));
        System.out.println(BinaryTree.find(root,"D"));
    }
}