二叉树实现（java）

从二叉树的定义可知，一棵非空的二叉树由根结点及左、右子树这三个基本部分组成。因此，在任一给定结点上，可以按某种次序执行节点本身的访问，左子树节点的访问和右子树节点的访问。下面的示例代码实现了二叉树的构建、二叉树的遍历（包含递归和非递归方式的实现）、二叉树的索引等。具体解释在代码中都有注释。代码如下：

/** * BinaryTree.java * Copyright (C) @2016 GuangDong Eshore Techonlogy Co. Ltd * @version: 1.0 */package com.learn.test;import java.util.Stack;/** * @desc:二叉树(递归与非递归方式实现) */public class BinaryTree {private static Node rootNode; //根节点/** * 构建树 * @desc: * @param node */public void addNode(Node node){if(rootNode == null){rootNode = new Node();rootNode.setValue(node.getValue());}else{int rootValue = rootNode.getValue();if(node.getValue() < rootValue){addChildNode(rootNode, node, 1);}else{addChildNode(rootNode, node, 2);}}}public void addChildNode(Node rootNode, Node node, int flag){ //flag: 1：左边节点；2：右边节点Node nextNode = null;if(flag == 1){nextNode = rootNode.getLeftNode();}else{nextNode = rootNode.getRightNode();}if(nextNode == null){if(flag == 1){rootNode.setLeftNode(node);}else{rootNode.setRightNode(node);}}else{if(node.getValue() < nextNode.getValue()){addChildNode(nextNode, node, 1);}else{addChildNode(nextNode, node, 2);}}}/** * 前序遍历(递归) * @desc:遍历顺序：根节点----左子树----右子树 * @param rootNode */public void preOrder(Node rootNode){if(rootNode != null){System.out.print(rootNode.getValue() + ",");preOrder(rootNode.getLeftNode());preOrder(rootNode.getRightNode());}}/** * 前序遍历(非递归实现1) * @desc:遍历顺序：根节点----左子树----右子树 * @param node */public void preOrderWithNonRecursive1(Node node){Stack<node> stack = new Stack<node>();while(node != null || stack.size() > 0){while(node != null){System.out.print(node.getValue() + ",");stack.push(node);node = node.getLeftNode();}if(stack.size() > 0){node = stack.pop();node = node.getRightNode();}}}/** * 前序遍历(非递归实现2) * @desc:遍历顺序：根节点----左子树----右子树 * @param node */public void preOrderWithNonRecursive2(Node node){Stack<node> stack = new Stack<node>();while(node != null || stack.size() > 0){//遍历左子树while(node != null){System.out.print(node.getValue() + ",");stack.push(node);node = node.getLeftNode();}//遍历右子树Node rightNode = null;while(stack.size() > 0){node = stack.pop();rightNode = node.getRightNode();if(rightNode != null){System.out.print(rightNode.getValue() + ",");if(rightNode.getRightNode() != null){stack.push(rightNode);}node = rightNode.getLeftNode();break;}}}}/** * 中序遍历(递归) * @desc:遍历顺序：左子树----根节点----右子树 * @param node */public void midOrder(Node node){if(node != null){midOrder(node.getLeftNode());System.out.print(node.getValue() + ",");midOrder(node.getRightNode());}}/** * 中序遍历(非递归实现) * @desc:左子树----根节点----右子树 * @param node */public void midOrderWithNonRecursive(Node node){Stack<node> stack = new Stack<node>();while(node != null || stack.size() > 0){while(node != null){stack.push(node);node = node.getLeftNode();}if(stack.size() > 0){node = stack.pop();System.out.print(node.getValue() + ",");node = node.getRightNode();}}}/** * 后序遍历(递归) * @desc:左子树----右子树----根节点 * @param node */public void lastOrder(Node node){if(node != null){lastOrder(node.getLeftNode());lastOrder(node.getRightNode());System.out.print(node.getValue() + ",");}}/** * 后序遍历(非递归实现) * @desc:左子树----右子树----根节点 * @param node */public void lastOrderWithNonRecursive1(Node node){Stack<node> stack = new Stack<node>();Stack<node> tempStack = new Stack<node>(); //存放已经遍历过且含有右子树的节点Node tempNode = null;while(node != null || stack.size() > 0){//遍历左子树while(node != null){stack.push(node);node = node.getLeftNode();}if(stack.size() > 0){node = stack.peek(); //获取一个节点if(tempStack.size() > 0){tempNode = tempStack.peek();if(node == tempNode){ //说明此节点右子树已经遍历，下面处理时直接输出结果，不再遍历其右节点tempStack.pop();}}if(node.getRightNode() == null || node == tempNode){ //若无右子树或此节点已经遍历过，则输出根节点结果，否则继续遍历右子树System.out.print(node.getValue() + ",");stack.pop();node = null;}else{ //若有右子树,然后继续遍历右子树tempStack.push(node); //将此节点放入栈中，目的是当再次遍历到此节点时（说明此节点右子树已经遍历），直接输出结果，不再遍历其右节点node = node.getRightNode();}}}}/** * 后序遍历(非递归实现) * @desc:左子树----右子树----根节点 * @param node */public void lastOrderWithNonRecursive2(Node node){Node tempNode = null; //存储最新输出过结果的节点，当一个节点的右节点等于tempNode，说明此节点已经遍历过（但未输出结果），直接输出结果Stack<node> stack = new Stack<node>();while(node != null || stack.size() > 0){//遍历左子树while(node != null){stack.push(node);node = node.getLeftNode();}if(stack.size() > 0){node = stack.peek().getRightNode(); //获取栈顶节点的右节点，若无右子树或此节点已经遍历过（但未输出结果），则输出结果；否则，若有右子树，则继续遍历右子树if(node == null || tempNode == node){ //若无右子树或此节点已经遍历过（但未输出结果），则输出根节点结果；否则继续遍历右子树node = stack.pop();System.out.print(node.getValue() + ",");tempNode = node; //将当前节点保存起来node = null;}}}}/** * 在二叉树中查找节点是否存在 * @desc: * @param value * @return */public boolean searchInBinaryTree(int value){boolean flag = false;while(rootNode != null){if(value == rootNode.getValue()){flag = true;break;}else if(value < rootNode.getValue()){ //遍历左子树rootNode = rootNode.getLeftNode();}else{ //遍历右子树rootNode = rootNode.getRightNode();}}return flag;}/** * 初始化一棵树 */public void buildBinaryTree(){Node node1 = new Node(10);Node node2 = new Node(7);Node node3 = new Node(16);Node node4 = new Node(8);Node node5 = new Node(5);Node node6 = new Node(3);Node node7 = new Node(1);Node node8 = new Node(6);Node node9 = new Node(19);Node node10 = new Node(12);Node node11 = new Node(9);this.addNode(node1);this.addNode(node2);this.addNode(node3);this.addNode(node4);this.addNode(node5);this.addNode(node6);this.addNode(node7);this.addNode(node8);this.addNode(node9);this.addNode(node10);this.addNode(node11);}/** * 树结构定义 * @desc: */class Node{private int value;private Node leftNode;private Node rightNode;public Node(){};public Node(int value){this.value = value;}public int getValue() {return value;}public void setValue(int value) {this.value = value;}public Node getLeftNode() {return leftNode;}public void setLeftNode(Node leftNode) {this.leftNode = leftNode;}public Node getRightNode() {return rightNode;}public void setRightNode(Node rightNode) {this.rightNode = rightNode;}}/** * @desc: * @param args */public static void main(String[] args) {BinaryTree test = new BinaryTree();//*************构建树**********************test.buildBinaryTree();//*************前序遍历（递归算法）*************System.out.println("前序遍历结果：");test.preOrder(rootNode);System.out.println();//*************前序遍历（非递归算法）*************test.preOrderWithNonRecursive1(rootNode);System.out.println();test.preOrderWithNonRecursive2(rootNode);System.out.println();//*************中序遍历（递归算法）*************System.out.println();System.out.println("中序遍历结果：");test.midOrder(rootNode);System.out.println();//*************中序遍历（非递归算法）*************test.midOrderWithNonRecursive(rootNode);System.out.println();//*************后序遍历（递归算法）*************System.out.println();System.out.println("后序遍历结果：");test.lastOrder(rootNode);System.out.println();//*************后序遍历（非递归算法）*************test.lastOrderWithNonRecursive1(rootNode);System.out.println();test.lastOrderWithNonRecursive2(rootNode);System.out.println();//*************在二叉树中查找节点是否存在**********System.out.println();System.out.println("在二叉树中查找节点是否存在：");System.out.println("查找节点【7】是否存在：" + test.searchInBinaryTree(7));System.out.println("查找节点【9】是否存在：" + test.searchInBinaryTree(9));System.out.println("查找节点【27】是否存在：" + test.searchInBinaryTree(27));}}

结果如下：
前序遍历结果：
10,7,5,3,1,6,8,9,16,12,19,
10,7,5,3,1,6,8,9,16,12,19,
10,7,5,3,1,6,8,9,16,12,19,


中序遍历结果：
1,3,5,6,7,8,9,10,12,16,19,
1,3,5,6,7,8,9,10,12,16,19,


后序遍历结果：
1,3,6,5,9,8,7,12,19,16,10,
1,3,6,5,9,8,7,12,19,16,10,
1,3,6,5,9,8,7,12,19,16,10,


在二叉树中查找节点是否存在：
查找节点【7】是否存在：true
查找节点【9】是否存在：true
查找节点【27】是否存在：false