user-0 提问: 递归能实现广度优先吗？

回复:
user: user-1
content: 引用 20 楼 user-2 的回复:if (node->left) q.push(node->left);                 if (node->right) q.push(node->right); 请问这段代码 和 我做的      if(pnode->pleft != NULL)         q.push(pnode->pleft);     if(pnode->pright != NULL)         q.push(pnode->pright); 有什么区别 我的做法是为了队列而队列  你的代码就伟大光正唯一正确? 人为何能如此自大呢 还水平特别低

user: user-1
content: 引用 20 楼 user-2 的回复:二叉树的 左右存的孩子结点 你这算啥     arr[0].pleft = arr+1;     arr[0].pright = arr+2;     arr[1].pleft = arr+3;     arr[1].pright = arr+4;     arr[2].pleft = arr+5;     arr[2].pright = arr+6; 你看不出这是存了左右节点?? arr[0].pleft = arr+1; 看不懂? 这个等于 arr[0].pleft = &arr[1]; 能理解吗  arr[0].pleft 左节点是一个结构体指针  我用数组元素的地址给这个节点赋值  所以节点0的左子节点是节点1 能看懂吗 你是不是没学过指针??

user: user-1
content: 引用 21 楼 user-2 的回复:一般 书上都是对的吧，循环不能转化为递归的，举个极端的例子 ，比如   while True:     print(0)  def dg():     print("0")     dg() dg() 我用while True可以无限打印 0  但是 递归会爆栈请百度一下尾递归

user: user-2
content: 引用 19 楼 lin5161678 的回复:[quote=引用 15 楼 user-2 的回复:] 一本书上说的，我说了也不算，书上原话是： 所有递归都可以转化为循环  并没有所有循环可以转化为递归这句话，但是我觉得应该是这样，循坏可以无限复杂，递归不一样，一个正向，一个逆向，个人观点，递归人脑算起来复杂度很高死读书?? 关于是不是 全部循环都能改为递归 我也不多说什么了 就举例一个Haskell语言 知道你不会 但你总听说过吧?? 这个语言 没有循环  需要用到循环的操作 这里全部得用递归处理  你体会一下[/quote] 一般 书上都是对的吧，循环不能转化为递归的，举个极端的例子 ，比如   while True:     print(0)      def dg():     print("0")     dg() dg() 我用while True可以无限打印 0  但是 递归会爆栈

user: user-2
content: 引用 30 楼 lin5161678 的回复:[quote=引用 25 楼 user-2 的回复:] 那尾递归无限输出可以不爆栈吗？ 可以 00861002  xor         eax,offset __imp__puts (8620A0h)   	puts("1"); 00861007  push        offset string "1" (8620F4h)   0086100C  call        esi   0086100E  add         esp,4   	tailrecsum(); 00861011  jmp         tailrecsum+7 (861007h)   这是vs2010开启优化之后的尾递归汇编 可以看到递归只是一个jmp指令 不会操作堆栈 多少层都不会造成爆栈[/quote]   引用 30 楼 lin5161678 的回复:[quote=引用 25 楼 user-2 的回复:] 那尾递归无限输出可以不爆栈吗？ 可以 00861002  xor         eax,offset __imp__puts (8620A0h)   	puts("1"); 00861007  push        offset string "1" (8620F4h)   0086100C  call        esi   0086100E  add         esp,4   	tailrecsum(); 00861011  jmp         tailrecsum+7 (861007h)   这是vs2010开启优化之后的尾递归汇编 可以看到递归只是一个jmp指令 不会操作堆栈 多少层都不会造成爆栈[/quote] 嗯，学到嘞

user: user-1
content: 引用 29 楼 user-2 的回复:学习啦 俺错了 学习到东西不寒掺 不仅不寒碜 还很有风度有心胸  你这样回复反而显得我前面部分回复略显刻薄 抱歉 一时没控制住情绪

user: user-1
content: 引用 25 楼 user-2 的回复:那尾递归无限输出可以不爆栈吗？ 哦 漏了代码  void tailrecsum(){ 	puts("1"); 	tailrecsum(); }

