二叉树各种练习

树节点构造：

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