数据结构 No.10 遍历二叉树

定义

所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问 题。 遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算之基础。

算法实现

历方案

从二叉树的 递归定义可知，一棵非空的二叉树由根结点及左、右子树这三个基本部分组成。因此，在任一给定结点上，可以按某种次序执行三个操作：

⑴访问结点本身（N）， ⑵遍历该结点的左子树（L）， ⑶遍历该结点的右子树（R）。

以上三种操作有六种执行次序： NLR、LNR、LRN、NRL、RNL、RLN。

根据访问结点操作发生位置命名：

① NLR： 前序遍历(Preorder Traversal 亦称（先序遍历））

——访问根结点的操作发生在遍历其左右子树之前。

② LNR： 中序遍历(Inorder Traversal)

——访问根结点的操作发生在遍历其左右子树之中（间）。

③ LRN： 后序遍历(Postorder Traversal)

——访问根结点的操作发生在遍历其左右子树之后。

注意：

由于被访问的结点必是某子树的根，所以N(Node）、L(Left subtree）和R(Right subtree）又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为 先根遍历、中根遍历和后根遍历。

代码实现

1．先序遍历的递归算法定义：
若二叉树非空，则依次执行如下操作：
     ⑴ 访问根结点；
     ⑵ 先序遍历左子树；
     ⑶ 先序遍历右子树。
2．中序遍历的递归算法定义：
若二叉树非空，则依次执行如下操作：
    ⑴中序遍历左子树；
    ⑵访问根结点；
    ⑶中序遍历右子树。
3．后序遍历得递归算法定义：
若二叉树非空，则依次执行如下操作：
    ⑴后序遍历左子树；
    ⑵遍历右子树；

    ⑶后序访问根结点。

具体代码实现很简单。其实最形象的就是画流程图，但是本人水平实在有限，大家可以参考维基百科。说的很详细。或者参考 http://blog.csdn.net/wj8987922/article/details/52227390。他的图确实不错

/*
 * 二叉树节点
 */
public class Node {
	//数据项
	public long data;
	//数据项
	public String sData;
	//左子节点
	public Node leftChild;
	//右子节点
	public Node rightChild;
	
	/**
	 * 构造方法
	 * @param data
	 */
	public Node(long data,String sData) {
		this.data = data;
		this.sData = sData;
	}
	
}

/*
 * 二叉树类
 */
public class Tree {
	//根节点
	public Node root;
	
	/**
	 * 插入节点
	 * @param value
	 */
	public void insert(long value,String sValue) {
		//封装节点
		Node newNode = new Node(value,sValue);
		//引用当前节点
		Node current = root;
		//引用父节点
		Node parent;
		//如果root为null，也就是第一插入的时候
		if(root == null) {
			root = newNode;
			return;
		} else {
			while(true) {
				//父节点指向当前节点
				parent = current;
				//如果当前指向的节点数据比插入的要大,则向左走
				if(current.data > value) {
					current = current.leftChild;
					if(current == null) {
						parent.leftChild = newNode;
						return;
					}
				} else {
					current = current.rightChild;
					if(current == null) {
						parent.rightChild = newNode;
						return;
					}
				}
			}
		}
	}
	
	/**
	 * 查找节点
	 * @param value
	 */
	public Node find(long value) {
		//引用当前节点，从根节点开始
		Node current = root;
		//循环，只要查找值不等于当前节点的数据项
		while(current.data != value) {
			//进行比较，比较查找值和当前节点的大小
			if(current.data > value) {
				current = current.leftChild;
			} else {
				current = current.rightChild;
			}
			//如果查找不到
			if(current == null) {
				return null;
			}
		}
		return current;
	}
	
	/**
	 * 删除节点
	 * @param value
	 */
	public void delte(long value) {
		
	}
	
	/**
	 * 前序遍历
	 */
	public void frontOrder(Node localNode) {
		if(localNode != null) {
			//访问根节点
			System.out.println(localNode.data + ", " + localNode.sData);
			//前序遍历左子树
			frontOrder(localNode.leftChild);
			//前序遍历右子树
			frontOrder(localNode.rightChild);
		}
	}
	
	/**
	 * 中序遍历
	 */
	public void inOrder(Node localNode) {
		if(localNode != null) {
			//中序遍历左子树
			inOrder(localNode.leftChild);
			//访问根节点
			System.out.println(localNode.data + ", " + localNode.sData);
			//中旬遍历右子树
			inOrder(localNode.rightChild);
		}
	}
	
	/**
	 * 后序遍历
	 */
	public void afterOrder(Node localNode) {
		if(localNode != null) {
			//后序遍历左子树
			afterOrder(localNode.leftChild);
			//后序遍历右子树
			afterOrder(localNode.rightChild);
			//访问根节点
			System.out.println(localNode.data + ", " + localNode.sData);
		}
	}
}

public class TestTree {
	public static void main(String[] args) {
		Tree tree = new Tree();
		tree.insert(10,"James");
		tree.insert(20,"YAO");
		tree.insert(15,"Kobi");
		tree.insert(3,"Mac");
		tree.insert(4, "Zhangsan");
		tree.insert(90, "Lisi");
		
//		System.out.println(tree.root.data);
//		System.out.println(tree.root.rightChild.data);
//		System.out.println(tree.root.rightChild.leftChild.data);
//		System.out.println(tree.root.leftChild.data);
//		
//		Node node = tree.find(3);
//		System.out.println(node.data + ", " + node.sData);
		
//		tree.frontOrder(tree.root);
		
//		tree.inOrder(tree.root);
		tree.afterOrder(tree.root);
	}
}