二叉树

Posted 2021-02-04 tu9oh0st

二叉树（binary tree）是一棵树，其中每个节点都不能有多于两个的儿子。

下图显式一颗由一个根和两颗字数组成的二叉树，子树T_L和T_R均可能为空。

二叉树的一个性质是一颗平均二叉树的深度要比节点个数N小得多，这个性质有时很重要。分析表明，其平均深度为O($$sqrt{N}$$)，而对于特殊类型的二叉树，即二叉查找树（binary search tree），其深度的平均值是O($$log{N}?$$)。

二叉树的遍历

对于二叉树来讲最主要、最基本的运算是遍历。

遍历二叉树，是指以一定的次序访问二叉树中的每个节点。所谓访问节点是指节点进行各种操作的简称。例如，查询节点数据域的内容，或输出它的值，或找出节点位置，或是执行对节点的其他操作。遍历二叉树的过程实质是把二叉树的节点进行线性排列的过程。假设遍历二叉树时访问节点的操作就是输出节点数据域的值，那么遍历的结果得到一个线性序列。

从二叉树的递归定义可知，一颗非空的二叉树由根节点及左、右子树这三个基本部分组成。因此，在任意给定节点上，可以按某种次序执行三个操作：

1. 访问节点本身（N）
2. 遍历该节点的左子树（L）
3. 便利该节点的右子树（R）

以上三种操作有六种执行次序：
　NLR、LNR、LRN、NRL、RNL、RLN。

注意：前三种次序与后三种次序对称，故只讨论先左后右的前三种次序。

由于被访问的结点必是某子树的根，所以N(Node)、L(Left subtlee)和R(Right subtree)又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。

实现

因为一个二叉树节点最多有两个子节点，所以我们可以保存直接连接道它们的链。树节点的声明在结构上类似于双链表的声明，在声明中，节点就是由element（元素）的信息加上两个到其他节点的引用（left和right）组成的结构。

import java.util.Stack;
 
/**
 * 二叉树的链式存储
 */
public class BinaryTree {
 
  
  private TreeNode root=null;
  
  public BinaryTree(){
    root=new TreeNode(1,"rootNode(A)");
  }
  
  /**
   * 创建一棵二叉树
   * <pre>
   *           A
   *     B          C
   *  D     E            F
   *  </pre>
   * @param root
   */
  public void createBinTree(TreeNode root){
    TreeNode newNodeB = new TreeNode(2,"B");
        TreeNode newNodeC = new TreeNode(3,"C");
        TreeNode newNodeD = new TreeNode(4,"D");
        TreeNode newNodeE = new TreeNode(5,"E");
        TreeNode newNodeF = new TreeNode(6,"F");
        root.leftChild=newNodeB;
        root.rightChild=newNodeC;
        root.leftChild.leftChild=newNodeD;
        root.leftChild.rightChild=newNodeE;
        root.rightChild.rightChild=newNodeF;
  }
  
  
  public boolean isEmpty(){
    return root==null;
  }
 
  //树的高度
  public int height(){
    return height(root);
  }
  
  //节点个数
  public int size(){
    return size(root);
  }
  
  
  private int height(TreeNode subTree){
    if(subTree==null)
      return 0;//递归结束：空树高度为0
    else{
      int i=height(subTree.leftChild);
      int j=height(subTree.rightChild);
      return (i<j)?(j+1):(i+1);
    }
  }
  
  private int size(TreeNode subTree){
    if(subTree==null){
      return 0;
    }else{
      return 1+size(subTree.leftChild)
          +size(subTree.rightChild);
    }
  }
  
  //返回双亲结点
  public TreeNode parent(TreeNode element){
    return (root==null|| root==element)?null:parent(root, element);
  }
  
  public TreeNode parent(TreeNode subTree,TreeNode element){
    if(subTree==null)
      return null;
    if(subTree.leftChild==element||subTree.rightChild==element)
      //返回父结点地址
      return subTree;
    TreeNode p;
    //现在左子树中找，如果左子树中没有找到，才到右子树去找
    if((p=parent(subTree.leftChild, element))!=null)
      //递归在左子树中搜索
      return p;
    else
      //递归在右子树中搜索
      return parent(subTree.rightChild, element);
  }
  
