Preorder traversal
Idea: first root node - > left subtree - > right subtree;
The binary tree is as follows:
/** * TreeSearch Brief description * <p> TODO:Describe such responsibilities</p> * * @author ckmike * @version 1.0 * @date 18-12-6 10:13 p.m. * @copyright ckmike **/ public class TreeSearch { // Node data structure class TreeNode{ private String value = null; private TreeNode leftchildren = null; private TreeNode rightchildre = null; public TreeNode(String value, TreeNode leftchildren, TreeNode rightchildre) { this.value = value; this.leftchildren = leftchildren; this.rightchildre = rightchildre; } public TreeNode(String value) { this.value = value; } public void setValue(String value) { this.value = value; } public void setLeftchildren(TreeNode leftchildren) { this.leftchildren = leftchildren; } public void setRightchildre(TreeNode rightchildre) { this.rightchildre = rightchildre; } public String getValue() { return value; } public TreeNode getLeftchildren() { return leftchildren; } public TreeNode getRightchildre() { return rightchildre; } } public TreeNode getTargetTree() { // Leaf node TreeNode G = new TreeNode("G"); TreeNode D = new TreeNode("D"); TreeNode E = new TreeNode("E",G,null); TreeNode B = new TreeNode("B",D,E); TreeNode H = new TreeNode("H"); TreeNode I = new TreeNode("I"); TreeNode F = new TreeNode("F",H,I); TreeNode C = new TreeNode("C",null,F); // Construct root node TreeNode root = new TreeNode("A",B,C); return root; } // First order traversal binary tree public void preorderVistTreeNode(TreeNode node){ if(null != node){ System.out.print(node.value); if(null != node.leftchildren){ preorderVistTreeNode(node.leftchildren); } if(null != node.rightchildre){ preorderVistTreeNode(node.rightchildre); } } } public static void main(String[] args) { TreeSearch treeSearch = new TreeSearch(); TreeNode tree= treeSearch.getTargetTree(); treeSearch.preorderVistTreeNode(tree); } }
Traversal result: ABDEGCFHI
Sequential traversal
Idea: first, left subtree - > root node - > right subtree;
// Sequential traversal public void inorderVistTreeNode(TreeNode node){ if(null != node){ if(null != node.leftchildren){ inorderVistTreeNode(node.leftchildren); } System.out.print(node.value); if(null != node.rightchildre){ inorderVistTreeNode(node.rightchildre); } } } public static void main(String[] args) { TreeSearch treeSearch = new TreeSearch(); TreeNode tree= treeSearch.getTargetTree(); System.out.print("Sequential traversal:"); treeSearch.inorderVistTreeNode(tree); }
Middle order traversal result: DBGEACHFI
Post order traversal
Idea: first, left subtree - > right subtree - > root node;
// Post order traversal public void postorderVistTreeNode(TreeNode node){ if(null != node){ if(null != node.leftchildren){ postorderVistTreeNode(node.leftchildren); } if(null != node.rightchildre){ postorderVistTreeNode(node.rightchildre); } System.out.print(node.value); } } public static void main(String[] args) { TreeSearch treeSearch = new TreeSearch(); TreeNode tree= treeSearch.getTargetTree(); System.out.print("Post order traversal:"); treeSearch.postorderVistTreeNode(tree); }
Postorder traversal result: DGEBHIFCA
level traversal
Idea: first root node, then the second layer, the third layer, and then go down in turn, (the same layer nodes output from left to right);
// level traversal public void levelorderVistTreeNode(TreeNode node){ if(null != node){ LinkedList<TreeNode> list = new LinkedList<TreeNode>(); list.add(node); TreeNode currentNode; while (!list.isEmpty()){ currentNode = list.poll(); System.out.print(currentNode.value); if(null != currentNode.leftchildren){ list.add(currentNode.leftchildren); } if(null != currentNode.rightchildre){ list.add(currentNode.rightchildre); } } } } public static void main(String[] args) { TreeSearch treeSearch = new TreeSearch(); TreeNode tree= treeSearch.getTargetTree(); System.out.print("level traversal:"); treeSearch.levelorderVistTreeNode(tree); }
Sequence traversal: ABCDEFGHI
It should be noted that sequence traversal binary tree is realized by non recursive queue, which is realized by using FIFO of queue. So I've written the algorithms of first order traversal, middle order traversal, second order traversal and sequence traversal binary tree here, isn't it very simple. If you are interested, you can think about whether there is an algorithm that does not use recursion to implement first, middle, and last traversal. Write it in a language you are familiar with and remember to share it.