菜鸟笔记
提升您的技术认知

二叉树的前序遍历,中序遍历,后序遍历-ag真人游戏

这三也是经典的二叉树的三种方法

二叉树的前序遍历

递归实现

public class main4 {
	static arraylist list = new arraylist();
	int qianxu(treenode t) {
	//根,判定第一个节点(根)是否存在
		if(t==null) {
			return 0;
		}	
		list.add(t);
		//左
		if(t.left!=null) {			
			houxu(t.left);	
		}	
		//右
		if(t.right!=null) {		
			houxu(t.right);
		}
		
		return 0;
		
	}
	
	public static void main(string[] args) {
		treenode tn1= new treenode(1);
		treenode tn2= new treenode(2);
		treenode tn3= new treenode(3);
		treenode tn4= new treenode(4);
		treenode tn5= new treenode(5);
		treenode tn6= new treenode(6);
		treenode tn7= new treenode(7);
		tn1.left=tn2;
		tn1.right=tn3;
		tn2.left=tn4;
		tn2.right=tn5;
		tn3.left=tn6;
		tn3.right=tn7;
		new main4().qianxu(tn1);
		for(int i =0;i

这个没什么难理解的,顺序就是根,左,右节点,如果有左右节点就遍历,没有就不往左节点或右节点遍历了

非递归实现

前序遍历的非递归实现就不写了,很简单,和深度优先一样,我不知道别人有用什么奇怪方法的,但是我用栈来实现深度优先,可以参考二叉树广度优先搜索和深度优先搜索

二叉树的中序遍历

1、使用递归的方式实现

class treenode {
    int val;
    treenode left;
    treenode right;
    treenode(int x) { val = x; }
 }
public class main3 {
	static arraylist list = new arraylist();
	int zhongxubianli(treenode tn) {
		if(t==null) {  //判定第一个节点(根)是否存在
			return 0;
		}	
		//左
		if(tn.left!=null) {
			zhongxubianli(tn.left);
		}	
		//根
		list.add(tn);
		//右
		if(tn.right!=null) {
			zhongxubianli(tn.right);		
		}	
		return 0;
	}	
	public static void main(string[] args) {
		treenode tn1= new treenode(1);
		treenode tn2= new treenode(2);
		treenode tn3= new treenode(3);
		treenode tn4= new treenode(4);
		treenode tn5= new treenode(5);
		treenode tn6= new treenode(6);
		treenode tn7= new treenode(7);
		tn1.left=tn2;
		tn1.right=tn3;
		tn2.left=tn4;
		tn2.right=tn5;
		tn3.left=tn6;
		tn3.right=tn7;
		new main3().zhongxubianli(tn1);
		for(int i =0;i

结果:

使用的例子示例图

分析这个可能有点眼花缭乱,那就先看小的部分

这个怎么能成中序遍历呢?
肯定是213吧,那是不是先把2节点放进去,再把1节点放进去,再把三节点放进去呢!肯定的
那给的节点肯定是1节点了,那访问的顺序肯定就是先从1到2,再经过1到3。
而这个顺序正好有一个中序遍历的顺序,那就是213,所以就从2节点开始放,那怎么知道到2了呢?
那就找左子树是null的节点就行,添加完2肯定就是返回,返回到根节点添加1,再通过右子树为null找到3,添加进去,就完成了。
再经过递归就可以成大的了、

2、使用非递归的方式实现(使用栈)

treenode是二叉树的节点,上个程序有,这就不添加上了

	//非递归
	int zhongxubianli1(treenode tn) {
		//根不存在
		if(tn==null) {
			return 0;
		}	
		stack stack = new stack();	
		stack.add(tn);
		//isempty只有当size==0时才返回true
		while(stack.isempty()==false) {		 //第一步
			if(tn!=null) {						//第二步
				stack.add(tn);
				tn = tn.left;			
			}else {									//第三步
				tn = stack.pop();
				list.add(tn);			
				if(stack.isempty()==false) {			//第四步
					tn = stack.pop();
					list.add(tn);				
				}
				tn = tn.right;			
			}			
		}		
		return 0;
		}	
	public static void main(string[] args) {
		treenode tn1= new treenode(1);
		treenode tn2= new treenode(2);
		treenode tn3= new treenode(3);
		treenode tn4= new treenode(4);
		treenode tn5= new treenode(5);
		treenode tn6= new treenode(6);
		treenode tn7= new treenode(7);
		tn1.left=tn2;
		tn1.right=tn3;
		tn2.left=tn4;
		tn2.right=tn5;
		tn3.left=tn6;
		tn3.right=tn7;
		new main3().zhongxubianli1(tn1);
		for(int i =0;i

这个的例子也是用的

因为不是用递归实现,所以就需要用while或者for来代替递归了,说实话递归的确好理解

一步一步的来分析分析怎么用栈来解决的,用栈怎么实现的。
首先看一张图

不知道你能不能看懂,一开始我也看不懂,经过自己写这个过程就会了,
这些不同颜色的实线箭头 就是进栈的顺序(这些箭头是不可以打断的,比如1,2,4必须进栈是1、2、4,不能在4之前插入一个)
当然出栈的没写,根据入栈的顺序,和中序遍历的顺序结合,其实就能写出 出栈的顺序。

按这个思路,首先你需要while循环一下把1、2、4都添加进去吧,之后出4,2,再把5进栈
之后5,1出栈,3、6进栈,再3、6出栈,7入栈,再7出栈,就构成了中序遍历

上面的思路好理解,但是实现有点困难,看程序,
1、首先解决的是while的判定条件,因为这个过程中栈空代表着么有没有节点了,所以结束了,
2、之后是怎么一口气把像1、2、4这样的节点入栈
3、什么情况下开始出栈,出栈几个(要考虑到有可能连着的父节点,祖父节点等没有右节点),
4、考虑到出栈到根节点的情况
上面的4个正好对应程序中关键的四步

二叉树的后序遍历

递归实现

class treenode {
    int val;
    treenode left;
    treenode right;
    treenode(int x) { val = x; }
 }
public class main4 {
	static arraylist list = new arraylist();
	int houxu(treenode t) {
		if(t==null) {  //判定第一个节点(根)是否存在
			return 0;
		}	
		//左
		if(t.left!=null) {			
			houxu(t.left);	
		}		
		//右
		if(t.right!=null) {		
			houxu(t.right);
		}
		list.add(t);	
		return 0;
		
	}
	
	public static void main(string[] args) {
		treenode tn1= new treenode(1);
		treenode tn2= new treenode(2);
		treenode tn3= new treenode(3);
		treenode tn4= new treenode(4);
		treenode tn5= new treenode(5);
		treenode tn6= new treenode(6);
		treenode tn7= new treenode(7);
		tn1.left=tn2;
		tn1.right=tn3;
		tn2.left=tn4;
		tn2.right=tn5;
		tn3.left=tn6;
		tn3.right=tn7;
		new main4().houxu(tn1);
		for(int i =0;i

非递归实现

用两个栈来实现,当压入第一个栈是1,取出来把它左右都压进栈,再把1压入另一个栈,这样循环下去,第二个栈的出栈顺序就是后续遍历

int houxu1(treenode t) {
		if(t==null) {
			return 0;
		}
		stack stack1=new stack();
		stack stack2=new stack();
		stack1.add(t);
		while(!stack1.isempty()) {
			t =stack1.pop();
			if(t.left!=null) {
				stack1.add(t.left);
			}
			if(t.right!=null) {
				stack1.add(t.right);
			}
			stack2.add(t);
		}
		while(!stack2.isempty()) {
			list.add(stack2.pop());
		}
		return 0;
	}
	
	public static void main(string[] args) {
		treenode tn1= new treenode(1);
		treenode tn2= new treenode(2);
		treenode tn3= new treenode(3);
		treenode tn4= new treenode(4);
		treenode tn5= new treenode(5);
		treenode tn6= new treenode(6);
		treenode tn7= new treenode(7);
		tn1.left=tn2;
		tn1.right=tn3;
		tn2.left=tn4;
		tn2.right=tn5;
		tn3.left=tn6;
		tn3.right=tn7;
		new main4().houxu1(tn1);
		for(int i =0;i

分析分析这三种遍历中递归的区别(非递归联系不是很大)

自己整理完这三种遍历的算法,感觉也就那样,尤其是递归的,更没什么

		if(t==null) {		//这个必须排第一个
			return 0;
		}								
		list.add(t);		//第一部分
		//左
		if(t.left!=null) {			//第二部分
			houxu(t.left);	
		}	
		//右
		if(t.right!=null) {		 //第三部分
			houxu(t.right);
		}
		return 0;

前序遍历、中序遍历、后序遍历也就是上面三部分根据前面序列的规则排序而已。
举个例子:
前序要求根节点,左节点,右节点。那上面排序的规则就是第一部分(根)、第二部分(左)、第三部分(右)

很简单。看别人千万遍不如自己写一遍,总结一遍啊。

网站地图