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

Nisy

#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

原本是打算写成这样的

#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

有基础的可以尝试一下
说明：
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

说明：
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

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

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

}
int main()
{
  move();
}

komany

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

cjteam

:dizzy:交流的这么少的啊

Finder

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

whypro

多多学习

zhuangd

支持一下！！！！！！！！