Nisy 发表于 2010-12-17 11:08:55

无局部变量递归的实现设计

#include "stdio.h"

int * p = 0;
int * pp = 0;

/* 假设该参数通过寄存器传入 */

int add(int * p)
{                        
      printf("p = %X *p = %d \n",p,*p);
      getchar();
                              
      if( *p == 0 )
      {
                return 0;
      }
      else
      {
                pp = (int *)malloc(2);
                * pp = *p - 1;
                return *p + add(pp);
      }
}

main()
{
      p = (int *)malloc(2);
      *p = 10;
      printf("sum = %d ",add(p));               
}

Nisy 发表于 2010-12-17 11:16:35

原本是打算写成这样的

#include "stdio.h"

int i = 0;

int add(int a)
{

      i = a ;

      printf("i = %d \n", i);
      getchar();
                               
      if( i == 0 )
      {
                return i;
      }
      else
      {
                return i + add(i-1);
      }
}

main()
{
      printf("sum = %d ",add(10));               
}

C:\tc>test
i = 10

i = 9

i = 8

i = 7

i = 6

i = 5

i = 4

i = 3

i = 2

i = 1

i = 0

sum = 0


申请一个空间 解决不了该模块化设计的问题

Nisy 发表于 2010-12-17 11:29:41

有基础的可以尝试一下
说明：
1. 用递归实现求 1 ~ 10 的和
2. 递归函数原型 void add(){}
3. 递归函数内不可以使用局部变量

设计一种 解决递归函数 模块化编译时 传参和返回的情况


#include "stdio.h"

int * p = 0;
int * newp = 0;
int sum = 0;

void add()
{                        
      p = newp;

      printf("p = %4X *p = %d newp = %4X *newp = %d \n",p,*p,newp,*newp);
      getchar();
                              
      if( *p == 0 )
      {
                return;
      }
      else
      {
                sum += *p ;
               
                newp = (int *)malloc(2);
                * newp = *p - 1;
                add();
      }
}

main()
{
      newp = (int *)malloc(2);
      *newp = 10;
      add();
      printf("sum = %d ",sum);               
}

Nisy 发表于 2010-12-17 13:10:49

说明：
1. 用递归实现求汉诺塔的步骤
2. 递归函数原型 void move(){}
3. 递归函数内不可以使用局部变量


void move(int n,char a,char b,char c)
{
      if(n == 1)
      {
                printf("mov %c to %c \n",a,c);
                return;
      }
      move(n-1,a,c,b);
      printf("mov %c to %c \n",a,c);
      move(n-1,b,a,c);
}

void main()
{
      move(3,'a','b','c');
}

ngm20 发表于 2010-12-17 18:53:38

用全局变量实现汉诺塔。以n=4为例。用数组来保存函数调用过程中的参数（模拟堆栈作用，只能说是作用上）。代码很恶心/:017
程序缺陷：数组是定长的，如果n过大会产生错误！改进方法，可以用链表代替数组。。。
QQ群ID 初空如风

#include "stdio.h"
int n=4;
char a={'a','b','c',4};/*模拟堆栈，保存参数。这个240是随意定的，自己没去计算具体n=4时，需要多大的空间来存参数*/
int i=0;/*模拟sp的效果，虽然很不像- -*/
void move()
{
      if(n == 1)
      {
                printf("mov %c to %c \n",a,a);
                return;
      }
                n--;
                i+=4;
                a=a;a=a;a=a;a=(char)n;/*模拟向栈中压入4个参数*/
      move();      
                i-=4;/*模拟平衡栈*/
                n=(int)a;
      printf("mov %c to %c \n",a,a);
                n--;
                i+=4;
                a=a;a=a;a=a;a=(char)n;
      move();
      i-=4;
                n=(int)a;

}
int main()
{
move();
}

komany 发表于 2010-12-17 21:22:09

函数没有形参的情况下，利用指针传参，是最好的方法。N大的好思想学习了

cjteam 发表于 2010-12-18 12:27:41

:dizzy:交流的这么少的啊

Finder 发表于 2010-12-19 10:15:28

1-10的和汇编递归:
assume cs:code,ds:data
data segment
        dw 0,0,0,0,0;申请全局变量空间 n 和结果保存空间num
data ends
code segment
start:        mov ax,data
        mov ds,ax
       
        mov ax,10
        mov ds:,ax;n初始化
        xor ax,ax
        mov ds:,ax ;num初始化
       
        mov bx,0         变址初始化       
        call recu
               
        mov ax,4c00h
        int 21h
recu:       
        movdx,ds:
        movax,ds:    ;读取所需数据n->dx,num->ax
       
        cmp dx,0
        jzreturn         ;当递归n=0时返回
        add ax,dx            ;num+=n
        dec dx               ;n--
        mov ds:,dx       ;n值放回原来空间
        mov ds:,ax   ;num值放回原来空间
       
        call recu            ;递归调用
return:        ret
code ends
end start
,不知道对否!

whypro 发表于 2010-12-19 10:56:11

多多学习

zhuangd 发表于 2010-12-23 09:15:49

支持一下！！！！！！！！
页: [1]
查看完整版本: 无局部变量递归的实现设计