二叉树的个人理解

二叉树节点

/**
 * 节点
 * @author Administrator
 *
 */
public class Node {
	
	/**
	 * 数据
	 */
	public int data;
	
	/**
	 * 左孩子
	 */
	public Node leftChild; 
	
	/**
	 * 右孩子
	 */
	public Node rightChild;
	
	public Node() {}
	
	public Node(int data, Node leftChild, Node rightChild) {
		this.data = data;
		this.leftChild = leftChild;
		this.rightChild = rightChild;
	}
}

先序遍历

	/**
	 * 先序遍历
	 * 按照根 左 右 的顺序
	 */
	public void preOrderTraverse(Node root, List list) {
		if (root != null) {
			// 根
			list.add(root.data);
			// 遍历左子树
			this.preOrderTraverse(root.leftChild, list);
			// 遍历右子树
			this.preOrderTraverse(root.rightChild, list);
		}
	}

中序遍历

	/**
	 * 中序遍历
	 * 按照 左 根 右 的顺序
	 */
	public void inOrderTraverse(Node root, List list) {
		if (root != null) {
			// 遍历左子树
			this.inOrderTraverse(root.leftChild, list);
			// 根
			list.add(root.data);
			// 遍历右子树
			this.inOrderTraverse(root.rightChild, list);
		}
	}

后序遍历

	/**
	 * 后序遍历
	 * 按照 左 右 根 的顺序
	 */
	public void postOrderTraverse(Node root, List list) {
		if (root != null) {
			// 遍历左子树
			this.postOrderTraverse(root.leftChild, list);
			// 遍历右子树
			this.postOrderTraverse(root.rightChild, list);
			// 根
			list.add(root.data);
		}
	}

层次遍历

	public List levelOrderTraverse() {
		// 如果树为空直接返回
		if (root == null) {
			return null;
		}
		List list = new ArrayList();
		Queue<Node> queue = new LinkedList();
		
		// 根节点入队列
		queue.add(root);
		while (queue.size() > 0) { // 队列不为空
			Node p = queue.poll();
			list.add(p.data);
			if (p.leftChild != null) { // 左孩子入队
				queue.add(p.leftChild);
			}
			if (p.rightChild != null) { // 右孩子入队
				queue.add(p.rightChild);
			}
		}
		
		return list;
	}

 

节点个数

	/**
	 * 计算节点个数
	 * 左子树 + 右子树 + 1
	 */
	public int size(Node root) {
		if (root == null) {
			return 0;
		}
		// 计算左子树节点个数
		int ls = size(root.leftChild);
		// 计算右子树节点个数
		int rs = size(root.rightChild);
		// 返回左子树节点个数+右子树结点个数+1
		return ls + rs + 1;		
	}

树的深度

	/**
	 * 计算树的深度
	 * 左子树与右子树深度较大的那个 + 1
	 */
	public int height(Node root) {
		if (root == null) {
			return 0;
		}
		// 计算左子树深度
		int lh = height(root.leftChild);
		// 计算右子树深度
		int rh = height(root.rightChild);
		// 返回左子树与右子树深度较大的那个 + 1
		return (lh > rh ? lh : rh) + 1;	
	}

二叉树统一接口

import java.util.List;

/**
 * 二叉树统一的接口
 * @author Administrator
 *
 */
public interface BinaryTree {
	
	/**
	 * 先序遍历
	 * @return
	 */
	List preOrderTraverse();
	
	/**
	 * 中序遍历
	 * @return
	 */
	List inOrderTraverse();
	
	/**
	 * 后序遍历
	 * @return
	 */
	List postOrderTraverse();
	
	/**
	 * 层次遍历
	 * @return
	 */
	List levelOrderTraverse();
	
	/**
	 * 节点个数
	 * @return
	 */
	int size();
	
	/**
	 * 树的深度
	 * @return
	 */
	int height();
}

二叉树接口具体的实现类

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * 自定义二叉树
 * 底层使用二叉链表实现
 * @author Administrator
 *
 */
public class ListBinaryTree implements BinaryTree {
	
	private Node root;
	
	public ListBinaryTree() {}
	
	public ListBinaryTree(Node root) {
		this.root = root;
	}
	
	public void setRoot(Node root) {
		this.root = root;
	}

	@Override
	public List preOrderTraverse() {
		List list = new ArrayList();
		preOrderTraverse(root, list);
		return list;
	}
	
	/**
	 * 先序遍历
	 * 按照根 左 右 的顺序
	 */
	public void preOrderTraverse(Node root, List list) {
		if (root != null) {
			// 根
			list.add(root.data);
			// 遍历左子树
			this.preOrderTraverse(root.leftChild, list);
			// 遍历右子树
			this.preOrderTraverse(root.rightChild, list);
		}
	}