user: user-1
content: 引用 25 楼 user-2 的回复:那尾递归无限输出可以不爆栈吗？ 可以 00861002  xor         eax,offset __imp__puts (8620A0h)   	puts("1"); 00861007  push        offset string "1" (8620F4h)   0086100C  call        esi   0086100E  add         esp,4   	tailrecsum(); 00861011  jmp         tailrecsum+7 (861007h)  这是vs2010开启优化之后的尾递归汇编 可以看到递归只是一个jmp指令 不会操作堆栈 多少层都不会造成爆栈

user: user-2
content: 引用 22 楼 lin5161678 的回复:[quote=引用 21 楼 user-2 的回复:] 一般 书上都是对的吧，循环不能转化为递归的，举个极端的例子 ，比如   while True:     print(0)      def dg():     print("0")     dg() dg() 我用while True可以无限打印 0  但是 递归会爆栈请百度一下尾递归[/quote] 类似于贪吃蛇？ 就不再开辟新的内存空间了吗？  引用 24 楼 lin5161678 的回复:[quote=引用 20 楼 user-2 的回复:]                if (node->left) q.push(node->left);                 if (node->right) q.push(node->right); 请问这段代码 和 我做的      if(pnode->pleft != NULL)         q.push(pnode->pleft);     if(pnode->pright != NULL)         q.push(pnode->pright); 有什么区别 我的做法是为了队列而队列  你的代码就伟大光正唯一正确? 人为何能如此自大呢 还水平特别低[/quote] 学习啦 俺错了 学习到东西不寒掺

user: user-2
content: 引用 24 楼 lin5161678 的回复:[quote=引用 20 楼 user-2 的回复:]                if (node->left) q.push(node->left);                 if (node->right) q.push(node->right); 请问这段代码 和 我做的      if(pnode->pleft != NULL)         q.push(pnode->pleft);     if(pnode->pright != NULL)         q.push(pnode->pright); 有什么区别 我的做法是为了队列而队列  你的代码就伟大光正唯一正确? 人为何能如此自大呢 还水平特别低[/quote] c语言就大一学过以后，没怎麽用过，我还以为你的queue是一个容量为1，就是递归顺序输出的1 2 3 4  5 6 7 8，  我一般用java和python，是我想的很局限了，当时我想的只是 return fun（） + fun（） 这种递归，它自己本身就是深度优先，所以觉得bfs应该不行，但是如果在里面维护一个队列就又可以bfs了，挺神奇的，学习到了，em。

user: user-2
content: 引用 23 楼 lin5161678 的回复:[quote=引用 20 楼 user-2 的回复:] 二叉树的 左右存的孩子结点 你这算啥     arr[0].pleft = arr+1;     arr[0].pright = arr+2;     arr[1].pleft = arr+3;     arr[1].pright = arr+4;     arr[2].pleft = arr+5;     arr[2].pright = arr+6; 你看不出这是存了左右节点?? arr[0].pleft = arr+1; 看不懂? 这个等于 arr[0].pleft = &arr[1]; 能理解吗  arr[0].pleft 左节点是一个结构体指针  我用数组元素的地址给这个节点赋值  所以节点0的左子节点是节点1 能看懂吗 你是不是没学过指针??  [/quote] 嗯 学习到了 指针忘了 你这麽讲就明白了

user: user-2
content: 引用 22 楼 lin5161678 的回复:[quote=引用 21 楼 user-2 的回复:] 一般 书上都是对的吧，循环不能转化为递归的，举个极端的例子 ，比如   while True:     print(0)      def dg():     print("0")     dg() dg() 我用while True可以无限打印 0  但是 递归会爆栈请百度一下尾递归[/quote] 那尾递归无限输出可以不爆栈吗？

user: user-1
content: 引用 15 楼 user-2 的回复:一本书上说的，我说了也不算，书上原话是： 所有递归都可以转化为循环  并没有所有循环可以转化为递归这句话，但是我觉得应该是这样，循坏可以无限复杂，递归不一样，一个正向，一个逆向，个人观点，递归人脑算起来复杂度很高死读书?? 关于是不是 全部循环都能改为递归 我也不多说什么了 就举例一个Haskell语言 知道你不会 但你总听说过吧?? 这个语言 没有循环  需要用到循环的操作 这里全部得用递归处理  你体会一下

