遍历概念
所谓遍历(Traversal)是指沿着某条搜索路线,依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题。
遍历是二叉树上最重要的运算之一,是二叉树上进行其它运算之基础。
遍历方案
1.遍历方案
从二叉树的递归定义可知,一棵非空的二叉树由根结点及左、右子树这三个基本部分组成。因此,在任一给定结点上,可以按某种次序执行三个操作:
(1)访问结点本身(N),
(2)遍历该结点的左子树(L),
(3)遍历该结点的右子树(R)。
以上三种操作有六种执行次序:
NLR、LNR、LRN、NRL、RNL、RLN。
注意:
前三种次序与后三种次序对称,故只讨论先左后右的前三种次序。
2.三种遍历的命名
根据访问结点操作发生位置命名:
① NLR:前序遍历(PreorderTraversal亦称(先序遍历))
——访问结点的操作发生在遍历其左右子树之前。
② LNR:中序遍历(InorderTraversal)
——访问结点的操作发生在遍历其左右子树之中(间)。
③ LRN:后序遍历(PostorderTraversal)
——访问结点的操作发生在遍历其左右子树之后。
注意:
由于被访问的结点必是某子树的根,所以N(Node)、L(Left subtlee)和R(Right subtree)又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。
遍历算法
1.中序遍历的递归算法定义:
若二叉树非空,则依次执行如下操作:
(1)遍历左子树;
(2)访问根结点;
(3)遍历右子树。
2.先序遍历的递归算法定义:
若二叉树非空,则依次执行如下操作:
(1) 访问根结点;
(2) 遍历左子树;
(3) 遍历右子树。
3.后序遍历得递归算法定义:
若二叉树非空,则依次执行如下操作:
(1)遍历左子树;
(2)遍历右子树;
(3)访问根结点。
4.中序遍历的算法实现
用二叉链表做为存储结构,中序遍历算法可描述为:
void InOrder(BinTree T)
{ //算法里①~⑥是为了说明执行过程加入的标号
① if(T) { // 如果二叉树非空
② InOrder(T->lchild);
③ printf("%c",T->data); // 访问结点
④ InOrder(T->rchild);
⑤ }
⑥ } // InOrder
遍历序列
1.遍历二叉树的执行踪迹
三种递归遍历算法的搜索路线相同(如下图虚线所示)。
具体线路为:
从根结点出发,逆时针沿着二叉树外缘移动,对每个结点均途径三次,最后回到根结点。
2.遍历序列
(1) 中序序列
中序遍历二叉树时,对结点的访问次序为中序序列
【例】中序遍历上图所示的二叉树时,得到的中序序列为:
D B A E C F
(2) 先序序列
先序遍历二叉树时,对结点的访问次序为先序序列
【例】先序遍历上图所示的二叉树时,得到的先序序列为:
A B D C E F
(3) 后序序列
后序遍历二叉树时,对结点的访问次序为后序序列
【例】后序遍历上图所示的二叉树时,得到的后序序列为:
D B E F C A
注意:
(1) 在搜索路线中,若访问结点均是第一次经过结点时进行的,则是前序遍历;若访问结点均是在第二次(或第三次)经过结点时进行的,则是中序遍历(或后序遍历)。只要将搜索路线上所有在第一次、第二次和第三次经过的结点分别列表,即可分别得到该二叉树的前序序列、中序序列和后序序列。
(2) 上述三种序列都是线性序列,有且仅有一个开始结点和一个终端结点,其余结点都有且仅有一个前趋结点和一个后继结点。为了区别于树形结构中前趋(即双亲)结点和后继(即孩子)结点的概念,对上述三种线性序列,要在某结点的前趋和后继之前冠以其遍历次序名称。
【例】上图所示的二叉树中结点C,其前序前趋结点是D,前序后继结点是E;中序前趋结点是E,中序后继结点是F;后序前趋结点是F,后序后继结点是A。但是就该树的逻辑结构而言,C的前趋结点是A,后继结点是E和F。
二叉链表的构造
1. 基本思想
基于先序遍历的构造,即以二叉树的先序序列为输入构造。
注意:
先序序列中必须加入虚结点以示空指针的位置。
【例】
建立上图所示二叉树,其输入的先序序列是:ABD∮∮CE∮∮F∮∮。
2. 构造算法
假设虚结点输入时以空格字符表示,相应的构造算法为:
void CreateBinTree (BinTree *T)
{ //构造二叉链表。T是指向根指针的指针,故修改*T就修改了实参(根指针)本身
char ch;
if((ch=getchar())=='') *T=NULL; //读人空格,将相应指针置空
else{ //读人非空格
*T=(BinTNode *)malloc(sizeof(BinTNode)); //生成结点
(*T)->data=ch;
CreateBinTree(&(*T)->lchild); //构造左子树
CreateBinTree(&(*T)->rchild); //构造右子树
}
}
注意:
调用该算法时,应将待建立的二叉链表的根指针的地址作为实参。
===============================================
java遍历目录及子目录下的文件
本文Tag:java java遍历目录及子目录下的文件 <script src="http://tag.csdn.net/articlecounter.aspx" type="text/javascript"></script>
作者:suncheng_hong 来源:csdn.net 发表于7个月以前
java遍历目录及子目录下的文件 <script src="http://blog.csdn.net/count.aspx?ID=1671632&Type=Rank" type="text/javascript"></script>
import java.io.File;
public class FileManager ... {
String dir = "";
String temp = "";
public String[] serachFiles(String dir) ...{
File root = new File(dir);
File[] filesOrDirs = root.listFiles();
String[] result = new String[10];
for (int i = 0; i < filesOrDirs.length; i++) ...{
if (filesOrDirs[i].isDirectory()) ...{
serachFiles(filesOrDirs[i].getAbsolutePath());
} else ...{
result[i] = filesOrDirs[i].getName();
temp += filesOrDirs[i].getName() + ",";
}
}
return temp.split(",");
}
/** *//**
* @param args
*/
public static void main(String[] args) ...{
FileManager fm = new FileManager();
String[] files = fm.serachFiles("D:/abc");
for (int i = 0; i < files.length; i++) ...{
System.out.println("files[" + i + "]" + files[i]);
}
}
}
Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1671632
=======================================================================
浅析Java遍历器(Iterator)的实现 选择自 lasersong2004 的 Blog
遍历器用于遍历Collection, Map没有提供public的遍历器,但是其内部定义了几个private遍历器自用。 简单地说,每个AbstratCollection的子类都有一个iterator()方法,这个方法将返回一个对应容器的遍历器。而AbstractList的子类自有一个listIterator()方法(ArrayList等具体类也提供iterator()方法,从源码中可以知道listIterator()实际上来自iterator()!在下面有详细解释)。
(*)通过研究源码可知,Set的Iterator实际上是从Map的内部Iterator获得的(HashSet从HashMap.KeySet私有内嵌类获得,TreeSet从TreeMap.KeySet私有内嵌类获得),之所以这样实现估计是因为Set和Map有同样的性质:不允许重复值。这里暂时不讨论。
listIterator()在AbstractList类中实现。AbstractList类中有四个内嵌类:Itr, ListItr, RandomAccessSubList和SubList。与Iterator有关的是Itr和ListItr这两个。 Itr和ListItr是两个private内嵌类,Itr的实现如下:
private class Itr implements Iterator { //定义一个游标,标示List中元素Index int cursor = 0;
//lastRet是最近被访问的元素的index,如果该元素被remove()了,设为-1 int lastRet = -1;
/** modCount是该List的被修改次数(指结构上的变化,例如size改变),通常在我们一边遍历一边remove()时会发生。注意modCount是transient的,不能被序列化。 expectedModCount如果不等于modCount,就说明在遍历过程中List结构改变了 */ int expectedModCount = modCount;
//hasNext()的实现 public boolean hasNext() { return cursor != size(); }
//next()的实现 public Object next() { try { Object next = get(cursor); checkForComodification(); lastRet = cursor++; return next; } catch(IndexOutOfBoundsException e) { checkForComodification(); throw new NoSuchElementException(); } }
//remove()的实现 public void remove() { if (lastRet == -1) throw new IllegalStateException(); checkForComodification();
try { /** AbstractList.remove()将会抛出UnsupportedOperationException,如果 如果某个子类允许remove(int)操作的话,必须override此方法。 */ AbstractList.this.remove(lastRet); if (lastRet < cursor) cursor--; lastRet = -1; expectedModCount = modCount; } catch(IndexOutOfBoundsException e) { throw new ConcurrentModificationException(); } }
//检查List是否被修改 final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); } } AbstractList.iterator()其实只有一行:return new Itr(); 返回一个Itr实例。 可以看到,Itr类中调用了大量AbstractList中的方法,例如get(int)、remove(int)等,但是这些方法要么是抽象的,要么只有一句:throw new UnsupportedOperationException(); 这样AbstractList的子类如果实现了这些方法,那么它们继承的iterator()也就有用了。如果不允许实现get(int),remove(int),那么iterator()也将被禁止。如下图所示:
ArrayList要提供遍历器,只需要覆盖它继承自AbstractList的get(int)和remove(int)方法就可以了。也就是说,遍历器的普遍行为都在AbstractList中定义了,其他具体类只需要根据自己的特点覆盖几个方法就能够使用iterator()。 ListItr内嵌类继承了Itr类,源码如下:
private class ListItr extends Itr implements ListIterator { ListItr(int index) { cursor = index; }
public boolean hasPrevious() { return cursor != 0; }
public Object previous() { try { int i = cursor - 1; Object previous = get(i); checkForComodification(); lastRet = cursor = i; return previous; } catch(IndexOutOfBoundsException e) { checkForComodification(); throw new NoSuchElementException(); } }
public int nextIndex() { return cursor; }
public int previousIndex() { return cursor-1; }
public void set(Object o) { if (lastRet == -1) throw new IllegalStateException(); checkForComodification(); //检查是否有修改
try { AbstractList.this.set(lastRet, o); expectedModCount = modCount; } catch(IndexOutOfBoundsException e) { throw new ConcurrentModificationException(); } }
public void add(Object o) { checkForComodification();
try { AbstractList.this.add(cursor++, o); lastRet = -1; expectedModCount = modCount; } catch(IndexOutOfBoundsException e) { throw new ConcurrentModificationException(); } } }
AbstractList.listIterator()有两个:
(1)public ListIterator listIterator() { return listIterator(0); }
(2)public ListIterator listIterator(final int index) { if (index<0 || index>size()) throw new IndexOutOfBoundsException("Index: "+index);
return new ListItr(index); }
Joshua Bloch设计的Collection架构之美,只有在源码中慢慢领会…… |