diff --git a/src/IAdapter.ts b/src/IAdapter.ts
index 91ddbe7f..e0dcfcd9 100755
--- a/src/IAdapter.ts
+++ b/src/IAdapter.ts
@@ -1,3 +1,11 @@
+export type Indexer = (len: number, idx: number) => number;
+export function IndexerL2R(len: number, idx: number): number {
+    return idx;
+}
+export function IndexerR2L(len: number, idx: number): number {
+    return (len - idx - 1);
+}
+
 export interface IAdapter<T> {
     add(t: T): void;
     remove(): T | undefined;
diff --git a/src/IEnumerator.ts b/src/IEnumerator.ts
new file mode 100755
index 00000000..cd6994e9
--- /dev/null
+++ b/src/IEnumerator.ts
@@ -0,0 +1,5 @@
+export interface IEnumberator<T> {
+    reset(): void;
+    moveNext(): boolean;
+    readonly current: T | undefined;
+}
\ No newline at end of file
diff --git a/src/NodeB2TEnumberator.ts b/src/NodeB2TEnumberator.ts
new file mode 100755
index 00000000..612d8b84
--- /dev/null
+++ b/src/NodeB2TEnumberator.ts
@@ -0,0 +1,35 @@
+import { IEnumberator } from "./IEnumerator";
+import { TreeNode } from "./TreeNode";
+
+export class NodeB2TEnumerator<T> implements IEnumberator<TreeNode<T>>{
+    private _iter: IEnumberator<TreeNode<T>>;
+    private _arr: Array<TreeNode<T> | undefined>;
+    private _arrIdx: number;
+
+    public constructor(iter: IEnumberator<TreeNode<T>>) {
+        this._iter = iter;
+        this.reset();
+    }
+    public reset(): void {
+        this._arr = [];
+        //调用先根枚举器，把结果存入数组
+        while (this._iter.moveNext()) {
+            this._arr.push(this._iter.current);
+        }
+        //设置_arrIdx为数组的length,因为从尾部先前遍历
+        this._arrIdx = this._arr.length;
+    }
+
+    public get current(): TreeNode<T> | undefined {
+        if (this._arrIdx >= this._arr.length) {
+            return undefined;
+        } else {
+            return this._arr[this._arrIdx];
+        }
+    }
+
+    public moveNext(): boolean {
+        this._arrIdx--;
+        return (this._arrIdx >= 0 && this._arrIdx < this._arr.length);
+    }
+}
\ No newline at end of file
diff --git a/src/NodeEnumeratorFactory.ts b/src/NodeEnumeratorFactory.ts
new file mode 100755
index 00000000..8062718e
--- /dev/null
+++ b/src/NodeEnumeratorFactory.ts
@@ -0,0 +1,90 @@
+import { IndexerL2R, IndexerR2L } from "./IAdapter";
+import { IEnumberator } from "./IEnumerator";
+import { NodeT2BEnumberator } from "./NodeT2BEnumerator";
+import { TreeNode } from "./TreeNode";
+import { Stack } from "./Stack";
+import { Queue } from "./Queue";
+import { NodeB2TEnumerator } from "./NodeB2TEnumberator";
+
+export class NodeEnumeratorFactory {
+
+    /**
+     * 创建深度优先，从左到右，从上到下的枚举器
+     * @param node 
+     * @returns 
+     */
+    public static create_df_l2r_t2b_iter<T>(node: TreeNode<T> | undefined): IEnumberator<TreeNode<T>> {
+        let iter: IEnumberator<TreeNode<T>> = new NodeT2BEnumberator(node, IndexerR2L, Stack);
+        return iter;
+    }
+
+    /**
+     * 创建深度优先，从右到左，从上到下的枚举器
+     * @param node 
+     * @returns 
+     */
+    public static create_df_r2l_t2b_iter<T>(node: TreeNode<T> | undefined): IEnumberator<TreeNode<T>> {
+        let iter: IEnumberator<TreeNode<T>> = new NodeT2BEnumberator(node, IndexerL2R, Stack);
+        return iter;
+    }
+
+    /**
+     * 创建广度优先，从左到右，从上到下的枚举器
+     * @param node 
+     * @returns 
+     */
+    public static create_bf_l2r_t2b_iter<T>(node: TreeNode<T> | undefined): IEnumberator<TreeNode<T>> {
+        let iter: IEnumberator<TreeNode<T>> = new NodeT2BEnumberator(node, IndexerL2R, Queue);
+        return iter;
+    }
+
+    /**
+     * 创建广度优先，从右到左，从上到下的枚举器
+     * @param node 
+     * @returns 
+     */
+    public static create_bf_r2l_t2b_iter<T>(node: TreeNode<T> | undefined): IEnumberator<TreeNode<T>> {
+        let iter: IEnumberator<TreeNode<T>> = new NodeT2BEnumberator(node, IndexerR2L, Queue);
+        return iter;
+    }
+
+    /**
+     * 创建深度优先，从左到右，从下到上的枚举器
+     * @param node 
+     * @returns 
+     */
+    public static create_df_l2r_b2t_iter<T>(node: TreeNode<T> | undefined): IEnumberator<TreeNode<T>> {
+        let iter: IEnumberator<TreeNode<T>> = new NodeB2TEnumerator<T>(NodeEnumeratorFactory.create_df_r2l_t2b_iter(node));
+        return iter;
+    }
+
+    /**
+     * 创建深度优先，从右到左，从下到上的枚举器
+     * @param node 
+     * @returns 
+     */
+    public static create_df_r2l_b2t_iter<T>(node: TreeNode<T> | undefined): IEnumberator<TreeNode<T>> {
+        let iter: IEnumberator<TreeNode<T>> = new NodeB2TEnumerator<T>(NodeEnumeratorFactory.create_df_l2r_t2b_iter(node));
+        return iter;
+    }
+
+    /**
+     * 创建广度优先，从左到右，从下到上的枚举器
+     * @param node 
+     * @returns 
+     */
+    public static create_bf_l2r_b2t_iter<T>(node: TreeNode<T> | undefined): IEnumberator<TreeNode<T>> {
+        let iter: IEnumberator<TreeNode<T>> = new NodeB2TEnumerator<T>(NodeEnumeratorFactory.create_bf_r2l_t2b_iter(node));
+        return iter;
+    }
+
+    /**
+     * 创建广度优先，从右到左，从下到上的枚举器
+     * @param node 
+     * @returns 
+     */
+     public static create_bf_r2l_b2t_iter<T>(node: TreeNode<T> | undefined): IEnumberator<TreeNode<T>> {
+        let iter: IEnumberator<TreeNode<T>> = new NodeB2TEnumerator<T>(NodeEnumeratorFactory.create_bf_l2r_t2b_iter(node));
+        return iter;
+    }
+}
\ No newline at end of file
diff --git a/src/NodeT2BEnumerator.ts b/src/NodeT2BEnumerator.ts
new file mode 100755
index 00000000..c7e99392
--- /dev/null
+++ b/src/NodeT2BEnumerator.ts
@@ -0,0 +1,54 @@
+import { IAdapter, Indexer } from "./IAdapter";
+import { IEnumberator } from "./IEnumerator";
+import { TreeNode } from "./TreeNode";
+
+export class NodeT2BEnumberator<T, IdxFunc extends Indexer, Adapter extends IAdapter<TreeNode<T>>> implements IEnumberator<TreeNode<T>> {
+    private _node: TreeNode<T> | undefined;
+    private _adapter !: IAdapter<TreeNode<T>>;
+    private _currNode !: TreeNode<T> | undefined;
+    private _indexer !: IdxFunc;
+
+    public constructor(node: TreeNode<T> | undefined, func: IdxFunc, adapter: new () => Adapter) {
+        if (node === undefined) {
+            return;
+        }
+        this._node = node;
+        this._indexer = func;
+        this._adapter = new adapter();
+        this._currNode = undefined;
+        this._adapter.add(this._node); //将根节点放入到堆栈或队列中
+    }
+    reset(): void {
+        if (this._node === undefined) {
+            return;
+        }
+        this._currNode = undefined;
+        this._adapter.clear();
+        this._adapter.add(this._node);
+    }
+    moveNext(): boolean {
+        if (this._adapter.isEmpty) {
+            return false;
+        }
+        //弹出头或尾元素，依赖adapter是stack还是queue
+        this._currNode = this._adapter.remove();
+
+        if (this._currNode !== undefined) {
+            //获取当前节点的儿子个数
+            let len: number = this._currNode.childCount;
+
+            for (let i = 0; i < len; i++) {
+                let childIdx: number = this._indexer(len, i);
+                let child: TreeNode<T> | undefined = this._currNode.getChildAt(childIdx);
+                if(child !== undefined){
+                    this._adapter.add(child);
+                }
+            }
+        }
+        return true;
+    }
+    public get current(): TreeNode<T> | undefined {
+        return this._currNode;
+    }
+
+}
\ No newline at end of file
diff --git a/src/Queue.ts b/src/Queue.ts
index b1ef6986..04fee9d5 100755
--- a/src/Queue.ts
+++ b/src/Queue.ts
@@ -1,7 +1,7 @@
 import { AdapterBase } from "./AdapterBase";
 import { List } from "./List";
 
-export class Quene<T> extends AdapterBase<T>{
+export class Queue<T> extends AdapterBase<T>{
     public remove(): T | undefined {
         if (this._arr.length > 0) {
             if (this._arr instanceof List) {
diff --git a/src/ThreeNode.ts b/src/TreeNode.ts
similarity index 73%
rename from src/ThreeNode.ts
rename to src/TreeNode.ts
index 510dc92c..d2263885 100755
--- a/src/ThreeNode.ts
+++ b/src/TreeNode.ts
@@ -1,10 +1,10 @@
-export class ThreeNode<T> {
-    private _parent: ThreeNode<T> | undefined;
-    private _children: Array<ThreeNode<T>> | undefined;
+export class TreeNode<T> {
+    private _parent: TreeNode<T> | undefined;
+    private _children: Array<TreeNode<T>> | undefined;
     public name: string | undefined;
     public data: T | undefined;
 
-    public constructor(data: T | undefined = undefined, parent: ThreeNode<T> | undefined = undefined, name: string) {
+    public constructor(data: T | undefined = undefined, parent: TreeNode<T> | undefined = undefined, name: string) {
         this._parent = parent;
         this._children = undefined;
         this.name = name;
@@ -19,13 +19,13 @@ export class ThreeNode<T> {
      * @param ancestor 
      * @returns 
      */
-    public isDescendantOf(ancestor: ThreeNode<T> | undefined): boolean {
+    public isDescendantOf(ancestor: TreeNode<T> | undefined): boolean {
         if (ancestor === undefined) {
             return false;
         }
         //从当前节点向上遍历
-        let node: ThreeNode<T> | undefined = this._parent; //不明白为啥要添加这句
-        for (let node: ThreeNode<T> | undefined = this._parent; node != undefined; node = node?._parent) {
+        let node: TreeNode<T> | undefined = this._parent; //不明白为啥要添加这句
+        for (let node: TreeNode<T> | undefined = this._parent; node != undefined; node = node?._parent) {
             if (node === ancestor) {
                 return true;
             }
@@ -33,7 +33,7 @@ export class ThreeNode<T> {
         return false;
     }
 
-    public getChildAt(index: number): ThreeNode<T> | undefined {
+    public getChildAt(index: number): TreeNode<T> | undefined {
         if (this._children === undefined) {
             return undefined;
         }
@@ -43,11 +43,11 @@ export class ThreeNode<T> {
         return this._children[index];
     }
 
-    public removeChildAt(index: number): ThreeNode<T> | undefined {
+    public removeChildAt(index: number): TreeNode<T> | undefined {
         if (this._children === undefined) {
             return undefined;
         }
-        let child: ThreeNode<T> | undefined = this.getChildAt(index);
+        let child: TreeNode<T> | undefined = this.getChildAt(index);
         if (child === undefined) {
             return undefined;
         }
@@ -56,7 +56,7 @@ export class ThreeNode<T> {
         return child;
     }
 
-    public removeChild(child: ThreeNode<T> | undefined): ThreeNode<T> | undefined {
+    public removeChild(child: TreeNode<T> | undefined): TreeNode<T> | undefined {
         if (child === undefined) {
             return undefined;
         }
@@ -79,14 +79,14 @@ export class ThreeNode<T> {
     /**
      * 把当前节点在父节点中删除
      */
-    public remove(): ThreeNode<T> | undefined {
+    public remove(): TreeNode<T> | undefined {
         if (this._parent !== undefined) {
             return this._parent.removeChild(this);
         }
         return undefined;
     }
 
-    public addChildAt(child: ThreeNode<T>, index: number): ThreeNode<T> | undefined {
+    public addChildAt(child: TreeNode<T>, index: number): TreeNode<T> | undefined {
         //第一种情况，如果child是本节点的祖先节点，是不允许的
         if (this.isDescendantOf(child)) {
             return undefined;
@@ -112,14 +112,14 @@ export class ThreeNode<T> {
         }
     }
 
-    public addChild(child: ThreeNode<T>): ThreeNode<T> | undefined {
+    public addChild(child: TreeNode<T>): TreeNode<T> | undefined {
         if (this._children === undefined) {
             this._children = [];
         }
         return this.addChildAt(child, this._children.length);
     }
 
-    public get parent(): ThreeNode<T> | undefined {
+    public get parent(): TreeNode<T> | undefined {
         return this._parent;
     }
 
@@ -134,8 +134,8 @@ export class ThreeNode<T> {
         return this._children !== undefined && this._children.length > 0;
     }
 
-    public get root(): ThreeNode<T> | undefined {
-        let curr: ThreeNode<T> | undefined = this;
+    public get root(): TreeNode<T> | undefined {
+        let curr: TreeNode<T> | undefined = this;
         while (curr !== undefined && curr._parent !== undefined) {
             curr = curr._parent;
         }
@@ -143,7 +143,7 @@ export class ThreeNode<T> {
     }
 
     public get depth() :number{
-        let curr: ThreeNode<T> | undefined = this;
+        let curr: TreeNode<T> | undefined = this;
         let level: number = 0;
 
         while(curr !== undefined && curr._parent !== undefined){