user: user-1
content: 引用 16 楼 user-2 的回复:你这段程序解决是什么问题，在哪里体现的是广度优先，你把数组换成二叉树，用队列去维护里面的结点还差不多，一层一层递归出来，这个不借助一些其它标识应该做不到，而且这为了用队列用队列，这个也说不上来是什么吧，进去了就出来了，到这儿吧，争论也没啥意义， 哪里体现的是广度优先 我好奇这段代码 怎么就不是广度优先了?? 二叉树是  广度优先遍历输出 1234567 有什么不对 你是不是没写过广度优先遍历的代码? 导致你根本认不出来 ================================ 数组换成二叉树     arr[0].pleft = arr+1;     arr[0].pright = arr+2;     arr[1].pleft = arr+3;     arr[1].pright = arr+4;     arr[2].pleft = arr+5;     arr[2].pright = arr+6;这一段就是数组转换二叉树你看不懂吗 你是不是没学过二叉树? ================================ 为了用队列用队列 请你写一写广度优先的代码 然后你自己评价一下你的代码是不是 为了用队列用队列 ================================ 行吧 偷懒硬编码一个二叉树你看不懂 dfs建立一个二叉树可以了把 数组元素做二叉树节点不认识 new节点总认识了吧 请问 这段代码是不是递归的 广度优先的遍历了一个二叉树??  #include <iostream> #include <queue> using namespace std;   struct node {     int data;     node* pleft, *pright; };  node* dfs() { 	int n; 	scanf("%d", &n); 	if(n == 0) 		return NULL; 	node* pnode = new node; 	pnode->data = n; 	pnode->pleft = dfs(); 	pnode->pright = dfs(); 	return pnode;  }   void dfsfree(node* phead) { 	if(phead == NULL) 		return; 	dfsfree(phead->pleft); 	dfsfree(phead->pright); 	delete phead;  }   void recursion(queue<node*>& q) {     if(q.empty())     {         return;     }     node* pnode = q.front();     q.pop();     cout << pnode->data << endl;     if(pnode->pleft != NULL)         q.push(pnode->pleft);     if(pnode->pright != NULL)         q.push(pnode->pright);     recursion(q); }   void bfs(node* head) {     queue<node*> q;     q.push(head);     recursion(q); }   int main(int argc, char *argv[]) {     node* phead = dfs();     bfs(phead);     dfsfree(phead);     return 0; }

user: user-1
content: 引用 16 楼 user-2的回复:[quote=引用 14 楼 lin5161678 的回复:][quote=引用 11 楼 user-2 的回复:] 是所有递归都可以用循环实现  不是所有循环都可以递归的  先把这个搞清楚再说  看我上面的例子，看看还能不能明白，深度优先和广度优先的本质区别在数据结构上的表现就是一个是栈一个是队列， #include <iostream> #include <queue> using namespace std;  struct node { 	int data; 	node* pleft, *pright; };  void recursion(queue<node*>& q) { 	if(q.empty()) 	{ 		return; 	} 	node* pnode = q.front(); 	q.pop(); 	cout << pnode->data << endl; 	if(pnode->pleft != NULL) 		q.push(pnode->pleft); 	if(pnode->pright != NULL) 		q.push(pnode->pright); 	recursion(q); }  void bfs(node* head) { 	queue<node*> q; 	q.push(head); 	recursion(q); }  int main(int argc, char *argv[]) { 	node arr[7] = { 0 }; 	 	for(int i=0; i<7; ++i) 		arr[i].data = i+1; 		 	arr[0].pleft = arr+1; 	arr[0].pright = arr+2; 	arr[1].pleft = arr+3; 	arr[1].pright = arr+4; 	arr[2].pleft = arr+5; 	arr[2].pright = arr+6; 	bfs(arr); 	return 0; }  这不就是递归的广度优先么  还有你说  引用不是所有循环都可以递归的 请你写一个不能写为递归的循环 谢谢 我还真没遇到不能该为递归的循环 想学习一下[/quote] 你这段程序解决是什么问题，在哪里体现的是广度优先，你把数组换成二叉树，用队列去维护里面的结点还差不多，一层一层递归出来，这个不借助一些其它标识应该做不到，而且这为了用队列用队列，这个也说不上来是什么吧，进去了就出来了，到这儿吧，争论也没啥意义，[/quote] 你没看出这个数组就是二叉树??

