After reading this article you will learn:

 What is a two binary tree
 Two special twofork trees
 Full two fork Tree
 Complete binary Tree
 A contrast chart of twoand fullbinary trees
 Realization of Binary Tree
 Using recursive node to realize the method of the left and right chain representation of a binary tree node
 Representation of a node with array subscript notation
 The main method of binary tree
 The creation of binary tree
 Adding elements to a binary tree
 Delete element of binary tree
 The emptying of the binary tree
 Get the height of a twofork tree
 Number of nodes to get a twofork tree
 Get the parent node of a node
 Traversal of a binary tree
 First Order traversal
 Middle Sequence traversal
 Postpost traversal
 Traverse Summary
 Summarize
There are many kinds of tree classification, but the basic is two fork tree derivation, today to learn the next two fork tree.
What is a two binary tree
Let's start with a definition:
A binary tree is a set of finite nodes, which can be an empty set or a set of root nodes and up to two subbinary trees , one of which is called the left subtree of the root and the other is called the right subtree of the root.
To put it simply, a binary tree is a tree of up to two subtrees per node , as shown in:
The definition of a binary tree is a recursive definition, which is notable for the concept of the left and right subtrees, since there are two trees below the same twofork tree:
Two special twofork trees
There are two special types of twofork trees:
 Full two fork Tree
 Complete binary Tree
Full two fork Tree
In the above tree and Java implementations we introduce the definition of the height of the tree, and here the definition of a twofork tree is:
If the height of a tree is K and has a 2^k1 node, it is called a full twofork tree.
What do you mean?
That is, each node must have either two subtrees trees or no subtrees.
Complete binary Tree
A complete binary tree is a special twofork tree that meets the following requirements:
 All leaf nodes appear in K or k1 layer, and the maximum number of nodes must be reached from 1 to k1 layer.
 The Klevel is not slow, but all nodes of the Klayer must be centered on the leftmost side.
To put it simply,
Is that the leaf node must be on the last or the penultimate level, and must be on the left. No node can be Zuozi without a right subtree.
A contrast chart of twoand fullbinary trees
Take a picture and compare the two:
Realization of Binary Tree
A binary tree is simpler to implement than a normal tree because it has a maximum of two nodes.
A binary tree node is represented by recursive node implementation method/leftright chain representation
public class BinaryTreeNode { /* * 一个二叉树包括 数据、左右孩子 三部分 */ private int mData; private BinaryTreeNode mLeftChild; private BinaryTreeNode mRightChild; public BinaryTreeNode(int data, BinaryTreeNode leftChild, BinaryTreeNode rightChild) { mData = data; mLeftChild = leftChild; mRightChild = rightChild; } public int getData() { return mData; } public void setData(int data) { mData = data; } public BinaryTreeNode getLeftChild() { return mLeftChild; } public void setLeftChild(BinaryTreeNode leftChild) { mLeftChild = leftChild; } public BinaryTreeNode getRightChild() { return mRightChild; } public void setRightChild(BinaryTreeNode rightChild) { mRightChild = rightChild; }}
The tree represented by this implementation is created by the node, as shown in the image on the right:
Representation of a node with array subscript notation
public class BinaryTreeArrayNode { /** * 数组实现，保存的不是 左右子树的引用，而是数组下标 */ private int mData; private int mLeftChild; private int mRightChild; public int getData() { return mData; } public void setData(int data) { mData = data; } public int getLeftChild() { return mLeftChild; } public void setLeftChild(int leftChild) { mLeftChild = leftChild; } public int getRightChild() { return mRightChild; } public void setRightChild(int rightChild) { mRightChild = rightChild; }}
It is common to construct a twofork tree using the nodes represented by the left and right chains.
The main method of binary tree
After having the node, we start to construct a binary tree, the main methods of the binary tree are:
 Create
 adding elements
 Delete Element
 Empty
 Traverse
 Get the height of the tree
 Gets the number of nodes in the tree
 Returns the parent node of a node
 ...
