Java 手撕二叉树

先定义一个结点类

/**
 * 二叉树的结点
 * 
 * @author Administrator
 *
 */
public class Node {

	Object value;
	Node leftChild;
	Node rightChild;

	public Node(Object value) {
		this.value = value;
	}

	public Node(Object value, Node leftChild, Node rightChild) {
		this.value = value;
		this.leftChild = leftChild;
		this.rightChild = rightChild;
	}

	@Override
	public String toString() {
		return "Node [value=" + value + ", leftChild=" + leftChild + ", rightChild=" + rightChild + "]";
	}
	 
}

 

定义一个二叉树接口

public interface BinaryTree {
	
	// 是否空树  
	public boolean isEmpty();
	
	// 树结点数量
	public int size();
	
	// 获取二叉树的高度
	public int getHeight();
	
	// 查询指定值的结点
	public Node findKey(Object value);
	
	// 前序递归遍历  根结点  左结点  右结点
	public void preOrderTraverse();
	
	// 中序递归遍历   左结点  根结点  右结点
	public void inOrderTraverse();
	
	// 后序递归遍历   左结点  右结点  根结点  
	public void postOrderTraverse();
	
	// 后序递归遍历   左结点  右结点  根结点  
	public void postOrderTraverse(Node node);
	
	// 前序遍历非递归操作
	public void preOrderByStack();
	
	// 中序遍历非递归操作
	public void inOrderByStack();
	
	// 后序遍历非递归操作
	public void postOrderByStack();
	
	// 按照层次遍历二叉树
	public void levelOrderByStack();
}

 

实现二叉树的实现类

package com.java.datastructure.tree;

import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;

/**
 * 二叉树的实现
 * 
 * @author Administrator
 *
 */
public class LinkedBinaryTree implements BinaryTree {

	private Node root; // 代表根结点

	public LinkedBinaryTree() {
	}

	public LinkedBinaryTree(Node root) {
		this.root = root;
	}

	@Override
	public boolean isEmpty() {
		return root == null;
	}

	// 树结点数量
	@Override
	public int size() {
		System.out.print("二叉树的结点个数是：");
		return this.size(root);
	}

	private int size(Node root) {
		if (root == null) {
			return 0;
		} else {
			// 获取左子树的size
			int nl = this.size(root.leftChild);
			// 获取右子树的size
			int nr = this.size(root.rightChild);
			// 取较大值加1即可
			return nl + nr + 1;
		}
	}

	// 获取二叉树的高度
	@Override
	public int getHeight() {
		System.out.print("二叉树的高度是：");
		return getHeight(root);
	}

	private int getHeight(Node root) {
		if (root == null) {
			return 0;
		} else {
			// 获取左子树的高度
			int nl = this.getHeight(root.leftChild);
			// 获取右子树的高度
			int nr = this.getHeight(root.rightChild);
			// 取较大值加1即可
			return nl > nr ? nl + 1 : nr + 1;
		}
	}

	// 查询指定值的结点
	@Override
	public Node findKey(Object value) {
		System.out.println("查找结点值为" + value + "：");
		return this.findKey(value, root);
	}

	private Node findKey(Object value, Node root) {
		if (root == null) {
			return null;
		} else if (root != null && root.value == value) {
			return root;
		} else {
			Node node1 = this.findKey(value, root.leftChild);
			Node node2 = this.findKey(value, root.rightChild);
			if (node1 != null && node1.value == value) {
				return node1;
			} else if (node2 != null && node2.value == value) {
				return node2;
			} else {
				return null;
			}
		}
	}

	// 前序递归遍历 根结点 左结点 右结点
	@Override
	public void preOrderTraverse() {
		System.out.println("==========递归遍历 前序==========");
		preOrderTraverse(root);
		System.out.println();
	}

	private void preOrderTraverse(Node root) {
		if (root != null) {
			// 输出根结点的值
			System.out.print(root.value + "  ");
			// 对左子树进行前序遍历
			preOrderTraverse(root.leftChild);
			// 对右子树进行前序遍历
			preOrderTraverse(root.rightChild);
		}
	}

