1

我在解决递归问题时遇到了很多麻烦。我可以做简单的递归，但这对我来说并不容易。我的目标是加速这个搜索算法。我猜递归会有所帮助。在一个简单的 43 节点树上，它需要 15 秒，因为它是子节点。下面是我对有效代码的展开递归。

var nodeList = new Array();
         var removeList = new Array();
         var count = 0;
         var foundInThisNodeTree;

         var find = function ( condition )
         {
         }

         while ( this.treeIDMap.igTree( "nodeByPath", count ).data() )
         {
             var foundInThisNodeTree = false;
             var n;
             n = this.treeIDMap.igTree( "nodeFromElement", this.treeIDMap.igTree( "nodeByPath", count ) )
             if ( n.data.ITEM.indexOf( filter ) > -1 ) { foundInThisNodeTree = true; }
             else {//look deeper
                 var i = 0;
                 while ( this.treeIDMap.igTree( "nodeByPath", count + "_" + i ).data() )
                 {
                     n = this.treeIDMap.igTree( "nodeFromElement", this.treeIDMap.igTree( "nodeByPath", count + "_" + i ) );
                     if ( n.data.ITEM.indexOf( filter ) > -1 ) { foundInThisNodeTree = true; break; }
                     else {//look deeper
                         var j = 0;
                         while ( this.treeIDMap.igTree( "nodeByPath", count + "_" + i + "_" + j ).data() )
                         {
                             n = this.treeIDMap.igTree( "nodeFromElement", this.treeIDMap.igTree( "nodeByPath", count + "_" + i + "_" + j ) );
                             if ( n.data.ITEM.indexOf( filter ) > -1 ) { foundInThisNodeTree = true; break; }
                             else {//look deeper
                                 var k = 0;
                                 while ( this.treeIDMap.igTree( "nodeByPath", count + "_" + i + "_" + j + "_" + k ).data() )
                                 {
                                     n = this.treeIDMap.igTree( "nodeFromElement", this.treeIDMap.igTree( "nodeByPath", count + "_" + i + "_" + j + "_" + k ) );
                                     if ( n.data.ITEM.indexOf( filter ) > -1 ) { foundInThisNodeTree = true; break; }
                                     k++;
                                 }
                             }

                             j++;
                         }
                     }
                     i++;
                 }
             }
             if ( !foundInThisNodeTree ) this.treeIDMap.igTree("removeAt", ""+count )
             else count++;
         }

** * Mirco Ellmann 建议的第二次修订* ****

var nodeList = new Array();
         var removeList = new Array();
         var count = 0;
         var foundInThisNodeTree;
         filter = filter.toLowerCase();
         while ( this.treeIDMap.igTree( "nodeByPath", count ).data() )
         {
             var foundInThisNodeTree = false;
             var n;
             n = this.treeIDMap.igTree( "nodeFromElement", this.treeIDMap.igTree( "nodeByPath", count ) )
             if ( n.data.ITEM.toLowerCase().indexOf( filter ) > -1 ) { foundInThisNodeTree = true; }
             else {//look deeper
                 var i = 0;
                 n = this.treeIDMap.igTree( "childrenByPath", count );
                 while ( n[i] )
                 {
                     if ( n[i].data.ITEM.indexOf( filter ) > -1 ) { foundInThisNodeTree = true; break; }
                         var j = 0;
                         n = this.treeIDMap.igTree( "childrenByPath", count + "_" + i );
                         while ( n[j]  )
                         {
                             if ( n[j].data.ITEM.indexOf( filter ) > -1 ) { foundInThisNodeTree = true; break; }
                                 var k = 0;
                                 n = this.treeIDMap.igTree( "childrenByPath", count + "_" + i + "_" + j);
                                 while ( n[k] )
                                 {
                                     if ( n[k].data.ITEM.indexOf( filter ) > -1 ) { foundInThisNodeTree = true; break; }
                                     k++;
                                 }
                             j++;
                         }

                     i++;
                 }
             }
             if ( !foundInThisNodeTree ) this.treeIDMap.igTree("removeAt", ""+count )
             else count++;
         }

