二叉树各种练习

树节点构造：

public class BinaryTree {public Node root;public Node temp;public class Node{int data;Node lchild;Node rchild;public  Node(int data) {this.data=data;this.lchild=null;this.rchild=null;}}

1.数组转化为二叉树

题目没有任何背景，只是方便生成二叉树，用来做试验。备注：所有方法都是在一个类中的，所以里面的root是全局变量。

public void convert(int[] nums) {Node[] Q=new Node[nums.length+1];int front=1,rear=0;root=null;Node s;int i=0;while(i<nums.length) {s=new Node(nums[i]);Q[++rear]=s;if(rear==1)root=s;else { if(rear%2==0)Q[front].lchild=s;else Q[front].rchild=s;if(rear%2==1)front++;}i++;}} 

2.二叉树深度优先遍历的先序、中序、后序遍历

二叉树的先序遍历

每到一个节点，先访问根节点，再访问左孩子，再访问右孩子，即DLR。该逻辑类似递归，每切换到一个节点，都要按DLR的顺序去访问。比如

先访问1，然后切换到2，访问2，切换到4，访问4，因4没有左孩子，也没有右孩子，切换到5，访问5，因为5没有左右孩子，切换到3，访问3，因为3没有

左右孩子，结束遍历。

所以最终的访问顺序为：1 2 4 5 3。先序遍历的代码主要分为递归和非递归。

非递归版：

public List<Integer> OrderDLR() {List<Integer> result=new LinkedList<Integer>();int top=0;Node s=root;Node[] stack=new Node[20];do {while(s!=null) {result.add(s.data);stack[top]=s;top++;s=s.lchild;}if(top>0) {top--;s=stack[top];s=s.rchild;}}while(top>0||s!=null);return result;}

备注：因为没有使用内置的栈，所以上面的代码中，使用了Stack模拟栈的使用。（有点low了）~~~~

递归版：

public void OrderDLR(Node s) { if(s!=null) {System.out.println(s.data);OrderDLR(s.lchild);OrderDLR(s.rchild);}}

二叉树的中序遍历

二叉树的后序遍历顺序是LDR，即当前根节点的左孩子，然后根节点，然后当前节点的右孩子。

举例来说：

先切换到1，再切换到2，再切换到4，因为4没有左孩子，所以访问4，因为4没有右孩子，所以访问2，切换到5，因为5没有左孩子，访问5，

因为5没有右孩子，访问1，切换到3，因为3没有左孩子，访问3，因为3没有右孩子，访问结束。所以最终的中序遍历顺序是：4 2 5 1 3

中序遍历的代码也分为递归和非递归。

非递归：

public List<Integer> OrderLDR() {List<Integer> result=new LinkedList<Integer>();int top=0;Node s=root;Node[] stack = new Node[20];do {while(s!=null) {stack[top]=s;top++;s=s.lchild;}if(top>0) {top--;s=stack[top];result.add(s.data);s=s.rchild;}}while(top>0||s!=null);return result;}

备注：之所以不需要传入待遍历二叉树的根节点，是因为，里面代码中的root是全局变量，所以直接实例化二叉树类的时候可以直接使用，类似于 栈的 stack.size() 用法；

当然可以对代码进行改动。

递归：

public void OrderLDR(Node s) {if(s!=null) {OrderLDR(s.lchild);System.out.println(s.data);OrderLDR(s.rchild);}}

备注：与先序相比，这两段代码的不同只是访问语句的顺序不同而已，后面的后序遍历的递归代码也是如此。

二叉树的后序遍历

二叉树的后序遍历，访问顺序为：LRD。直接举例说明：

切换到1，切换到1的左孩子2，切换到2的左孩子4，因为4没有左孩子，也没有右孩子，访问4，切换到2的右孩子5，因为5没有左孩子，没有右孩子，访问5，访问2，切换

到1的右孩子3，因为3没有左孩子也没有右孩子，访问3，访问1，访问到根节点，结束。最后的后序遍历顺序为：4 5 2 3 1.

非递归版：

public void OrderLRD() {int top=0;Node p=root;Node last=root;Node[] stack=new Node[10];stack[top]=p;while(top>=0) {p=stack[top];if((p.lchild==null&&p.rchild==null)||(p.rchild==null&&last==p.lchild)||last==p.rchild) {System.out.println(p.data);last=p;top--;}else {if(p.rchild!=null) {top++;stack[top]=p.rchild;}if(p.lchild!=null) {top++;stack[top]=p.lchild;}}}}

备注：后序遍历的非递归相对比较难，需要引入一个指针来记忆上一次访问的节点。可以访问的节点情况是：1、当前节点的左孩子，右孩子均不存在。

2、当前节点的左孩子不存在，上一次访问的是当前节点的

右孩子。

3、上一次访问的是当前节点的右孩子。

递归：

public void OrderLRD(Node s) {if(s!=null) {OrderLRD(s.lchild);OrderLRD(s.rchild);System.out.println(s.data);}}

备注：实际上，二叉树深度优先遍历的递归迭代代码，对于先序、中序、后序来说，其切换顺序都是一样的，只是具体访问顺序不一样而已。

3二叉树的广度优先遍历

广度优先遍历是指逐层遍历，即从根节点开始，一层一层的遍历。用到了队列的方法。

public void LevelOrder() {Node s;List<Node> Q=new LinkedList<Node>();int rear=1,front=0;Q.add(null);Q.add(root);if(root!=null) {while(front<rear) {front=front+1;s=Q.get(front);System.out.println(s.data);if(s.lchild!=null) {rear=rear+1;Q.add(s.lchild);}if(s.rchild!=null) {rear=rear+1;Q.add(s.rchild);}}}}

4.依据前序和中序遍历结果，重构二叉树。

前序遍历结果中，第一个点是根节点，在中序遍历结果中，如果假设遍历结果没有相同元素的话，前序第一个结果在中序结果中的位置，

将中序的结果分成了两份，左边是左子树，右边是右子树；而对应于前序结果中，具有和中序左子树相同结果的一部分是对应的左子树，另一部分则为右子树。举例。

前序：1 2 4 5 3

中序：4 2 5 1 3

左子树：前序，24 5

      中序，4 2 5

右子树：前序，3

中序，3

递归的方法：

public Node construct(int[] pre,int []mid) {Node root1=new Node(pre[0]);int plen=pre.length;if(plen==1) {root1.lchild=null;root1.rchild=null;return root1;}int midnum=root1.data;int i=0;while(midnum!=mid[i])i++;if(i>0) {int[] prec=new int[i];int[] midc=new int[i];for(int j=0;j<i;j++) {prec[j]=pre[j+1];midc[j]=mid[j];}root1.lchild=construct(prec,midc);}else root1.lchild=null;if(plen-i-1>0) {int[] prec=new int[plen-i-1];int[] midc=new int[plen-i-1];for(int j=i+1;j<plen;j++) {prec[j-i-1]=pre[j];midc[j-i-1]=mid[j];}root1.rchild=construct(prec,midc);}else root1.rchild=null;return root1;}