二叉树手写

特点

• 每个节点最多有两颗子树。
• 左子树和右子树是有顺序的，次序不能颠倒。
• 即使某节点只有一个子树，也要区分左右子树。

树图

伪代码实现

/**
 * 节点类
 */
@Data
public class Node {

	// 节点内容
	int value;
	// 左节点
	Node leftChild;
	// 右节点
	Node rightChild;

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

	@Override
	public String toString() {
		return String.valueOf(value);
	}
}

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

/**
 * 二叉树
 */
public class BinaryTree {

	// 根节点
	private Node root = null;

	// 构造方法
	// 有参数
	public BinaryTree(int value) {
		root = new Node(value);
		root.leftChild = null;
		root.rightChild = null;
	}

	// 无参数
	public BinaryTree() {
	}

	public Node getRoot() {
		return root;
	}

	/**
	 * 插入节点
	 *
	 * @param value 节点的值
	 * @return 插入成功返回true，否则返回false
	 */
	public boolean add(int value) {
		// 定义变量用来标识是否插入成功，默认值表示插入成功
		boolean success = true;
		// 根据内容创建节点对象
		Node node = new Node(value);
		// 判断根节点是否为null，如果为null，则将node对象作为根节点对象
		if (root == null) { // 没有根节点
			// 将node对象作为根节点对象
			root = node;
			// 设置左右节点为null
			root.leftChild = null;
			root.rightChild = null;
		} else { // 有根据节点
			// 定义变量记录当前遍历的节点对象：默认从根节点对象开始遍历
			Node current = root;
			// 遍历树上的所有节点对象
			while (true) {
				if (value < current.value) {
					// 来到这里说明node对象应该添加到current节点对象的左边
					if (current.leftChild == null) {
						current.leftChild = node;
						break;
					}
					// 获得current节点的左子节点对象，并赋值给current变量
					current = current.leftChild;
				} else if (value > current.value) {
					// 来到这里说明node对象应该添加到current节点对象的右边
					if (current.rightChild == null) {
						current.rightChild = node;
						break;
					}
					// 获得current节点的右子节点对象，并赋值给current变量
					current = current.rightChild;
				} else { // value值已经存在了，则直接返回false
					success = false;
					break;
				}
			}
		}
		// 插入成功
		return success;
	}

	/**
	 * 根据节点内容查找节点对象
	 *
	 * @param value 内容
	 * @return 查找到的节点对象，如果没有则返回null
	 */
	public Node get(int value) {
		// 定义变量记录当前遍历的节点对象，默认从根节点开始遍历
		Node current = root;
		while (true) {
			// 判断value和current节点对象的value是否相同
			if (value == current.value) {
				// 来到这里则说明current节点对象就是要查找的对象，直接返回即可
				return current;
			} else if (value < current.value) {
				// 来到这里说明要查找的节点对象是在current节点的左子树上
				current = current.leftChild;
			} else if (value > current.value) {
				// 来到这里说明要查找的节点对象是在current节点的右子树上
				current = current.rightChild;
			}
			// 如果current节点对象为null，则说明没有找到对应的节点对象
			if (current == null) {
				return null;
			}
		}
	}

	/**
	 * 先遍历左子树，再访问根节点，最后遍历右子树；
	 *
	 * @param node
	 */
	public void inOrder(Node node) {
		if (node != null) {
			inOrder(node.getLeftChild());
			System.out.println(node);
			inOrder(node.getRightChild());
		}
	}

	/**
	 * 将指定节点下的所有子节点的内容按顺序输出
	 *
	 * @param node
	 */
	public void order2(Node node, List<Integer> list) {
		if (node == null)
			return;
		// 先遍历node的左节点
		order2(node.getLeftChild(), list);
		// 将节点内容添加集合中
		list.add(node.getValue());
		// 遍历node的右节点
		order2(node.getRightChild(), list);
	}

	@Override
	public String toString() {
		// 创建集合对象
		List<Integer> list = new ArrayList<>();
		order2(root, list);
		return list.toString();
	}

	public static void main(String[] args) {
		BinaryTree binaryTree = new BinaryTree();
		binaryTree.add(3);
		binaryTree.add(1);
		binaryTree.add(0);
		binaryTree.add(2);
		binaryTree.add(7);
		binaryTree.add(5);
		binaryTree.add(8);
		binaryTree.add(9);

		System.out.println(binaryTree.toString());

		Node root = binaryTree.getRoot();
		binaryTree.inOrder(root);
	}

}