Java 二叉树遍历
package edu.cumt.jnotnull; import java.util.Stack; public class BinaryTree { protected Node root; public BinaryTree(Node root) { this.root = root; } public Node getRoot() { return root; } /** 构造树 */ public static Node init() { Node a = new Node('A'); Node b = new Node('B', null, a); Node c = new Node('C'); Node d = new Node('D', b, c); Node e = new Node('E'); Node f = new Node('F', e, null); Node g = new Node('G', null, f); Node h = new Node('H', d, g); return h;// root } /** 访问节点 */ public static void visit(Node p) { System.out.print(p.getKey() + " "); } /** 递归实现前序遍历 */ protected static void preorder(Node p) { if (p != null) { visit(p); preorder(p.getLeft()); preorder(p.getRight()); } } /** 递归实现中序遍历 */ protected static void inorder(Node p) { if (p != null) { inorder(p.getLeft()); visit(p); inorder(p.getRight()); } } /** 递归实现后序遍历 */ protected static void postorder(Node p) { if (p != null) { postorder(p.getLeft()); postorder(p.getRight()); visit(p); } } /** 非递归实现前序遍历 */ protected static void iterativePreorder(Node p) { Stack<Node> stack = new Stack<Node>(); if (p != null) { stack.push(p); while (!stack.empty()) { p = stack.pop(); visit(p); if (p.getRight() != null) stack.push(p.getRight()); if (p.getLeft() != null) stack.push(p.getLeft()); } } } /** 非递归实现前序遍历2 */ protected static void iterativePreorder2(Node p) { Stack<Node> stack = new Stack<Node>(); Node node = p; while (node != null || stack.size() > 0) { while (node != null) {//压入所有的左节点,压入前访问它 visit(node); stack.push(node); node = node.getLeft(); } if (stack.size() > 0) {// node = stack.pop(); node = node.getRight(); } } } /** 非递归实现后序遍历 */ protected static void iterativePostorder(Node p) { Node q = p; Stack<Node> stack = new Stack<Node>(); while (p != null) { // 左子树入栈 for (; p.getLeft() != null; p = p.getLeft()) stack.push(p); // 当前节点无右子或右子已经输出 while (p != null && (p.getRight() == null || p.getRight() == q)) { visit(p); q = p;// 记录上一个已输出节点 if (stack.empty()) return; p = stack.pop(); } // 处理右子 stack.push(p); p = p.getRight(); } } /** 非递归实现后序遍历 双栈法 */ protected static void iterativePostorder2(Node p) { Stack<Node> lstack = new Stack<Node>(); Stack<Node> rstack = new Stack<Node>(); Node node = p, right; do { while (node != null) { right = node.getRight(); lstack.push(node); rstack.push(right); node = node.getLeft(); } node = lstack.pop(); right = rstack.pop(); if (right == null) { visit(node); } else { lstack.push(node); rstack.push(null); } node = right; } while (lstack.size() > 0 || rstack.size() > 0); } /** 非递归实现后序遍历 单栈法*/ protected static void iterativePostorder3(Node p) { Stack<Node> stack = new Stack<Node>(); Node node = p, prev = p; while (node != null || stack.size() > 0) { while (node != null) { stack.push(node); node = node.getLeft(); } if (stack.size() > 0) { Node temp = stack.peek().getRight(); if (temp == null || temp == prev) { node = stack.pop(); visit(node); prev = node; node = null; } else { node = temp; } } } } /** 非递归实现后序遍历4 双栈法*/ protected static void iterativePostorder4(Node p) { Stack<Node> stack = new Stack<Node>(); Stack<Node> temp = new Stack<Node>(); Node node = p; while (node != null || stack.size() > 0) { while (node != null) { temp.push(node); stack.push(node); node = node.getRight(); } if (stack.size() > 0) { node = stack.pop(); node = node.getLeft(); } } while (temp.size() > 0) { node = temp.pop(); visit(node); } } /** 非递归实现中序遍历 */ protected static void iterativeInorder(Node p) { Stack<Node> stack = new Stack<Node>(); while (p != null) { while (p != null) { if (p.getRight() != null) stack.push(p.getRight());// 当前节点右子入栈 stack.push(p);// 当前节点入栈 p = p.getLeft(); } p = stack.pop(); while (!stack.empty() && p.getRight() == null) { visit(p); p = stack.pop(); } visit(p); if (!stack.empty()) p = stack.pop(); else p = null; } } /** 非递归实现中序遍历2 */ protected static void iterativeInorder2(Node p) { Stack<Node> stack = new Stack<Node>(); Node node = p; while (node != null || stack.size() > 0) { while (node != null) { stack.push(node); node = node.getLeft(); } if (stack.size() > 0) { node = stack.pop(); visit(node); node = node.getRight(); } } } /** * @param args */ public static void main(String[] args) { BinaryTree tree = new BinaryTree(init()); System.out.print(" Pre-Order:"); preorder(tree.getRoot()); System.out.println(); System.out.print(" In-Order:"); inorder(tree.getRoot()); System.out.println(); System.out.print("Post-Order:"); postorder(tree.getRoot()); System.out.println(); System.out.print(" Pre-Order:"); iterativePreorder(tree.getRoot()); System.out.println(); System.out.print("Pre-Order2:"); iterativePreorder2(tree.getRoot()); System.out.println(); System.out.print(" In-Order:"); iterativeInorder(tree.getRoot()); System.out.println(); System.out.print(" In-Order2:"); iterativeInorder2(tree.getRoot()); System.out.println(); System.out.print(" Post-Order:"); iterativePostorder(tree.getRoot()); System.out.println(); System.out.print("Post-Order2:"); iterativePostorder2(tree.getRoot()); System.out.println(); System.out.print("Post-Order3:"); iterativePostorder3(tree.getRoot()); System.out.println(); System.out.print("Post-Order4:"); iterativePostorder4(tree.getRoot()); System.out.println(); } }
class DataNode{ int data; DataNode leftChild = null; DataNode rightChild = null; } public class NodeTree { DataNode rootNode; DataNode tempNode; //int index_root; DataNode left_childDataNode; DataNode right_childDataNode; public DataNode initRootNode(int[] preArray){ rootNode = new DataNode(); rootNode.data = preArray[0]; return rootNode; } public void BuildTree(int[] preArray,int[] midArray,DataNode rootNode){ int index_root = getIndex(midArray, rootNode.data); int lengthOfRightTree = preArray.length - index_root -1; int[] preArray_left; int[] preArray_right; int[] midArray_left; int[] midArray_right; if (index_root>0) { left_childDataNode = new DataNode(); if (index_root==1) { left_childDataNode.data = midArray[0]; rootNode.leftChild = left_childDataNode; }else { preArray_left = new int[index_root]; midArray_left = new int[index_root]; System.arraycopy(preArray, 1, preArray_left, 0, index_root); System.arraycopy(midArray, 0, midArray_left, 0, index_root); left_childDataNode.data = preArray_left[0]; rootNode.leftChild = left_childDataNode; BuildTree(preArray_left, midArray_left, left_childDataNode); } } if (lengthOfRightTree>0) { right_childDataNode = new DataNode(); if (lengthOfRightTree==1) { right_childDataNode.data = midArray[index_root+1]; rootNode.rightChild = right_childDataNode; return; }else { preArray_right = new int[lengthOfRightTree]; midArray_right = new int[lengthOfRightTree]; System.arraycopy(preArray, index_root+1, preArray_right, 0,lengthOfRightTree); System.arraycopy(midArray, index_root+1, midArray_right, 0, lengthOfRightTree); right_childDataNode.data = preArray_right[0]; rootNode.rightChild = right_childDataNode; BuildTree(preArray_right, midArray_right,right_childDataNode); } } } public int getIndex(int[] array,int temp){ int index = -1; for (int i = 0; i < array.length; i++) { if (array[i]==temp) { index = i; return index; } } return index; } //后序遍历 public void postOrderTraverse(DataNode node){ if (node==null) { return; } postOrderTraverse(node.leftChild); postOrderTraverse(node.rightChild); System.out.print(node.data); } //前序遍历 public void preOrderTraverse(DataNode node){ if (node==null) { return; } System.out.print(node.data); preOrderTraverse(node.leftChild); preOrderTraverse(node.rightChild); } //中序遍历 public void inOrderTraverse(DataNode node){ if (node==null) { return; } inOrderTraverse(node.leftChild); System.out.print(node.data); inOrderTraverse(node.rightChild); } public static void main(String args[]){ int[] preArray = {1,2,3}; int[] midArray = {1,2,3}; NodeTree tree = new NodeTree(); DataNode headNode = tree.initRootNode(preArray); tree.BuildTree(preArray, midArray, headNode); tree.postOrderTraverse(headNode); } }