	// 中序递归遍历 左结点 根结点 右结点
	@Override
	public void inOrderTraverse() {
		System.out.println("==========递归遍历 中序==========");
		inOrderTraverse(root);
		System.out.println();
	}

	private void inOrderTraverse(Node root) {
		if (root != null) {
			// 遍历左结点
			this.inOrderTraverse(root.leftChild);
			// 输出根的值
			System.out.print(root.value + "  ");
			// 遍历右结点
			this.inOrderTraverse(root.rightChild);
		}
	}

	// 后序递归遍历 左结点 右结点 根结点
	@Override
	public void postOrderTraverse() {
		System.out.println("==========递归遍历 后序==========");
		postOrderTraverse(root);
		System.out.println();
	}

	@Override
	public void postOrderTraverse(Node node) {
		if (node != null) {
			// 遍历左结点
			this.postOrderTraverse(node.leftChild);
			// 遍历右结点
			this.postOrderTraverse(node.rightChild);
			// 输出根的值
			System.out.print(node.value + "  ");
		}
	}

	@Override
	public void preOrderByStack() {
		// TODO Auto-generated method stub

	}

	// 中序遍历非递归操作 左结点 根结点 右结点
	@Override
	public void inOrderByStack() {
		System.out.println("==========中序遍历非递归操作==========");
		// 创建栈
		Deque<Node> stack = new LinkedList<Node>();
		Node current = root;
		while (current != null || !stack.isEmpty()) {
			while (current != null) { // 循环   只要左边有结点，就一直循环
				stack.push(current);
				current = current.leftChild; // 中序遍历先输出左结点
			}
			if (!stack.isEmpty()) { // 判断   左边没了，就判断下右子结点
				current = stack.pop();
				System.out.print(current.value + "  ");
				current = current.rightChild;
			}
		}
		System.out.println();
	}

	@Override
	public void postOrderByStack() {
		// TODO Auto-generated method stub

	}

	// 按照层次遍历二叉树 借助队列
	@Override
	public void levelOrderByStack() {
		System.out.println("==========按照层次遍历二叉树（借助队列）==========");

		if (root == null) {
			return;
		}
		Queue<Node> queue = new LinkedList<Node>(); // 链表
		queue.add(root);
		while (queue.size() != 0) {
			int len = queue.size();
			for (int i = 0; i < len; i++) {
				Node temp = queue.poll();
				System.out.print(temp.value + "  ");
				if (temp.leftChild != null) {
					queue.add(temp.leftChild);
				}
				if (temp.rightChild != null) {
					queue.add(temp.rightChild);
				}
			}
		}
		System.out.println();
	}

}

 

测试类

package com.java.datastructure.tree;

public class TestLinkedBinaryTree {

	public static void main(String[] args) {
		// 创建一个二叉树
		Node node5 = new Node(5, null, null);
		Node node4 = new Node(4, null, node5);
		Node node7 = new Node(7, null, null);
		Node node6 = new Node(6, null, node7);
		Node node3 = new Node(3, null, null);
		Node node2 = new Node(2, node3, node6);
		Node node1 = new Node(1, node4, node2);
		BinaryTree tree = new LinkedBinaryTree(node1);

		// 判断二叉树是否为空
		System.out.println("判断二叉树是否为空：" + tree.isEmpty());

		// 判断二叉树是否为空

		// 递归遍历 先序    1 4 5 2 3 6 7 
		tree.preOrderTraverse();

		// 递归遍历 中序   4 5 1 3 2 6 7 
		tree.inOrderTraverse();

		// 递归遍历 后序  5 4 3 7 6 2 1 
		tree.postOrderTraverse();
		
		// 二叉树的高度
		System.out.println(tree.getHeight());
		
		// 树结点数量
		System.out.println(tree.size());

		// 非递归遍历 先序

		// 非递归遍历 中序   4 5 1 3 2 6 7 
		tree.inOrderByStack();

		// 非递归遍历 后序
		
		// 按照层次遍历  借助队列   1 4 2 5 3 6 7 
		tree.levelOrderByStack();
		
		// 在二叉树中查找某个值
		System.out.println(tree.findKey(4));
	}

}

 

测试结果