//深度优先 
类节目 
    { 
        静态无效的主要（字串[] args） 
        { 
            int []号= int新[] {1，3，5，7}; 
            列表数据=新名单（）; 
            堆栈的openstack =新的堆栈（）; 
            树根=新树（）; 
            树父=根; 
            而（真） 
            {
如果（parent.getdeep（）== 4） 
                { 
                    parent.printf（）;
} 
                其他 
                { 
                   var tempson = number.tolist（）; 
                   的foreach（在tempson var项） 
                   { 
                       ）树节点=新树（; 
                       node.nodedata =项目; 
                       node.parent =父母; 
                       openstack.push（节点）; 
                   } 
                } 
               如果（openstack.count == 0）[颜色= darkred] [/ color] 
                    突破; 
               变种的itemdata = openstack.pop（）; 
               父=的itemdata;
} 
            system.console.read（）;
} 
        公共静态无效的printf（列表数据） 
        { 
            串d =＆quot;英寸; 
            data.foreach（p值= d 1和d = d + p）; 
            的system.console.writeline（d）; 
        } 
    } 
    类树 
    { 
        公共树父; 
        公众诠释nodedata; 
        公开名单的儿子=新名单（）; 
        公众诠释getdeep（） 
        { 
            int i = 0; 
              var p =这一点; 
            而（真） 
            { 
                如果（p == null） 
                { 
                    回报我; 
                } 
                否则 
                { 
                    p = p.parent; 
                    我++;
}
}
} 
        公共无效的printf（） 
        { 
            字符串pf =＆quot;英寸; 
            var p =这一点; 
            而（真） 
            { 
                如果（p == null） 
                { 
                    的system.console.writeline（pf）; 
                    返回; 
                } 
                否则 
                { 
                    如果（p.nodedata！= 0） 
                    { 
                        pf = p.nodedata + pf; 
                    } 
                    p = p.parent; 
                } 
            }
} 
    } 
//广度优先 
类节目 
    { 
        静态无效的主要（字串[] args） 
        { 
            int []号= int新[] {1，3}; 
            名单<int>的数据=新的list <int>的（）; 
            堆栈<树>的openstack =新的堆栈<树>（）; 
            队列<树> openqueue =新队列<树>（）;
树根=新树（）; 
            树父=根; 
            而（真） 
            {
如果（parent.getdeep（）== 4） 
                { 
                    parent.printf（）;
} 
                其他 
                { 
                   var tempson = number.tolist（）; 
                   的foreach（在tempson var项） 
                   { 
                       ）树节点=新树（; 
                       node.nodedata =项目; 
                       node.parent =父母; 
                      // openstack.push（节点）; 
                       openqueue.enqueue（节点）; 
                   } 
                } 
                如果（openqueue.count == 0）//如果（openstack.count == 0） 
                    打破; 
               变种的itemdata = openqueue.dequeue（）; //openstack.pop（）; 
               父=的itemdata;
} 
            system.console.read（）;
}
公共静态无效的printf（名单<int>的数据） 
        { 
            串d =“”; 
            data.foreach（p => d = d + p）; 
            的system.console.writeline（d）; 
        }
} 
    类树 
    { 
        公共树父; 
        公众诠释nodedata; 
        公开名单<树>儿子=新的list <树>（）; 
        公众诠释getdeep（） 
        { 
            int i = 0; 
              var p =这一点; 
            而（真） 
            { 
                如果（p == null） 
                { 
                    回报我; 
                } 
                否则 
                { 
                    p = p.parent; 
                    我++;
}
}
} 
        公共无效的printf（） 
        { 
            字符串pf =“”; 
            var p =这一点; 
            而（真） 
            { 
                如果（p == null） 
                { 
                    的system.console.writeline（pf）; 
                    返回; 
                } 
                否则 
                { 
                    如果（p.nodedata！= 0） 
                    { 
                        pf = p.nodedata + pf; 
                    } 
                    p = p.parent; 
                }
}
} 
    }