先序遍历
规则: 树根 -> 左侧树 -> 右侧树5
中序遍历
规则: 左侧树 -> 树根 -> 右侧树
后序遍历
规则: 左侧树 -> 右侧树 -> 树根
先序遍历
8,3,1,6,4,7,10,14,13,
中序遍历
1,3,4,6,7,8,10,13,14,
后序遍历
1,4,7,6,3,13,14,10,8,
图解
先序
中序
后序
说明
先序
- 由树根“8”开始。找到“8”
- ”8“的左侧树,找到“3”。
- “3”的左侧树,找到“1”。“1”没有左侧也没有右侧。
- “3”的右侧树,找到“6”。
- “6”的左侧树,找到“4”。“4”没有左侧也没有右侧。
- “6”的右侧树,找到“7”。”7“没有左侧也没有右侧。
- ”8“的右侧树,找到”10“
- “10”的左侧树没有,右侧,找到“14”
- “14“的左侧树,找到”13“,没有右侧
中序
- 由“8”开始,左侧“3”,“3”的左侧“1”,"1"没有左侧,然后根据(左侧,根,右侧原则),找到根“1”,然后“1”没有右侧节点。
- “1”的根节点“3”,找到“3”
- “3”右侧“6”,“6”的左侧“4”,“4没有左侧”,找到“4”,“4”没有右侧
- “4”的根节点“6”,找到“6”
- “6”的右侧“7”,“7”没有左侧,找到“7”。“7”没有右侧
- “3”的根节点“8”,找到“8”
- “8”的右侧“10”,“10”没有左侧,找到“10”
- “10”的右侧“14”,“14”有左侧“13”。“13”没有左侧,找到“13”。“13”没有右侧
- “13”的根节点“14”,找到“14”。“14”没有右侧
后序
- 由“8”开始,左侧“3”,“3”的左侧“1”,"1"没有左侧也没有右侧,找到根“1”
- “1”的右侧兄弟节点“6”,“6”有左侧节点“4”,“4”没有左侧也没有右侧,找到“4”
- “4”的右侧兄弟节点“7”,“7”没有左侧也没有右侧。找到“7”
- 然后根据(左右根)的原则。找到“4”和“7”的根“6”。找到“6”
- 然后根据(左右根)的原则。找到“1”和“6”的根“3”。找到“3”
- “3”的右侧兄弟节点“10”,“10没有左侧”,右侧“14”,“14”有左侧“13”。13没有子节点。找到“13”
- “13”没有右侧兄弟节点,找到“13”的根节点“14”。找到“14”
- “14”的根节点“10”,找到“10”
- “3”和“10”的根节点“8”,找到“8”
先序遍历
A,B,C,D,E,F,G,H,K,
中序遍历
B,D,C,A,E,H,G,K,F,
后序遍历
D,C,B,H,K,G,F,E,A,
java 实现
二叉树节点实体
package com.liuzhiqiang.domain;
public class NodeTree {
private String value;
private NodeTree leftNodeTree;
private NodeTree rightNodeTree;
public NodeTree(String value) {
this.value = value;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public NodeTree getLeftNodeTree() {
return leftNodeTree;
}
public void setLeftNodeTree(NodeTree leftNodeTree) {
this.leftNodeTree = leftNodeTree;
}
public NodeTree getRightNodeTree() {
return rightNodeTree;
}
public void setRightNodeTree(NodeTree rightNodeTree) {
this.rightNodeTree = rightNodeTree;
}
}
实现
package com.liuzhiqiang.test;
import com.liuzhiqiang.domain.NodeTree;
public class Traversal {
public static void main(String[] a) {
NodeTree nodeTree = establishNodeTree();
System.out.println("先序遍历");
preorder(nodeTree);
System.out.println();
System.out.println("中序遍历");
lnr(nodeTree);
System.out.println();
System.out.println("后序遍历");
houxu(nodeTree);
}
static void houxu(NodeTree nodeTree) {
if (nodeTree.getLeftNodeTree() != null) {
houxu(nodeTree.getLeftNodeTree());
}
if (nodeTree.getRightNodeTree() != null) {
houxu(nodeTree.getRightNodeTree());
}
System.out.print(nodeTree.getValue() + ",");
}
static void lnr(NodeTree nodeTree) {
if (nodeTree.getLeftNodeTree() != null) {
lnr(nodeTree.getLeftNodeTree());
}
System.out.print(nodeTree.getValue() + ",");
if (nodeTree.getRightNodeTree() != null) {
lnr(nodeTree.getRightNodeTree());
}
}
static void preorder(NodeTree nodeTree) {
System.out.print(nodeTree.getValue() + ",");
if (nodeTree.getLeftNodeTree() != null) {
preorder(nodeTree.getLeftNodeTree());
}
if (nodeTree.getRightNodeTree() != null) {
preorder(nodeTree.getRightNodeTree());
}
}
static NodeTree establishNodeTree() {
NodeTree nodeTree = new NodeTree("8");
NodeTree leftNode1 = new NodeTree("3");
nodeTree.setLeftNodeTree(leftNode1);
NodeTree rightNodeTree1 = new NodeTree("10");
nodeTree.setRightNodeTree(rightNodeTree1);
NodeTree leftNode2 = new NodeTree("1");
leftNode1.setLeftNodeTree(leftNode2);
NodeTree rightNodeTree2 = new NodeTree("6");
leftNode1.setRightNodeTree(rightNodeTree2);
NodeTree leftNode3 = new NodeTree("4");
rightNodeTree2.setLeftNodeTree(leftNode3);
NodeTree rightNodeTree3 = new NodeTree("7");
rightNodeTree2.setRightNodeTree(rightNodeTree3);
NodeTree rightNodeTree4 = new NodeTree("14");
rightNodeTree1.setRightNodeTree(rightNodeTree4);
NodeTree leftNode4 = new NodeTree("13");
rightNodeTree4.setLeftNodeTree(leftNode4);
return nodeTree;
}
}