数据结构---二叉树（1）

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 postOrderTraverse1(Node node) {
Stack<Node> s = new Stack<Node>();
Node cur; // 当前结点
Node pre = null; // 前一次访问的结点
s.push(node);
while (!s.empty()) {
cur = s.peek();
if ((cur.leftChild == null && cur.rightChild == null)
|| (pre != null && (pre == cur.leftChild || pre == cur.rightChild))) {
System.out.print(cur.value+" "); // 如果当前结点没有孩子结点或者孩子节点都已被访问过
s.pop();
pre = cur;
} else {
if (cur.rightChild != null)
s.push(cur.rightChild);
if (cur.leftChild != null)
s.push(cur.leftChild);
}
}
}

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;
}

后续：数据结构---二叉树（2）

参考来源:

二叉树的非递归遍历

轻松搞定面试中的二叉树题目

根据前序遍历和中序遍历重建二叉树的Java实现