数据结构与算法二叉树

一、树的示意图

1) 节点
2) 根节点（唯一）
3) 父节点
4) 子节点
5) 叶子节点 (没有子节点的节点)
6) 节点的度(此节点子树个数)，树的度就是各节点度最大值。
7) 路径(从root节点找到该节点的路线)
8) 层
9) 子树（互不相交）
10) 树的高度（叶子节点）深度（到根节点）
11) 森林 :多颗子树构成森林

二、二叉树的概念

1. 树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。
2. 二叉树的子节点分为左节点和右节点
3. 示意图
   

4.如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树。

5.如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二 层的叶子节点在右边连续，我们称为完全二叉树

三、二叉树遍历（Java实现）

来自leetcode
二叉树的遍历分为两个方面，即深度优先DFS和广度优先BFS。

深度优先遍历包含
前序遍历:根左右
中序遍历:左根右
后序遍历: 左右根
广度优先遍历包含层序遍历。

代码实现：

递归实现（以前序遍历为例子）
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
 //列表返回的，也可直接打印sout
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
       List<Integer> list = new ArrayList<>();
       if (root!=null){
       list.add(root.val);
       list.addAll(preorderTraversal(root.left));
       list.addAll(preorderTraversal(root.right));
       }return list;
    }
}

//递归+遍历实现

package tree;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
public class TreeTraversal {
     //递归实现
     public static void preOrder(Node root){
          if(root==null) return ;
          System.out.print(root.value);
          preOrder(root.left);
          preOrder(root.right);
     }
     public static void midOrder(Node root){
          if(root==null) return ;

          midOrder(root.left);
          System.out.print(root.value);
          midOrder(root.right);
     }
     public static void postOrder(Node root){
          if(root==null) return ;
          postOrder(root.left);
          postOrder(root.right);
          System.out.print(root.value);
     }
 //栈实现,先进后出
     private static void preOrder2(Node root){
        if(root==null) return ;
        Stack<Node> stack = new Stack<>();
        stack.push(root);//先放进来
        while(!stack.isEmpty()){
            Node node =stack.pop();
            System.out.print(node.value);
            if(node.right!=null) stack.push(node.right);//先进右节点，后出
            if(node.left!=null) stack.push(node.left);
        }
    }
     private static void midOrder2(Node root){
        if(root==null) return ;
        Stack<Node> stack = new Stack<>();
        Node cur =root;
        while(!stack.isEmpty() || cur != null){
            while(cur!=null){
                stack.push(cur);
                cur=cur.left;
            }
            Node node = stack.pop();
            System.out.print(node.value);
            if(node.right!=null) cur=node.right;
        }
    }
    private static void postOrder2(Node root){
        if(root==null) return ;
        Stack<Node> stack = new Stack<>();
        Stack<Node> stack2 = new Stack<>();
        stack.push(root);//先放进来
        while(!stack.isEmpty()){
            Node node =stack.pop();
            stack2.push(node);
            if(node.left!=null) stack.push(node.left);
            if(node.right!=null) stack.push(node.right);//先进右节点，后出
        }
        while(!stack2.isEmpty()){
            System.out.print(stack2.pop().value);
        }
    }
    
 //层序遍历BFS
    private static void bfs(Node root){
         if(root==null) return ;
         Queue<Node> queue = new LinkedList<>();
         queue.add(root);
         while(!queue.isEmpty()){
         Node node = queue.poll();
            System.out.print(node.value);
            if(node.left!=null) queue.add(node.left);
            if(node.right!=null) queue.add(node.right);

        }

    }
     public static void main(String[] args) {
          Node nodeA = new Node("A");
          Node nodeB = new Node("B");
          Node nodeC = new Node("C");
          Node nodeD = new Node("D");
          Node nodeE = new Node("E");
          Node nodeF = new Node("F");
          Node nodeG = new Node("G");

          nodeA.left = nodeB;
          nodeA.right = nodeC;
          nodeB.left = nodeD;
          nodeB.right = nodeE;
          nodeC.right = nodeF;
          nodeE.left = nodeG;
          preOrder(nodeA);
          System.out.println();//换行
          midOrder(nodeA);
          System.out.println();//换行
          postOrder(nodeA);
          System.out.println("栈实现");
          preOrder2(nodeA);
         System.out.println();
          midOrder2(nodeA);
          System.out.println();
          postOrder2(nodeA);
         System.out.println();
          bfs(nodeA);

     }
//     定义节点
     public static class Node{
          public String value;
          public Node left;
          public Node right;
          public Node(String value){
               this.value = value;
          }
     }

}

图解：

四、详解BFS && DFS

DFS：深度优先搜索，前中后序遍历
BFS：宽度优先搜索，高度顺序一层一层的访问整棵树

五、二叉搜索树实现

package 刷题;

public class BST {
    class TreeNode {//定义节点
        int val;
        TreeNode left;
        TreeNode right;

        private TreeNode(int x) {
            this.val = x;
        }

        public void insert(int value) {//插入元素
            if (value <= val) {  //go to left
            if (left==null) {
                left=new TreeNode(value);
            }else{
                left.insert(value);
            }

            }else{  //go to right
                if (right==null){
                    right=new TreeNode(value);
                }else{
                    right.insert(value);
                }
            }
        }
//判断是否包含
        public boolean constains(int value) {
            if (val==value){
                return true;
            }else if (value<val){// go to left
                if (left==null){
                    return false;
                }else
                return left.constains(value);
            }else{
                if (right==null){
                    return false;
                }else
                    return right.constains(value);
            }
        }
        public  void printinOrder(){//输出打印
            if(left!=null){
                left.printinOrder();
            }
            System.out.println(val);    
        if(right!=null){
                right.printinOrder();
            }
            System.out.println(val);
            }
         }
    }