二叉树实现（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