本文介绍了如何使用Java实现二叉树的构建及多种遍历方式，包括递归和非递归方法，并详细解释了每种遍历的具体实现过程。此外，还探讨了如何根据前序和中序遍历结果重建二叉树。
1. java实现二叉树
//使用二叉链表实现二叉树
public class BinaryTree {
// 结点类
static class Node {
int value; // 该节点存储的值。
Node leftChild; // 指向左子节点的引用。
Node rightChild; // 指向右子节点的引用。
Node(int value) {
this.value = value;
leftChild = null;
rightChild = null;
}
}
private Node root; // 根节点
// 无参构造方法
BinaryTree() {
root = null;
}
// 用数组构建二叉树
public void createBinTree(int[] arr) {
for (int i = 0; i < arr.length; i++) {
root = insert(root, arr[i]);
}
}
// 向二叉树中插入节点（构建二叉排序树）
public Node insert(Node node, int value) {
if (node == null) {
node = new Node(value);
} else {
if (value <= node.value) {
node.leftChild = insert(node.leftChild, value);
} else {
node.rightChild = insert(node.rightChild, value);
}
}
return node;
}
// 先序遍历
public static void preOrderTraverse(Node node) {
if (node == null)
return;
System.out.print(node.value + " ");
preOrderTraverse(node.leftChild);
preOrderTraverse(node.rightChild);
}
// 中序遍历
public static void inOrderTraverse(Node node) {
if (node == null)
return;
inOrderTraverse(node.leftChild);
System.out.print(node.value + " ");
inOrderTraverse(node.rightChild);
}
// 后序遍历
public static void postOrderTraverse(Node node) {
if (node == null)
return;
postOrderTraverse(node.leftChild);
postOrderTraverse(node.rightChild);
System.out.print(node.value + " ");
}
}
2. 二叉树的遍历
二叉树的遍历有三种方式，如下：
（1）前序遍历（DLR），首先访问根结点，然后遍历左子树，最后遍历右子树。简记根-左-右。
（2）中序遍历（LDR），首先遍历左子树，然后访问根结点，最后遍历右子树。简记左-根-右。
（3）后序遍历（LRD），首先遍历左子树，然后遍历右子树，最后访问根结点。简记左-右-根。
前序：根A，A的左子树B，B的左子树没有，看右子树，为D，所以A-B-D。再来看A的右子树，根C，左子树E，E的左子树F，E的右子树G，G的左子树为H，没有了结束。连起来为C-E-F-G-H,最后结果为ABDCEFGH
中序：先访问根的左子树,B没有左子树，其有右子树D，D无左子树，下面访问树的根A，连起来是BDA。再访问根的右子树，C的左子树的左子树是F，F的根E，E的右子树有左子树是H，再从H出发找到G，到此C的左子树结束，找到根C，无右子树，结束。连起来是FEHGC, 中序结果连起来是BDAFEHGC
后序：B无左子树，有右子树D，再到根B。再看右子树，最下面的左子树是F，其根的右子树的左子树是H，再到H的根G，再到G的根E，E的根C无右子树了，直接到C，这时再和B找它们其有的根A，所以连起来是DBFHGECA
3.二叉树遍历非递归算法
3.1先序遍历
思想：根据前序遍历访问的顺序，优先访问根结点，然后再分别访问左孩子和右孩子。即对于任一结点，其可看做是根结点，因此可以直接访问，访问完之后，若其左孩子不为空，按相同规则访问它的左子树；当访问其左子树时，再访问它的右子树。因此其处理过程如下：
对于任一结点P：
1)访问结点P，并将结点P入栈;
2)判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);若不为空，则将P的左孩子置为当前的结点P;
3)直到P为NULL并且栈为空，则遍历结束。
java算法实现：
// 非递归先序遍历
public static void preOrderTraverse1(Node node) {
Stack<Node> s = new Stack<Node>();
Node p = node;
while (p != null || !s.empty()) {
while (p != null) {
System.out.print(p.value + " ");
s.push(p);
p = p.leftChild;
}
if (!s.empty()) {
p = s.peek();
s.pop();
p = p.rightChild;
}
}
}
3.2 中序遍历
思想：根据中序遍历的顺序，对于任一结点，优先访问其左孩子，而左孩子结点又可以看做一根结点，然后继续访问其左孩子结点，直到遇到左孩子结点为空的结点才进行访问，然后按相同的规则访问其右子树。因此其处理过程如下：
对于任一结点P，
1)若其左孩子不为空，则将P入栈并将P的左孩子置为当前的P，然后对当前结点P再进行相同的处理；
2)若其左孩子为空，则取栈顶元素并进行出栈操作，访问该栈顶结点，然后将当前的P置为栈顶结点的右孩子；
3)直到P为NULL并且栈为空则遍历结束
java算法实现：
// 非递归中序遍历
public static void inOrderTraverse1(Node node) {
Stack<Node> s = new Stack<Node>();
Node p = node;
while (p != null || !s.empty()) {
while (p != null) {
s.push(p);
p = p.leftChild;
}
if (!s.empty()) {
p = s.peek();
System.out.print(p.value + " ");
s.pop();
p = p.rightChild;
}
}
}
3.3 后序遍历
思想：要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。
java代码：
// 非递归后序遍历
public static void postOrderTraversal(Node root) {
Stack<Node> s = new Stack<>();
Node visited = null;
Node curNode = root;
Node p = root;
while (p != null || !s.isEmpty()) {
// 左孩子都入栈
while (p != null) {
s.push(p);
p = p.left;
}
// curNode节点的左孩子为空（或被访问过）
curNode = s.peek();
// curNode的右孩子也为空或被访问过就要打印
if (curNode.right == null || curNode.right == visited) {
p = s.pop();
System.out.print(p.val + "\t");
visited = p;
p = null;
} else {
p = curNode.right;
}
}
}
3.4 层次遍历（从上往下打印二叉树--剑指offer-23）
思想：
(1)根结点非空，则入队列
(2)队列非空，队首元素出队列，输出结点值，若结点有左孩子，左孩子入队列；若结点有右孩子，右孩子也入队列。
(3)重复步骤(2)直到队列为空
// 层次遍历二叉树
public static void levelOrderTraverse(Node node) {
LinkQueue<Node> queue = new LinkQueue<Node>();
Node p = null;
if (node != null)// 若根结点非空，则入队列
queue.enqueue(node);
while (!queue.isEmpty())// 队列非空
{
p = queue.dequeue();
System.out.print(p.value + " ");
if (p.leftChild != null)
queue.enqueue(p.leftChild);
if (p.rightChild != null)
queue.enqueue(p.rightChild);
}
}
4. 重建二叉树（剑指offer-6）
题目:输入某二叉树的前序遍历和中序遍历，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含有重复的数字。
例如，前序遍历序列：｛1，2，4，7，3，5，6，8｝，中序遍历序列：｛4，7，2，1，5，3，8，6｝
递归解法：
（1）如果前序遍历为空或中序遍历为空或节点个数小于等于0，返回NULL。
（2）创建根节点。前序遍历的第一个数据就是根节点的数据，在中序遍历中找到根节点的位置，可分别得知左子树和右子树的前序和中序遍历序列，重建左右子树。
// 输入某二叉树的前序遍历和中序遍历，请重建出该二叉树
// pPreOrder--先序序列
// start--先序序列头
// pInOrder--中序序列
// end--中序序列尾
// length--序列长度
public static Node RebuildBinaryTree(int[] preOrder, int start,
int[] inOrder, int end, int length) {
// 参数验证
if (preOrder == null || preOrder.length == 0 || inOrder == null
|| inOrder.length == 0 || length <= 0) {
return null;
}
// 建立子树根节点
Node proot = new Node(preOrder[start]);
// 递归终止条件：子树只有一个节点
if (length == 1)
return proot;
// 分拆子树的左子树和右子树
int i = 0;
while (i < length) {
if (preOrder[start] == inOrder[end - i]) {
break;
}
i++;
}
// 建立子树的左子树
proot.leftChild = RebuildBinaryTree(preOrder, start + 1, inOrder, end - i - 1, length
- 1 - i);
// 建立子树的右子树
proot.rightChild = RebuildBinaryTree(preOrder, start + length - i, inOrder, end, i);
return proot;
}
参考来源:
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
