面试20之创建含有某一深度上所有结点的链表。

题目描述

对于一棵二叉树，请设计一个算法，创建含有某一深度上所有结点的链表。

给定二叉树的根结点指针TreeNode* root，以及链表上结点的深度，请返回一个链表ListNode，代表该深度上所有结点的值，请按树上从左往右的顺序链接，保证深度不超过树的高度，树上结点的值为非负整数且不超过100000。

<方法1>：层次遍历

     这个题目的意思就是输出二叉树的某一层的所有元素，这个首先想到的是层次遍历，层次遍历最简单的方法就是用队列实现，我们传统的层次遍历方法是可以输出所有元素，那么如何区分相邻两层之间的元素呢？

     其实我们可以用两个整数变量curlevel，nextlevel来记录相邻两层的元素个数，其中curlevel代表出栈那一层留下的元素个数，nextlevel代表下一层进栈元素的个数，每当curlevel为0的时候，说明上一层已经全部出栈，下一层已经全部入栈，那么层次遍历层数就加一，这个时候将nextlevel的值复制给curlevel，nextlevel=0，当遍历到第dep层的时候，便把那一层的所有元素输出，停止遍历。

<方法2>：递归遍历

     其实也可以用递归遍历实现，刚开始为深度为dep，每往下递归一层，则深度减一（dep=dep-1），当dep==1的时候，便输出那个元素，如果先递归左子树，那么则实现从左到右打印，如果先递归右子树，则实现从右往左打印。

树的节点和链表节点定义：

struct TreeNode
{
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x):val(x),left(NULL),right(NULL) { }
};

struct ListNode
{
int val;
struct ListNode *next;
ListNode(int x):val(x),next(NULL) { }
};

//第一种方法，非递归。

ListNode *GetTreeLevel(TreeNode *root,int dep)
{
if(root == NULL || dep <= 0)
return NULL;

int heigh = 1;
queue<TreeNode*> q;
q.push(root);
int curlevel = 1;  //表示当前要遍历层的节点个数。
int nextlevel = 0;//表示下一层节点个数。
while (!q.empty())
{
if(heigh == dep)
break;
TreeNode *temp = q.front();
q.pop();
if(temp->left)
{
q.push(temp->left);
nextlevel++;
}
if(temp->right)
{
q.push(temp->right);
nextlevel++;
}
curlevel--;
if(curlevel == 0) //表示这一层遍历完了。
{
heigh++;  //遍历下一层高度++
curlevel = nextlevel;
nextlevel = 0;
}
}

ListNode *phead = NULL;
ListNode *Tail = NULL;

while(!q.empty())  //此时队列中存放的是要求的这一层的节点。
{
TreeNode *temp = q.front();
ListNode *Node = new ListNode(temp->val);
q.pop();

if(phead == NULL)
{
phead = Node;
Tail = Node;
}
else
{
Tail->next = Node;
Tail = Node;
}
}
return phead;
}

//第二种方式，递归，但是链表要有一个头节点。
void Get(TreeNode *root,ListNode *&head,int dep) //注意这里要用引用。递归会回退，比如在树中找第二层的节点，在左子树找到了，head->next = left,head = left,
{ //但是递归退回到跟节点，找右子树，也找到，但是此时head还是头节点，而不是指向刚刚插入的左子树了。又重新插入节点。
if(root == NULL||dep <= 0)
return ;
if(dep == 1)
{
ListNode *Node = new ListNode(root->val);
head->next = Node;
head = Node;
return ;
}
Get(root->left,head,dep-1);
Get(root->right,head,dep-1);
}

ListNode *GetTreeLevel(TreeNode *root,int dep)
{
if(root == NULL || dep <= 0)
return NULL;
ListNode *pHead = new ListNode(-1); //头节点。
ListNode *list = pHead;
Get(root,pHead,dep);

return list->next;
}


测试代码：
void test()
{
TreeNode *p1 = new TreeNode(1);
TreeNode *p2 = new TreeNode(2);
TreeNode *p3 = new TreeNode(3);
TreeNode *p4 = new TreeNode(4);
TreeNode *p5 = new TreeNode(5);
TreeNode *p6 = new TreeNode(6);
TreeNode *p7 = new TreeNode(7);
TreeNode *p8 = new TreeNode(8);
TreeNode *p9 = new TreeNode(9);
TreeNode *p10 = new TreeNode(10);

p1->left = p2;
p1->right = p3;
p2->left = p4;
p2->right = p5;
p3->right = p6;
p4->left = p7;
p4->right = p8;
p5->right = p9;
p6->right = p10;

ListNode *phead = GetTreeLevel(p1, 4);

while(phead)
{
cout << phead->val << " ";
phead = phead->next;
}

}

int main()
{
test();

cout << "hello..."<<endl;
return 0;
}