【数据结构--二叉树】Java递归实现二叉树遍历

参考链接：https://www.cnblogs.com/yaobolove/p/6213936.html

这有一棵树：

1、节点对象

package com.tree.mybinarytree;
/**
 * 二叉树TreeNode,每个node代表树中的一个节点
 * @author ZX
 * @date   2018年7月
 */
public class Node {
	//左边子节点
	private Node leftNode;
	//右边子节点
	private Node rightNode;
	//节点数据
	private String data;

	//getset
	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;
	}
	public String getData() {
		return data;
	}
	public void setData(String data) {
		this.data = data;
	}
	//constructor
	public Node() {}
	public Node(Node leftNode,Node rightNode,String data) {
		this.leftNode=leftNode;
		this.rightNode=rightNode;
		this.data=data;
	}

}

2、测试类

package com.tree.mybinarytree;

/**
 * 1、组装树 2、遍历树 3、测试
 *
 * @author zx
 *
 */
public class TreeTest {
	public static void main(String[] args) {
		//按照图片组装树
		Node G = new Node(null, null, "G");

		Node F = new Node(null, null, "F");

		Node E = new Node(null, null, "E");

		Node D = new Node(null, null, "D");

		Node C = new Node(F, G, "C");

		Node B = new Node(D, E, "B");

		Node A = new Node(B, C, "A");
		//遍历
		System.out.println("先序遍历");
		theFirstTraversal(A);
		System.out.println("");
		System.out.println("中序遍历");
		theInOrderTraversal(A);
		System.out.println("");
		System.out.println("后序遍历");
		thePostOrderTraversal(A);
		System.out.println("");

	}

	public static void printNode(Node node) {
		System.out.print(node.getData());
	}

	/**
	 * 先序遍历
	 * @param root
	 */
	public static void theFirstTraversal(Node root) { // 先序遍历
		printNode(root);
		if (root.getLeftNode() != null) { // 使用递归进行遍历左孩子
			theFirstTraversal(root.getLeftNode());
		}
		if (root.getRightNode() != null) { // 递归遍历右孩子
			theFirstTraversal(root.getRightNode());
		}
	}
	/**
	 * 中序遍历
	 * @param root
	 */
	public static void theInOrderTraversal(Node root) { // 中序遍历
		if (root.getLeftNode() != null) {
			theInOrderTraversal(root.getLeftNode());
		}
		printNode(root);
		if (root.getRightNode() != null) {
			theInOrderTraversal(root.getRightNode());
		}
	}
	/**
	 * 后序遍历
	 * @param root
	 */
	public static void thePostOrderTraversal(Node root) { // 后序遍历
		if (root.getLeftNode() != null) {
			thePostOrderTraversal(root.getLeftNode());
		}
		if (root.getRightNode() != null) {
			thePostOrderTraversal(root.getRightNode());
		}
		printNode(root);
	}

}

由于二叉查找树可以任意构造，同样的值，可以构造出很少分支的二叉查找树，显然这棵二叉树的查询效率和顺序查找差不多。若想二叉查找数的查询性能最高，需要这棵二叉查找树是平衡的，也即平衡二叉树（AVL树）