****使用我的可分支树来获取数据，无需对树进行任何调用* ***

 var count = 0;
 var foundInThisNodeTree;
 filter = filter.toLowerCase();
 while ( this.treeIDMap.igTree( "nodeByPath", count ).data() )
 {
     var foundInThisNodeTree = false;
     var n;
     n = this.treeIDMap.igTree( "nodeFromElement", this.treeIDMap.igTree( "nodeByPath", count ) )
     if ( n.data.ITEM.toLowerCase().indexOf( filter ) > -1 ) { foundInThisNodeTree = true; }
     if ( n.data.branch )//look at all childer under the root node
     {      
         var i = 0;
         n = n.data.branch;
         while ( n[i] )//look at all childer under the root node
         {      
            if ( n[i].ITEM.toLowerCase().indexOf( filter ) > -1 ) { foundInThisNodeTree = true; break; }
            while ( n[i].branch )//look deeper
            {
                var j = 0;
                n = n[i].branch;
                if ( n[j].ITEM.toLowerCase().indexOf( filter ) > -1 ) { foundInThisNodeTree = true; break; }
                while ( n[j].branch )//look deeper
                {
                    var k = 0;
                    n = n[j].branch;
                    if ( n[k].ITEM.toLowerCase().indexOf( filter ) > -1 ) { foundInThisNodeTree = true; break; }
                    k++;
                }

                j++;
            }

             i++;
         }
     }
     if ( !foundInThisNodeTree ) this.treeIDMap.igTree("removeAt", ""+count )
     else count++;
 }
4

3 回答 3

0

好的，我找到了一种使用数据提供程序并使用普通 Json 搜索的方法。不过，如果有人能加快速度，我将不胜感激。我只是从 15 秒到 1。这个有我需要的递归。

   findInObject = function( obj, prop, val )
 {
     if ( obj !== null && obj.hasOwnProperty( prop ) && obj[prop].toLowerCase().indexOf(val) > -1 )
     {
         return obj;
     } else
     {
         for ( var s in obj )
         {
             if ( obj.hasOwnProperty( s ) && typeof obj[s] == 'object' && obj[s] !== null )
             {
                 var result = findInObject( obj[s], prop, val );
                 if ( result !== null )
                 {
                     return result;
                 }
             }
         }
     }
     return null;
 }

 for ( var i = 0; i < this.treeData.length; i++)
 {
     if ( findInObject( this.treeData[i], "ITEM", filter ) ) foundNodes.push( this.treeData[i] )//does the node have a match?
 }

 this.treeIDMap.igTree( { dataSource: foundNodes } );
 this.treeIDMap.igTree( "dataBind" );

};

于 2013-05-08T19:05:41.650 回答
0

而不是总是使用“nodeByPath”，你应该使用“childrenByPath”。

这将最小化 igTree 上的搜索调用。

PS：使用而不是替换；）

于 2013-05-08T16:00:11.937 回答
0

您并没有真正递归地执行此操作。您宁愿为层次结构中的每个级别重复代码。您想要的是一个辅助函数，它将当前节点路径作为参数，并为其每个子节点递归调用相同的方法，并将其 id 添加到当前节点的路径中。递归意味着代码应该适用于任何深度的树。对我来说，您的代码似乎只适用于设定的深度。

对于速度问题，可能有两个问题。我并没有真正仔细阅读您的代码，所以我留给您找出哪个更有可能。

  1. 您可能正在重新访问节点。如果是这样，显然这会影响性能。

  2. 您正在使用的框架在查找节点时可能会很慢。一种解决方案可能是找到替代方法来调用适用于您正在做的事情的框架。例如，框架可能在内部具有分层表示，但是当您传入完整路径时必须重新构建或解析它。寻找采用源和相对路径的方法。如果这不是问题，那么框架可能会很慢，您可能最好读取所有节点并构建自己的内存树来代替使用。

于 2013-05-08T18:24:09.883 回答