BinaryTree的中序遍历和层次遍历

TreeNode

package com.lxw.treeTest;  
  
public class TreeNode<T> {  
    private T data;  
  
    private TreeNode<T> leftChild;  
  
    private TreeNode<T> rightChild;  
  
    public T getData() {  
        return data;  
    }  
  
    public void setData(T data) {  
        this.data = data;  
    }  
  
    public TreeNode<T> getLeftChild() {  
        return leftChild;  
    }  
  
    public void setLeftChild(TreeNode<T> leftChild) {  
        this.leftChild = leftChild;  
    }  
  
    public TreeNode<T> getRightChild() {  
        return rightChild;  
    }  
  
    public void setRightChild(TreeNode<T> rightChild) {  
        this.rightChild = rightChild;  
    }  
  
  
}

MyTree

package com.lxw.treeTest;  
  
import java.util.ArrayList;  
import java.util.Deque;  
import java.util.LinkedList;  
import java.util.List;  
  
public class MyTree<T> {  
    private TreeNode<T> root;  
  
    /**  
     * init current binary tree     * @param root     */    public MyTree(TreeNode<T> root) {  
        this.root = root;  
    }  
  
  
  
    public TreeNode<T> getRoot() {  
        return root;  
    }  
  
    public void setRoot(TreeNode<T> root) {  
        this.root = root;  
    }  
  
    public boolean isEmpty() {  
        return  root == null;  
    }  
  
    public void insertLeft(TreeNode<T> root, TreeNode<T> node) {  
        root.setLeftChild(node);  
    }  
  
    public void insertRight(TreeNode<T> root, TreeNode<T> node) {  
        root.setRightChild(node);  
    }  
  
    /**  
     * 中序遍历 (递归)  
     * @param root  
     */  
    public void inOrder(TreeNode<T> root){  
        if(root == null) {  
            return;  
        }  
        inOrder(root.getLeftChild());  
        System.out.print(root.getData() + " ");  
        inOrder(root.getRightChild());  
    }  
  
    /**  
     * 中序遍历（非递归）  
     * @param root  
     * @return  
     */  
    public void inorderTraversal(TreeNode<T> root) {  
        Deque<TreeNode> stk = new LinkedList<TreeNode>();  
        while (root != null || !stk.isEmpty()) {  
            while (root != null) {  
                stk.push(root);  
                root = root.getLeftChild();  
            }  
            root = stk.pop();  
            System.out.print(root.getData() + " ");  
            root = root.getRightChild();  
        }  
    }  
  
  
    /**  
     * 层次遍历    
* @param root  
     */  
    public void levelOrder(TreeNode<T> root) {  
        LinkedList<TreeNode<T>> queue = new LinkedList<>();  
        queue.add(root);  
        while (!queue.isEmpty()){  
            root = queue.pop();  
            if(root.getLeftChild() != null){  
                queue.add(root.getLeftChild());  
            }  
            if(root.getRightChild() != null){  
                queue.add(root.getRightChild());  
            }  
            System.out.print(root.getData() + " ");  
        }  
    }    
  
  
  
  
}

Test

package com.lxw.treeTest;  
  
public class Test {  
    public static void main(String[] args) {  
  
  
            TreeNode<String> nodeA = new TreeNode<>();  
            nodeA.setData("A");  
  
            TreeNode<String> nodeB = new TreeNode<>();  
            nodeB.setData("B");  
            nodeA.setLeftChild(nodeB);  
  
            TreeNode<String> nodeC = new TreeNode<>();  
            nodeC.setData("C");  
            nodeA.setRightChild(nodeC);  
  
            TreeNode<String> nodeD = new TreeNode<>();  
            nodeD.setData("D");  
            nodeB.setLeftChild(nodeD);  
  
            TreeNode<String> nodeE = new TreeNode<>();  
            nodeE.setData("E");  
            nodeB.setRightChild(nodeE);  
  
            TreeNode<String> nodeF = new TreeNode<>();  
            nodeF.setData("F");  
            nodeC.setLeftChild(nodeF);  
  
            TreeNode<String> nodeG = new TreeNode<>();  
            nodeG.setData("G");  
            nodeC.setRightChild(nodeG);  
  
        MyTree<String> tree = new MyTree<>(nodeA);  
  
  
            System.out.print("\n"+"中序遍历的结果是(递归): ");  
            tree.inOrder(nodeA);  
  
            System.out.print("\n"+"中序遍历的结果是(非递归): ");  
            tree.inorderTraversal(nodeA);  
  
            System.out.print("\n" + "层次遍历的结果是: ");  
            tree.levelOrder(nodeA);  
        }  
  
  
  
  
  
  
  
  
  
  
  
    }