栈改递归

原创 2006年06月08日 16:33:00

 

       这个问题,距今有3年多了。不过我自己早就忘了,以前的工程也找不到了。只好自己重新新写。本以为是个很容易的问题。实际上却花了3个多小时。
先把代码贴出来,以后腾出时间再写总结。
/*-------------------------------------------------------------------
       http://topic.csdn.net/t/20030118/19/1372004.html
       算法问题(栈改递归其它非递归方法也可!!)
       liuxk99 (极地狐)     2003-01-18 19:32:13 在 C/C++ / C语言 提问
       非递归算法实现一个函数.
              f = n; (m <= 1)
              f = m; (n <= 1)  
              f = f(m - 1, n) + f(m, n - 1); (m > 1, n > 1)
-------------------------------------------------------------------*/
#include "stdio.h"
#include "string.h"
 
#include "windows.h"
 
#define TRUE      1
#define FALSE    0
#define STACK_SIZE 1000
 
typedef struct _st{
       int m;
       int n;
       int bLeft;
       int bRight;
       int fpos; // 父节点
}st;
 
int f(int m, int n)
{
       if (m <= 1)
              return n;
       else if (n <= 1)
              return m;
       else
              return f(m - 1, n) + f(m, n - 1);
}
 
int fs(int m, int n)
{
       int res = 0;
       st stk[STACK_SIZE];
       int pos = 0, x, y, lspos;
       memset (&stk, 0, sizeof(stk));
       stk[pos].m = m;
       stk[pos].n = n;
       stk[pos].bLeft = FALSE;
       stk[pos].bRight = FALSE;
       lspos = pos;
 
       while (1)
       {
              if (stk[0].bLeft && stk[0].bRight)
                     break;
 
              printf(("/r/nstack :"));
              for (int i = 0; i <= pos; i++)
              {
                     printf (" (%d, %d)", stk[i].m, stk[i].n);
              }
              // get stack top
              x = stk[pos].m;
              y = stk[pos].n;
 
              if (x <= 1)
              {
                     lspos = stk[pos].fpos;
                     res += y;
                     stk[lspos].bLeft = TRUE;
                     printf ("/r/n%02d.Pop(%d, %d)", pos, stk[pos].m, stk[pos].n);
                     --pos; // pop stack
                     //printf(("/r/nfs(%d, %d) = %d", x, y, res);
              }
              else if (y <= 1)
              {
                     lspos = stk[pos].fpos;
                     res += x;
                     stk[lspos].bRight = TRUE;
                     printf ("/r/n%02d.Pop(%d, %d)", pos, stk[pos].m, stk[pos].n);
                     --pos; // pop stack
              }
              else
              {
                     // pop stack
                     if (stk[pos].bLeft && stk[pos].bRight)
                     {
                            lspos = stk[pos].fpos;
                            if (pos - lspos == 1) // 分支判断
                                   stk[lspos].bLeft = TRUE;
                            else
                                   stk[lspos].bRight = TRUE;
                            printf ("/r/n%02d.Pop(%d, %d)", pos, stk[pos].m, stk[pos].n);
                            --pos;
                     }
                     else
                     {
                            lspos = pos;
                            // push stack
                            printf ("/r/n%02d.Push(%d, %d)", pos, x - 1, y);
                            ++pos;
                            stk[pos].m = x - 1;
                            stk[pos].n = y;
                            stk[pos].bLeft = FALSE;
                            stk[pos].bRight = FALSE;
                            stk[pos].fpos = lspos;
 
                            printf ("/r/n%02d.Push(%d, %d)", pos, x, y - 1);
                            ++pos;
                            stk[pos].m = x;
                            stk[pos].n = y - 1;
                            stk[pos].bLeft = FALSE;
                            stk[pos].bRight = FALSE;
                            stk[pos].fpos = lspos;
                     }
              }
       }
 
       return res;
}
 
int main(int argc, char* argv[])
{
       int m = 5, n = 4, res = 0;
 
       DWORD tc1, tc2;
       tc1 = GetTickCount ();
       res = f(m, n);
       tc2 = GetTickCount ();
       printf ("%d : f(%d, %d) = %d/r/n", tc2 - tc1, m, n, res);
 
       tc1 = GetTickCount ();
       res = fs(m, n);
       tc2 = GetTickCount ();
       printf ("%d : f(%d, %d) = %d/r/n", tc2 - tc1, m, n, res);
 
       return 0;
}
 

Python-递归

​是指函数/过程/子程序在运行过程序中直接或间接调用自身而产生的重入现象。 在计算机编程里,递归指的是一个过程:函数不断引用自身,直到引用的对象已知。
  • 2017年08月21日 14:22

递归程序用栈改写为非递归

  • 2010年11月14日 14:15
  • 3KB
  • 下载

算法 递归和循环的转换

【直接转化 】 消除尾递归和单向递归 1. 尾递归 指在递归算法中递归调用语句只有一个 且处于算法的最后private static int factoria...
  • Thousa_Ho
  • Thousa_Ho
  • 2017-08-23 15:31:45
  • 307

数据结构(20)栈与递归

导言 递归 n阶Hanoi塔问题 算法 解析 汉诺塔3阶过程演示导言前面阶段用栈实现了表达式求值、括号匹配以及数字转换。这一次,我们介绍栈的另一个重要级别的应用-递归递归栈的重要应用是在程序设计语言中...
  • YuYunTan
  • YuYunTan
  • 2016-04-09 22:57:20
  • 3333

栈、递归、循环的关系

栈和递归其实原理都是差不多的,栈是先进后出,递归也是先进后出,递归也是利用堆栈来实现的,然后循环可以模拟代替栈和递归,只是用循环太复杂。但是它们的变量存储方式不同,导致占的空间不同。首先说明一下栈和堆...
  • qq_18297675
  • qq_18297675
  • 2017-01-31 15:22:28
  • 1819

Java将递归改成循环的通用方法

用Stack或LinkedList来实现内存中的出栈入栈过程,即可将递归改成循环。 第一个例子用求阶乘,顺便加了迭代方法。 import java.util.Stack; public class...
  • kinglearnjava
  • kinglearnjava
  • 2015-01-19 11:29:24
  • 3664

栈结构 和 递归 的关系

栈结构 和 递归 的关系
  • qq_36016407
  • qq_36016407
  • 2017-02-15 14:47:22
  • 1128

数据结构复习篇:用栈实现递归

也许大家会疑问:复习完栈应该到队列了吧。我开始也是这样想的,但用栈实现递归,是一个难点。说实话,我以前学习的时候,就在这一处卡住了,当时我烦躁了好几天,但可能由于突然被什么东西转移了注意力,所以就这样...
  • chinainvent
  • chinainvent
  • 2006-10-02 16:17:00
  • 11750

C++ 手工栈 解决递归次数太多爆栈的问题

首先我们有一个搜索的题目,源程序如下#include using namespace std; int a[1001][1001],dx[4],dy[4]; bool f[1001][1001],up...
  • Nidhogg__
  • Nidhogg__
  • 2016-09-10 15:54:56
  • 1058

使用栈模拟递归的算法

这一篇笔者要讲的是如何用栈来模拟递归,或者说替代递归的算法,现在我们假如要算从三角形数的叠加,比如输入10 ,输出是55,输入是100 ,输出是5050,等等。 首先,我们建一个栈: public...
  • hasser1
  • hasser1
  • 2015-08-27 22:34:23
  • 1360
收藏助手
不良信息举报
您举报文章:栈改递归
举报原因:
原因补充:

(最多只允许输入30个字)