java多叉树的层次遍历_多叉树的层次遍历

多叉树的层次遍历　这个在网上有完整程序的好像不多. 我在网上看到一个，就把它转帖过来了,

有兴趣的朋友一起来研究下.

TreeNode.h　文件

#ifndef __TREENODE_

#define __TREENODE_

#include "StdAfx.h"

#include

#include

#include

#include

using namespace std;

class TreeNode

{

private:

long selfID;

string nodeName;

list *p_childList;

public:

TreeNode();

~TreeNode();

/*向当前节点中插入一个子节点*/

void insertChildNode(TreeNode *treeNode);

/*遍历树，层次遍历*/

void LevelTraverse() ;

//判断某个节点是否为叶子节点

bool isLeaf();

//返回当前节点的孩子集合

list * getChildList();

long getSelfId();

void setSelfId(long selfID);

string getNodeName();

void setNodeName(string &nodeName);

};

//返回当前节点的孩子集合

inline list * TreeNode::getChildList()

{

return p_childList;

}

inline long TreeNode::getSelfId()

{

return selfID;

}

inline void TreeNode::setSelfId(long selfID)

{

this->selfID = selfID;

}

inline string TreeNode::getNodeName()

{

return nodeName;

}

inline void TreeNode::setNodeName(string &nodeName)

{

this->nodeName = nodeName;

}

#endif

TreeNode.cpp　文件

#include "stdafx.h"

#include "TreeNode.h"

TreeNode::TreeNode()

{

selfID = 0 ;

nodeName = "";

p_childList = NULL;

}

TreeNode::~TreeNode()

{

delete p_childList;

}

//判断某个节点是否为叶子节点

bool TreeNode::isLeaf()

{

if (NULL == p_childList)

{

return true;

}

else

{

return false;

}

}

/*向当前节点中插入一个子节点*/

void TreeNode::insertChildNode(TreeNode *treeNode)

{

if (NULL==treeNode)

{

cout<

return;

}

if (isLeaf())

{

p_childList = new list;

}

p_childList->push_back((TreeNode*)treeNode);

}

/*遍历树，层次遍历*/

void TreeNode::LevelTraverse()

{

queue queue ;

queue.push((TreeNode*)this);

TreeNode *p = NULL;

while (!queue.empty())

{

p = queue.front();

queue.pop();

cout<getSelfId()<

if (NULL!= p->getChildList())

{

list::iterator it = (p->getChildList())->begin();

while(it!= (p->getChildList())->end())

{

queue.push((*it));

++it;

}

}

}

}

测试代码:

#include "stdafx.h"

#include "TreeNode.h"

int main(int argc, char* argv[])

{

TreeNode root;

root.setSelfId(0);

TreeNode *node1 = new TreeNode();

TreeNode *node2 = new TreeNode();

TreeNode *node3 = new TreeNode();

TreeNode *node10 = new TreeNode();

node10->setSelfId(10);

node1->setSelfId(1);

node2->setSelfId(2);

node3->setSelfId(3);

root.insertChildNode(node1);

root.insertChildNode(node2);

root.insertChildNode(node3);

root.insertChildNode(node10);

TreeNode *node4 = new TreeNode();

TreeNode *node5 = new TreeNode();

node4->setSelfId(4);

node5->setSelfId(5);

node1->insertChildNode(node4);

node1->insertChildNode(node5);

TreeNode *node6 = new TreeNode();

TreeNode *node7 = new TreeNode();

TreeNode *node8 = new TreeNode();

node6->setSelfId(6);

node7->setSelfId(7);

node8->setSelfId(8);

node4->insertChildNode(node6);

node4->insertChildNode(node7);

node4->insertChildNode(node8);

//遍历

root.LevelTraverse();

delete node1;

delete node2;

delete node3;

delete node4;

delete node5;

delete node6;

delete node7;

delete node8;

return 0;

}

打印出来的结果是:

0 1 2 3 10 4 5 6 7 8 (其中10是故意用来测试的)

这个只是简单的测试,大家可以用模板来实现.

这个算法有几个关键的地方:

1.　list 中存放的是指针,好处就不用说了.如果不用指针的话,在delete时候会出现问题.原因大家也清楚.

2.　用队列比栈实现起来要方便。