user: user-2
content: 引用 14 楼 lin5161678 的回复:[quote=引用 11 楼 user-2 的回复:] 是所有递归都可以用循环实现  不是所有循环都可以递归的  先把这个搞清楚再说  看我上面的例子，看看还能不能明白，深度优先和广度优先的本质区别在数据结构上的表现就是一个是栈一个是队列， #include <iostream> #include <queue> using namespace std;  struct node { 	int data; 	node* pleft, *pright; };  void recursion(queue<node*>& q) { 	if(q.empty()) 	{ 		return; 	} 	node* pnode = q.front(); 	q.pop(); 	cout << pnode->data << endl; 	if(pnode->pleft != NULL) 		q.push(pnode->pleft); 	if(pnode->pright != NULL) 		q.push(pnode->pright); 	recursion(q); }  void bfs(node* head) { 	queue<node*> q; 	q.push(head); 	recursion(q); }  int main(int argc, char *argv[]) { 	node arr[7] = { 0 }; 	 	for(int i=0; i<7; ++i) 		arr[i].data = i+1; 		 	arr[0].pleft = arr+1; 	arr[0].pright = arr+2; 	arr[1].pleft = arr+3; 	arr[1].pright = arr+4; 	arr[2].pleft = arr+5; 	arr[2].pright = arr+6; 	bfs(arr); 	return 0; }  这不就是递归的广度优先么  还有你说  引用不是所有循环都可以递归的 请你写一个不能写为递归的循环 谢谢 我还真没遇到不能该为递归的循环 想学习一下[/quote] 你这段程序解决是什么问题，在哪里体现的是广度优先，你把数组换成二叉树，用队列去维护里面的结点还差不多，一层一层递归出来，这个不借助一些其它标识应该做不到，而且这为了用队列用队列，这个也说不上来是什么吧，进去了就出来了，到这儿吧，争论也没啥意义，

user: user-2
content: 引用 14 楼 lin5161678 的回复:[quote=引用 11 楼 user-2 的回复:] 是所有递归都可以用循环实现  不是所有循环都可以递归的  先把这个搞清楚再说  看我上面的例子，看看还能不能明白，深度优先和广度优先的本质区别在数据结构上的表现就是一个是栈一个是队列， #include <iostream> #include <queue> using namespace std;  struct node { 	int data; 	node* pleft, *pright; };  void recursion(queue<node*>& q) { 	if(q.empty()) 	{ 		return; 	} 	node* pnode = q.front(); 	q.pop(); 	cout << pnode->data << endl; 	if(pnode->pleft != NULL) 		q.push(pnode->pleft); 	if(pnode->pright != NULL) 		q.push(pnode->pright); 	recursion(q); }  void bfs(node* head) { 	queue<node*> q; 	q.push(head); 	recursion(q); }  int main(int argc, char *argv[]) { 	node arr[7] = { 0 }; 	 	for(int i=0; i<7; ++i) 		arr[i].data = i+1; 		 	arr[0].pleft = arr+1; 	arr[0].pright = arr+2; 	arr[1].pleft = arr+3; 	arr[1].pright = arr+4; 	arr[2].pleft = arr+5; 	arr[2].pright = arr+6; 	bfs(arr); 	return 0; }  这不就是递归的广度优先么  还有你说  引用不是所有循环都可以递归的 请你写一个不能写为递归的循环 谢谢 我还真没遇到不能该为递归的循环 想学习一下[/quote] 这个有什么实际意义吗，  引用 14 楼 lin5161678 的回复:[quote=引用 11 楼 user-2 的回复:] 是所有递归都可以用循环实现  不是所有循环都可以递归的  先把这个搞清楚再说  看我上面的例子，看看还能不能明白，深度优先和广度优先的本质区别在数据结构上的表现就是一个是栈一个是队列， #include <iostream> #include <queue> using namespace std;  struct node { 	int data; 	node* pleft, *pright; };  void recursion(queue<node*>& q) { 	if(q.empty()) 	{ 		return; 	} 	node* pnode = q.front(); 	q.pop(); 	cout << pnode->data << endl; 	if(pnode->pleft != NULL) 		q.push(pnode->pleft); 	if(pnode->pright != NULL) 		q.push(pnode->pright); 	recursion(q); }  void bfs(node* head) { 	queue<node*> q; 	q.push(head); 	recursion(q); }  int main(int argc, char *argv[]) { 	node arr[7] = { 0 }; 	 	for(int i=0; i<7; ++i) 		arr[i].data = i+1; 		 	arr[0].pleft = arr+1; 	arr[0].pright = arr+2; 	arr[1].pleft = arr+3; 	arr[1].pright = arr+4; 	arr[2].pleft = arr+5; 	arr[2].pright = arr+6; 	bfs(arr); 	return 0; }  这不就是递归的广度优先么  还有你说  引用不是所有循环都可以递归的 请你写一个不能写为递归的循环 谢谢 我还真没遇到不能该为递归的循环 想学习一下[/quote] 不是我说的 书上说的，书上的原话是： 所有的递归都可以转化为循环  引用 14 楼 lin5161678 的回复:[quote=引用 11 楼 user-2 的回复:] 是所有递归都可以用循环实现  不是所有循环都可以递归的  先把这个搞清楚再说  看我上面的例子，看看还能不能明白，深度优先和广度优先的本质区别在数据结构上的表现就是一个是栈一个是队列， #include <iostream> #include <queue> using namespace std;  struct node { 	int data; 	node* pleft, *pright; };  void recursion(queue<node*>& q) { 	if(q.empty()) 	{ 		return; 	} 	node* pnode = q.front(); 	q.pop(); 	cout << pnode->data << endl; 	if(pnode->pleft != NULL) 		q.push(pnode->pleft); 	if(pnode->pright != NULL) 		q.push(pnode->pright); 	recursion(q); }  void bfs(node* head) { 	queue<node*> q; 	q.push(head); 	recursion(q); }  int main(int argc, char *argv[]) { 	node arr[7] = { 0 }; 	 	for(int i=0; i<7; ++i) 		arr[i].data = i+1; 		 	arr[0].pleft = arr+1; 	arr[0].pright = arr+2; 	arr[1].pleft = arr+3; 	arr[1].pright = arr+4; 	arr[2].pleft = arr+5; 	arr[2].pright = arr+6; 	bfs(arr); 	return 0; }  这不就是递归的广度优先么  还有你说  引用不是所有循环都可以递归的 请你写一个不能写为递归的循环 谢谢 我还真没遇到不能该为递归的循环 想学习一下[/quote] 一本书上说的，我说了也不算，书上原话是： 所有递归都可以转化为循环  并没有所有循环可以转化为递归这句话，但是我觉得应该是这样，循坏可以无限复杂，递归不一样，一个正向，一个逆向，个人观点，递归人脑算起来复杂度很高

