队列排序测试

src/IEnumerator.ts

@@ -1,3 +1,5 @@
+import { IAdapter, Indexer } from "./IAdapter";
+import { TreeNode } from "./TreeNode";
 export interface IEnumberator<T> {
     reset(): void;
     moveNext(): boolean;

src/NodeB2TEnumberator.ts

@@ -3,8 +3,8 @@ 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;
+    private _arr !: Array<TreeNode<T> | undefined>;
+    private _arrIdx !: number;
 
     public constructor(iter: IEnumberator<TreeNode<T>>) {
         this._iter = iter;

src/NodeT2BEnumerator.ts

@@ -27,12 +27,12 @@ export class NodeT2BEnumberator<T, IdxFunc extends Indexer, Adapter extends IAda
         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;
@@ -50,5 +50,4 @@ export class NodeT2BEnumberator<T, IdxFunc extends Indexer, Adapter extends IAda
     public get current(): TreeNode<T> | undefined {
         return this._currNode;
     }
-
 }

src/Stack.ts

@@ -3,7 +3,7 @@ import { AdapterBase } from "./AdapterBase";
 export class Stack<T> extends AdapterBase<T>{
     public remove(): T | undefined {
         if(this._arr.length > 0){
-            this._arr.pop();
+            return this._arr.pop();
         }
         return undefined;
     }

src/TreeNode.ts

@@ -1,7 +1,7 @@
 export class TreeNode<T> {
     private _parent: TreeNode<T> | undefined;
     private _children: Array<TreeNode<T>> | undefined;
-    public name: string | undefined;
+    public name: string ;
     public data: T | undefined;
 
     public constructor(data: T | undefined = undefined, parent: TreeNode<T> | undefined = undefined, name: string) {
@@ -142,15 +142,22 @@ export class TreeNode<T> {
         return curr;
     }
 
-    public get depth() :number{
+    public get depth(): number {
         let curr: TreeNode<T> | undefined = this;
         let level: number = 0;
 
-        while(curr !== undefined && curr._parent !== undefined){
+        while (curr !== undefined && curr._parent !== undefined) {
             curr = curr._parent;
             level++;
         }
 
         return level;
     }
+    public repeatString(target: string, n: number): string {
+        let total: string = "";
+        for(let i = 0; i < n; i++){
+            total += target;
+        }
+        return total;
+    }
 }

src/index.ts

@@ -1,10 +1,57 @@
-import { Dictionary } from "./Dictionary";
+import { IEnumberator } from "./IEnumerator";
+import { NodeEnumeratorFactory } from "./NodeEnumeratorFactory";
+import { TreeNode } from "./TreeNode";
+import { IndexerL2R, IndexerR2L } from "./IAdapter";
+import { NodeT2BEnumberator } from "./NodeT2BEnumerator";
+import { Stack } from "./Stack";
+import { Queue } from "./Queue";
+import { NodeB2TEnumerator } from "./NodeB2TEnumberator";
 
-let dict: Dictionary<string> = new Dictionary(false);
-dict.insert("ka", "a");
-dict.insert("kd", "d");
-dict.insert("kc", "c");
-dict.insert("kb", "b");
+class NumberNode extends TreeNode<number> { }
 
-console.log(JSON.stringify(dict.keys));
-console.log(JSON.stringify(dict.values));
+class TreeNodeTest {
+    public static createTree(): NumberNode {
+        let root: NumberNode = new NumberNode(0, undefined, " root ");
+        let node1: NumberNode = new NumberNode(1, root, " node1 ");
+        let node2: NumberNode = new NumberNode(2, root, " node2 ");
+        let node3: NumberNode = new NumberNode(3, root, " node3 ");
+        let node4: NumberNode = new NumberNode(4, node1, " node4 ");
+        let node5: NumberNode = new NumberNode(5, node1, " node5 ");
+        let node6: NumberNode = new NumberNode(6, node2, " node6 ");
+        let node7: NumberNode = new NumberNode(7, node2, " node7 ");
+        let node8: NumberNode = new NumberNode(8, node3, " node8 ");
+        let node9: NumberNode = new NumberNode(9, node4, " node9 ");
+        let node10: NumberNode = new NumberNode(10, node6, " node10 ");
+        let node11: NumberNode = new NumberNode(11, node7, " node11 ");
+        let node12: NumberNode = new NumberNode(12, node11, " node12 ");
+        return root;
+    }
+
+    public static outputNodesInfo(iter: IEnumberator<TreeNode<number>>): string {
+        let output: string[] = [];
+        let current: TreeNode<number> | undefined = undefined;
+        while(iter.moveNext()){
+            current = iter.current;
+            if(current !== undefined){
+                output.push(current.name);
+            }
+        }
+        return "实际输出：[" + output.join(",") + " ] ";
+    }
+}
+
+let root: NumberNode = TreeNodeTest.createTree();
+let iter: IEnumberator<TreeNode<number>>;
+let current: TreeNode<number> | undefined = undefined;
+
+iter = new NodeT2BEnumberator(root, IndexerR2L, Stack);
+
+while (iter.moveNext()) {
+    current = iter.current;
+    if (current !== undefined) {
+        console.log(current.repeatString(" ", current.depth * 4) + current.name);
+    }
+}
+
+// iter = new NodeT2BEnumberator(root, IndexerR2L, Queue);
+// console.log(TreeNodeTest.outputNodesInfo(iter));