	@Override
	public List inOrderTraverse() {
		List list = new ArrayList();
		inOrderTraverse(root, list);
		return list;
	}
	
	/**
	 * 中序遍历
	 * 按照 左 根 右 的顺序
	 */
	public void inOrderTraverse(Node root, List list) {
		if (root != null) {
			// 遍历左子树
			this.inOrderTraverse(root.leftChild, list);
			// 根
			list.add(root.data);
			// 遍历右子树
			this.inOrderTraverse(root.rightChild, list);
		}
	}

	@Override
	public List postOrderTraverse() {
		List list = new ArrayList();
		postOrderTraverse(root, list);
		return list;
	}
	
	/**
	 * 后序遍历
	 * 按照 左 右 根 的顺序
	 */
	public void postOrderTraverse(Node root, List list) {
		if (root != null) {
			// 遍历左子树
			this.postOrderTraverse(root.leftChild, list);
			// 遍历右子树
			this.postOrderTraverse(root.rightChild, list);
			// 根
			list.add(root.data);
		}
	}
	
	@Override
	public List levelOrderTraverse() {
		// 如果树为空直接返回
		if (root == null) {
			return null;
		}
		List list = new ArrayList();
		Queue<Node> queue = new LinkedList();
		
		// 根节点入队列
		queue.add(root);
		while (queue.size() > 0) { // 队列不为空
			Node p = queue.poll();
			list.add(p.data);
			if (p.leftChild != null) { // 左孩子入队
				queue.add(p.leftChild);
			}
			if (p.rightChild != null) { // 右孩子入队
				queue.add(p.rightChild);
			}
		}
		
		return list;
	}

	@Override
	public int size() {
		return size(root);
	}
	
	/**
	 * 计算节点个数
	 * 左子树 + 右子树 + 1
	 */
	public int size(Node root) {
		if (root == null) {
			return 0;
		}
		// 计算左子树节点个数
		int ls = size(root.leftChild);
		// 计算右子树节点个数
		int rs = size(root.rightChild);
		// 返回左子树节点个数+右子树结点个数+1
		return ls + rs + 1;		
	}

	@Override
	public int height() {
		return height(root);
	}
	
	/**
	 * 计算树的深度
	 * 左子树与右子树深度较大的那个 + 1
	 */
	public int height(Node root) {
		if (root == null) {
			return 0;
		}
		// 计算左子树深度
		int lh = height(root.leftChild);
		// 计算右子树深度
		int rh = height(root.rightChild);
		// 返回左子树与右子树深度较大的那个 + 1
		return (lh > rh ? lh : rh) + 1;	
	}

}

测试类

import java.util.ArrayList;
import java.util.List;

public class TestBinaryTree {

	public static void main(String[] args) {
		// 创建二叉树
		Node node7 = new Node(7, null, null);
		Node node6 = new Node(6, null, node7);
		Node node3 = new Node(3, null, null);
		Node node5 = new Node(5, null, null);
		Node node4 = new Node(4, null, node5);
		Node node2 = new Node(2, node3, node6);
		Node node1 = new Node(1, node4, node2);
		
		ListBinaryTree btree = new ListBinaryTree(node1);
		
		// 先序遍历 1 4 5 2 3 6 7
		List<Integer> preList = new ArrayList<Integer>();
		preList = btree.preOrderTraverse();
		System.out.print("先序遍历:");
		for (int t: preList) {
			System.out.print(" " + t);
		}
		System.out.println();
		
		// 中序遍历 4 5 1 3 2 6 7
		List<Integer> inList = new ArrayList<Integer>();
		inList = btree.inOrderTraverse();
		System.out.print("中序遍历:");
		for (int t: inList) {
			System.out.print(" " + t);
		}
		System.out.println();
		
		// 后序遍历 5 4 3 7 6 2 1
		List<Integer> postList = new ArrayList<Integer>();
		postList = btree.postOrderTraverse();
		System.out.print("后序遍历:");
		for (int t: postList) {
			System.out.print(" " + t);
		}
		System.out.println();
		
		// 层次遍历 1 4 2 5 3 6 7
		List<Integer> levelList = new ArrayList<Integer>();
		levelList = btree.levelOrderTraverse();
		System.out.print("层次遍历:");
		for (int t: levelList) {
			System.out.print(" " + t);
		}
		System.out.println();
		
		// 二叉树的高度 4
		System.out.println("深度: " + btree.height());
		
		// 二叉树的节点个数 7
		System.out.println("节点个数: " + btree.size());
		
	}

}

结果

先序遍历: 1 4 5 2 3 6 7
中序遍历: 4 5 1 3 2 6 7
后序遍历: 5 4 3 7 6 2 1
层次遍历: 1 4 2 5 3 6 7
深度: 4
节点个数: 7