1. Creation of two fork trees
Creating a binary tree is as simple as having a binary root node and providing a way to set the root node:
public class BinaryTree { private BinaryTreeNode mRoot; //根节点 public BinaryTree() { } public BinaryTree(BinaryTreeNode root) { mRoot = root; } public BinaryTreeNode getRoot() { return mRoot; } public void setRoot(BinaryTreeNode root) { mRoot = root; }}
2. Adding elements of a twofork tree
Since the binary tree has a subtree of left and right, it is also divided into two cases when adding elements: Add as Zuozi, or just a subtree:
public void insertAsLeftChild(BinaryTreeNode child){ checkTreeEmpty(); mRoot.setLeftChild(child); } public void insertAsRightChild(BinaryTreeNode child){ checkTreeEmpty(); mRoot.setRightChild(child); } private void checkTreeEmpty() { if (mRoot == null){ throw new IllegalStateException("Can‘t insert to a null tree! Did you forget set value for root?"); } }
Check that the root node is empty before each insert, and if it is, throw an exception (with Android source).
3. Two delete element of the fork tree
Deleting an element is simple, just set yourself to null.
But in order to avoid wasting useless memory, convenient GC recovery, we also need to traverse the left and right subtree of this element, set to null:
public void deleteNode(BinaryTreeNode node){ checkTreeEmpty(); if (node == null){ //递归出口 return; } deleteNode(node.getLeftChild()); deleteNode(node.getRightChild()); node = null;}
4. Two The emptying of the fork tree
The emptying of the binary tree is actually a special delete element – Delete the root node, so it's simple:
public void clear(){ if (mRoot != null){ deleteNode(mRoot); }}
5. Get the height of the two fork tree
In a binary tree, the height of the tree is the maximum value of each node degree.
So getting the height of the tree requires recursion to get the height of all the nodes and then the maximum value.
/** * 获取树的高度 ，特殊的获得节点高度 * @return */ public int getTreeHeight(){ return getHeight(mRoot); } /** * 获得指定节点的度 * @param node * @return */ public int getHeight(BinaryTreeNode node){ if (node == null){ //递归出口 return 0; } int leftChildHeight = getHeight(node.getLeftChild()); int rightChildHeight = getHeight(node.getRightChild()); int max = Math.max(leftChildHeight, rightChildHeight); return max + 1; //加上自己本身 }
6. The number of nodes to get a twofork tree
To get the number of nodes for a twofork tree, you need to traverse all the subtrees and add the sum.
public int getSize(){ return getChildSize(mRoot);}/** * 获得指定节点的子节点个数 * @param node * @return */public int getChildSize(BinaryTreeNode node){ if (node == null){ return 0; } int leftChildSize = getChildSize(node.getLeftChild()); int rightChildSize = getChildSize(node.getRightChild()); return leftChildSize + rightChildSize + 1;}
7. Get the parent node of a node
Since we use the nodes represented by the left and right subtrees and do not contain a parent node reference, sometimes it may also be necessary to return a method to the parent node of the specified node in the binary tree.
You need to traverse each subtree from the top down, and if the child of the root node of the subtree is the target node, return the node, or recursively traverse its right and left subtree:
/** * 获得指定节点的父亲节点 * @param node * @return */public BinaryTreeNode getParent(BinaryTreeNode node) { if (mRoot == null  mRoot == node) { //如果是空树，或者这个节点就是根节点，返回空 return null; } else { return getParent(mRoot, node); //否则递归查找 父亲节点 }}/** * 递归对比 节点的孩子节点 与 指定节点 是否一致 * * @param subTree 子二叉树根节点 * @param node 指定节点 * @return */public BinaryTreeNode getParent(BinaryTreeNode subTree, BinaryTreeNode node) { if (subTree == null) { //如果子树为空，则没有父亲节点，递归出口 1 return null; } //正好这个根节点的左右孩子之一与目标节点一致 if (subTree.getLeftChild() == node  subTree.getRightChild() == node) { //递归出口 2 return subTree; } //需要遍历这个节点的左右子树 BinaryTreeNode parent; if ((parent = getParent(subTree.getLeftChild(), node)) != null) { //左子树节点就是指定节点，返回 return parent; } else { return getParent(subTree.getRightChild(), node); //从右子树找找看 }}
Traversal of a binary tree
The traversal of the binary tree is introduced separately, because it is too important! I used to test this in my old exams.
As you can see from the previous operations, the recursive data structure of the binary tree makes it possible to use recursion for many operations.
The traversal of a binary tree is, in fact, a recursive traversal process that makes each node accessible and accessible only once.
The traversal of the binary tree is divided into three types according to the sequence of the root node, the left and right subtree traversal in different scenarios:
 First Order traversal
 Middle Sequence traversal
 Postpost traversal
Here, the first order, the middle order, the sequence refers to the root node relative to the left and right subtree traversal order.
First Order traversal
That is, the root node is traversed before the left and right subtrees:
 Access the root node first
 Reorder Traversal Zuozi
 The first step is to traverse the right subtree
 Exit
Code:
/** * 先序遍历 * @param node */public void iterateFirstOrder(BinaryTreeNode node){ if (node == null){ return; } operate(node); iterateFirstOrder(node.getLeftChild()); iterateFirstOrder(node.getRightChild());}/** * 模拟操作 * @param node */public void operate(BinaryTreeNode node){ if (node == null){ return; } System.out.println(node.getData());}
Middle Sequence traversal
Traversal order:
 First middle order traversal Zuozi
 Reaccess the root node
 Then the middle sequence traverses the right subtree
 Exit
Code:
/** * 中序遍历 * @param node */public void iterateMediumOrder(BinaryTreeNode node){ if (node == null){ return; } iterateMediumOrder(node.getLeftChild()); operate(node); iterateMediumOrder(node.getRightChild());}
Postpost traversal
That is, the root node is traversed after the left and right subtrees:
 Sequencing Traversal Zuozi
 And then go through the right subtree.
 Last Access root node
 Exit
Code:
/** * 后序遍历 * @param node */public void iterateLastOrder(BinaryTreeNode node){ if (node == null){ return; } iterateLastOrder(node.getLeftChild()); iterateLastOrder(node.getRightChild()); operate(node);}
Traverse Summary
As you can see, the difference between the three ways of traversal is the succession of recursion.
For example, there are three kinds of traversal results:
Firstorder Traversal:
1 2 4 5 7 3 6
Middle Sequence Traversal:
4 2 7 5 1 3 6
Postpost traversal:
4 7 5 2 6 3 1
Summarize
This article introduces the basic concepts of twofork tree in data structure, common operations and three kinds of traversal methods.
There are three types of traversal methods that you might look at during an interview, and give you two kinds of traversal results that let you draw the actual twotree structure. As long as you master the difference of three kinds of traversal methods, you can answer.
Revisit data structure: common methods of twofork tree and three kinds of traversal methods Java implementation