user: user-1
content: 引用 11 楼 user-2 的回复:是所有递归都可以用循环实现  不是所有循环都可以递归的  先把这个搞清楚再说  看我上面的例子，看看还能不能明白，深度优先和广度优先的本质区别在数据结构上的表现就是一个是栈一个是队列， #include <iostream> #include <queue> using namespace std;  struct node { 	int data; 	node* pleft, *pright; };  void recursion(queue<node*>& q) { 	if(q.empty()) 	{ 		return; 	} 	node* pnode = q.front(); 	q.pop(); 	cout << pnode->data << endl; 	if(pnode->pleft != NULL) 		q.push(pnode->pleft); 	if(pnode->pright != NULL) 		q.push(pnode->pright); 	recursion(q); }  void bfs(node* head) { 	queue<node*> q; 	q.push(head); 	recursion(q); }  int main(int argc, char *argv[]) { 	node arr[7] = { 0 }; 	 	for(int i=0; i<7; ++i) 		arr[i].data = i+1; 		 	arr[0].pleft = arr+1; 	arr[0].pright = arr+2; 	arr[1].pleft = arr+3; 	arr[1].pright = arr+4; 	arr[2].pleft = arr+5; 	arr[2].pright = arr+6; 	bfs(arr); 	return 0; }  这不就是递归的广度优先么  还有你说  引用不是所有循环都可以递归的 请你写一个不能写为递归的循环 谢谢 我还真没遇到不能该为递归的循环 想学习一下

user: user-1
content: 所有循环都能用递归实现 广度优先能用循环实现 所以广度优先必然可以用递归实现

user: user-1
content: 引用 6 楼 user-2的回复:引用 3 楼 lin5161678 的回复:当然可以 只是没必要 各个方面都不如直接循环    别误导人了，就是实现不了，程序的递归就是深度优先，只有遍历才能实现广度优先 所有循环都能用递归实现 认为不行是你见识少