从Java看数据结构之——树和他的操作集

写在前面

树这种数据结构在计算机世界中有广泛的应用，比如操作系统中用到了红黑树，数据库用到了B+树，编译器中的语法树，内存管理用到了堆（本质上也是树），信息论中的哈夫曼编码等等等等。而树的实现和他的操作集也是笔试面试中常见的考核项目。

树的实现

与C语言的结构体+指针的实现方式不同，Java中树的实现当然是基于类。以二叉树为例，树的实现可以用下面这样的形式：

 public class BinaryTree<T extends Comparable<T>> {
     private BinaryTree<T> root;
     //定义存储内容：内容、左子树、右子树
     public class Node<T extends Comparable<T>>{
         T data;
         BinaryTree<T> left;
         BinaryTree<T> right;
         //也可以有父节点
         BinaryTree<T> parent;

         public Node(T data, BinaryTree<T> left, BinaryTree<T> right, BinaryTree<T> parent) {
             this.data = data;
             this.left = left;
             this.right = right;
             this.parent = parent;
         }
     }

     //定义方法：增、删、查、改。

     public boolean insert(int x){
         ...
     }
     public boolean delete(int x){
         ...
     }
 }

要注意，为了清晰树中数据的含义，我们一般不直接把树节点当做其成员变量，而是在其中新建内部类将其打包。针对子节点不止2个的多叉树，只需要把上面的left，right等合并成一个BinaryTree<T>类型的数组即可。

树的遍历

树的遍历应当是我们的基本功，里面涉及了后面图论算法中的深度优先搜索（DFS）和广度优先搜索（BFS），因此虽然简单但也很重要。在树的遍历中，往往对应着递归算法和非递归算法（层序遍历除外）。递归算法往往能写出很精简的代码，但是运行过程中会占用大量的系统资源。因此，非递归算法在这一点上还是更有优势。我们也应该更着重记忆他的非递归算法。面试过程中，我们甚至可以和面试官讨论所要求的写法。

先来看看前中后序遍历的递归写法：

 public void preOrderTraversal(BinaryTree<T> tree){
     if(tree==null) return;
     System.out.print(tree.node.data+" ");
     preOrderTraversal(tree.node.left);
     preOrderTraversal(tree.node.right);
 }

 //中序遍历
 public void inOrderTraversal(BinaryTree<T> tree){
     if(tree==null) return;
     inOrderTraversal(tree.node.left);
     System.out.print(tree.node.data+" ");
     inOrderTraversal(tree.node.right);
 }

 //后序遍历
 public void pastOrderTraversal(BinaryTree<T> tree){
     if(tree==null) return;
     pastOrderTraversal(tree.node.left);
     pastOrderTraversal(tree.node.right);
     System.out.print(tree.node.data+" ");
 }

看起来相当简单，也相当好记对吧。再来看非递归怎么在Java中实现：

树的前序遍历和中序遍历的非递归算法都是用堆栈来实现，具体实现如下。

 public void preOrderTraversal(){
     Stack<BinaryTree<T>> st = new Stack<>();
     BinaryTree<T> tmp = this;
     while(tmp!=null || !st.empty()){
         while(tmp!=null){
             System.out.print(tmp.node.data+" ");
             st.push(tmp);
             tmp=tmp.node.left;//一路向左
         }
         if(!st.empty()){
             tmp=st.pop();
             tmp=tmp.node.right;//偶尔向右
         }
     }
     System.out.println();
 }

 public void inOrderTraversal(){
     Stack<BinaryTree<T>> st = new Stack<>();
     BinaryTree<T> tmp = this;
     while(tmp!=null || !st.empty()){
         while(tmp!=null){
             st.push(tmp);
             tmp=tmp.node.left;
         }
         if(!st.empty()){
             tmp=st.pop();
             //输出变到这里，仅此而已
             System.out.println(tmp.node.data);
             tmp=tmp.node.right;
         }
     }
 }

后序遍历思路相似，由于后序遍历是第三次经过才进行输出（见上图），而上面的while循环和if代码块分别表示第一次见和第二次见，因此需要增加一个标志位在每一个节点，用来标明是不是在if代码块中第一次看见它。这么说并不明显，自己实现一遍应该会印象深刻一点。

 //后续非递归
 public void PastOrderTraversal(){
     BinaryTree<T> Tmp = this;
     Stack<BinaryTree<T>> st = new Stack<>();
     while(Tmp!=null || !st.empty()){
         while(Tmp!=null){
             st.push(Tmp);
             Tmp=Tmp.node.left;
         }
         if(!st.empty()){//if代码块
             Tmp=st.pop();
             if(Tmp.node.IsFirstTraversal){//这里判断是不是第一次进if代码块
                 Tmp.node.IsFirstTraversal=false;//进来过了，置位false，下一次就可以输出了
                 st.push(Tmp);
                 Tmp=Tmp.node.right;
             }
             else{//不是第一次，输出
                 System.out.print(Tmp.node.data+" ");
             }
         }
     }
 }

层序遍历只有非递归写法，没有递归的方法。层序遍历利用的数据结构是队列。遍历应该先从根节点开始，首先将根节点入队，然后开始执行循环：节点出队、访问节点（print）、左右儿子入队。

 //层序遍历
 public void levelOrderTraversal(){
     Queue<BinaryTree<T>> tQueue = new ArrayDeque<>();
     BinaryTree<T> tmp = this;
     tQueue.add(tmp);
     while(!tQueue.isEmpty()){
         tmp = tQueue.remove();
         System.out.print(tmp.node.data+" ");
         if(tmp.node.left!=null) tQueue.add(tmp.node.left);
         if(tmp.node.right!=null) tQueue.add(tmp.node.right);
     }
 }

操作集

1.插入

     private BinaryTree<T> insert(BinaryTree<T> t, Node<T> n){
         if(t==null) {
             t = new BinaryTree<>();
             t.node = n;
             return t;
         }
         int cmp = n.data.compareTo(t.node.data);
         if(cmp==0) return null;//节点存在
         else if(cmp<0) t.node.left = insert(t.node.left, n);
         else t.node.right = insert(t.node.right, n);
         return t;
     }

     public void insert(T x){
         Node<T> n = new Node<>(x,null, null, null);
         if(this.node==null){
             this.node = n;
             return;
         }
         insert(this,n);
     }

2.查找

普通查找比较好实现，这个就是利用了二分查找的思想。

 　　 /**
      * 查找
      * @param t 树
      * @param x 查找的值
      * @return 值所在树
      */
     private BinaryTree<T> find(BinaryTree<T> t, T x){
         int cmp = x.compareTo(t.node.data);
         if(cmp==0){//找到了
             return t;
         }
         else if(cmp<0) return find(t.node.left,x);
         else return find(t.node.right,x);
     }

     public BinaryTree<T> find(T x){
         return find(this, x);
     }