  public TreeNode getLeftChildNode(TreeNode element){
    return (element!=null)?element.leftChild:null;
  }
  
  public TreeNode getRightChildNode(TreeNode element){
    return (element!=null)?element.rightChild:null;
  }
  
  public TreeNode getRoot(){
    return root;
  }
  
  //在释放某个结点时，该结点的左右子树都已经释放，
  //所以应该采用后续遍历，当访问某个结点时将该结点的存储空间释放
  public void destroy(TreeNode subTree){
    //删除根为subTree的子树
    if(subTree!=null){
      //删除左子树
      destroy(subTree.leftChild);
      //删除右子树
      destroy(subTree.rightChild);
      //删除根结点
      subTree=null;
    }
  }
  
  public void traverse(TreeNode subTree){
    System.out.println("key:"+subTree.key+"--name:"+subTree.data);;
    traverse(subTree.leftChild);
    traverse(subTree.rightChild);
  }
  
  //前序遍历
  public void preOrder(TreeNode subTree){
    if(subTree!=null){
      visted(subTree);
      preOrder(subTree.leftChild);
      preOrder(subTree.rightChild);
    }
  }
  
  //中序遍历
  public void inOrder(TreeNode subTree){
    if(subTree!=null){
      inOrder(subTree.leftChild);
      visted(subTree);
      inOrder(subTree.rightChild);
    }
  }
  
  //后续遍历
  public void postOrder(TreeNode subTree) {
    if (subTree != null) {
      postOrder(subTree.leftChild);
            postOrder(subTree.rightChild);
            visted(subTree);
        }
  }
  
  //前序遍历的非递归实现
  public void nonRecPreOrder(TreeNode p){
    Stack<TreeNode> stack=new Stack<TreeNode>();
    TreeNode node=p;
    while(node!=null||stack.size()>0){
      while(node!=null){
        visted(node);
        stack.push(node);
        node=node.leftChild;
      }
      <span abp="507" style="font-size:14px;">while</span>(stack.size()>0){
        node=stack.pop();
        node=node.rightChild;
      } 
    }
  }
  
  //中序遍历的非递归实现
  public void nonRecInOrder(TreeNode p){
    Stack<TreeNode> stack =new Stack<BinaryTree.TreeNode>();
    TreeNode node =p;
    while(node!=null||stack.size()>0){
      //存在左子树
      while(node!=null){
        stack.push(node);
        node=node.leftChild;
      }
      //栈非空
      if(stack.size()>0){
        node=stack.pop();
        visted(node);
        node=node.rightChild;
      }
    }
  }
  
  //后序遍历的非递归实现
  public void noRecPostOrder(TreeNode p){
    Stack<TreeNode> stack=new Stack<BinaryTree.TreeNode>();
    TreeNode node =p;
    while(p!=null){
      //左子树入栈
      for(;p.leftChild!=null;p=p.leftChild){
        stack.push(p);
      }
      //当前结点无右子树或右子树已经输出
      while(p!=null&&(p.rightChild==null||p.rightChild==node)){
        visted(p);
        //纪录上一个已输出结点
        node =p;
        if(stack.empty())
          return;
        p=stack.pop();
      }
      //处理右子树
      stack.push(p);
      p=p.rightChild;
    }
  }
  public void visted(TreeNode subTree){
    subTree.isVisted=true;
    System.out.println("key:"+subTree.key+"--name:"+subTree.data);;
  }
  
  
  /**
   * 二叉树的节点数据结构
   */
  private class  TreeNode{
    private int key=0;
    private String data=null;
    private boolean isVisted=false;
    private TreeNode leftChild=null;
    private TreeNode rightChild=null;
    
    public TreeNode(){}
    
    /**
     * @param key  层序编码
     * @param data 数据域
     */
    public TreeNode(int key,String data){
      this.key=key;
      this.data=data;
      this.leftChild=null;
      this.rightChild=null;
    }
  }
}

参考链接：https://blog.csdn.net/wuwenxiang91322/article/details/12231657
参考书籍：
《数据结构与算法分析》