遍历和JAVA遍历

遍历概念

    　所谓遍历(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>

<script language="javascript" type="text/javascript"> ad_width=600; ad_height=60; adcss=2; ad_type='j'; unionuser=17; tags='java,java遍历目录及子目录下的文件' count=3; </script>

作者：suncheng_hong 来源：csdn.net 发表于7个月以前

java遍历目录及子目录下的文件   <script src="http://blog.csdn.net/count.aspx?ID=1671632&Type=Rank" type="text/javascript"></script>  

 

package  com.daacc.common;

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架构之美，只有在源码中慢慢领会…… 作者Blog： http://blog.csdn.net/lasersong2004/