C递归到迭代

2023年2月13日 255次阅读

下午好,我希望有人能帮助我看看我错过了什么.我承认这是一项家庭作业,但我们可以在代码上进行协作,所以希望有人在这里不介意帮忙.

对于这个程序,我需要使用递归和迭代在C中旋转一组三个项目.我的递归案例没有问题,但迭代版本给了我很多麻烦.我尝试的所有东西要么是段错误,要么是无限打印.这是代码,再次感谢任何帮助：

template<typename A, typename B, typename C>
class Triple{
public:
    A first;
    B second;
    C third;

Triple(A a, B b, C c){ first = a; second = b; third = c;}

A fst(){return first;}
B snd(){return second;}
C thd(){return third;}

// The function change1(), changes the first component of a triple. 
void change1(A a){ first = a;}
};

// A linked list of triples where the order of the triple rotates as it goes.
template<typename A, typename B, typename C>
class RotateList{ 
public:
    Triple<A,B,C> *t;
    RotateList<B,C,A> * next; // Notice the order has changed

    RotateList(Triple<A,B,C> *t1, RotateList<B,C,A> * n1){ this->t = t1; this->next = n1;}

/*
 * Implement with recursion, creating i triples, each with the order rotated from the
 * previous.
 */
static RotateList<A,B,C> * create(A a, B b, C c, int i){
if (i <= 0) return nullptr;
Triple<A,B,C> * t = new Triple<A,B,C>(a,b,c);
RotateList<B,C,A> * n = RotateList<B,C,A>::create(b,c,a, i-1); 

return new RotateList<A,B,C>(t, n);
}

/*
 * Implement with iteration, using the same instance of the same three triples
 * over and over.
 */
static RotateList<A,B,C> * create2(A a, B b, C c, int i){
}

/* Print the whole rotating list. */ 
void print(){
cout << "{" << t->fst() << " "<< t->snd() << " "<< t->thd() << "}";
if (next != nullptr) 
    next->print();
else 
    cout << endl;
}
};


int main(){
float f = 3.14;
int i = 3;
char c = 'c';

Triple<float,int,char> t = Triple<float,int,char>(f,i,c);
Triple<float,int,char> t1 = t;
cout << "Starting triple: [" << t.fst() << " "<< t.snd() << " "<< t.thd() << "]" << endl;

cout << endl << "Rotating list created recursively" << endl;
RotateList<float,int,char> * r= RotateList<float,int,char>::create(f,i,c, 10);
r->print();

r->t->change1(42.42);
r->print();

cout << endl << "Rotating list created iteratively" << endl;
RotateList<float,int,char> * s= RotateList<float,int,char>::create2(f,i,c, 10);
s->print();

s->t->change1(42.42);
s->print();

s->next->t->change1(501);
s->print();
}

我到目前为止的尝试：

static RotateList<A,B,C> * create2(A a, B b, C c, int i) {
    RotateList<C,A,B> *l1 = new RotateList<A,B,C>(new Triple<A,B,C>, nullptr);
    RotateList<B,C,A> *l2;
    RotateList<C,A,B> *l3;        
    RotateList<A,B,C> *tmp1 = l1;
    RotateList<B,C,A> *tmp2;
    RotateList<C,A,B> *tmp3;

    int nextTriple = 2;
    for (i; i > 0; i--) {
        tmp3->next = l1;
        tmp1 = tmp3->next;
        nextTriple = 2;
    } else if {
        temp1->mext = l2;
        tmp2 = tmp1->next;
        nextTriple = 3;
    } else {
        tmp2->next = l3;
        tmp3 = tmp2->next;
        nextTriple = 1;
    }
}
return l1;
}

最佳答案 我将从概述开始,并通过示例进行操作.如果您需要更具体的作业,请添加评论,但只有在您仔细考虑了这个答案之后.

概观

将递归转换为迭代有两种通用方法.一种是重写递归函数以使用tail call(即在递归调用之后不再进行进一步处理;一些编译器,包括一些C++ compilers,可以优化尾调用,产生与交互版本无法区分的目标代码).另一个(例如迭代Tower of Hanoi解决方案)是使用您自己的堆栈基本上跟踪帧.幸运的是,通过尾部调用重写可以解决分配问题.

例

所有代码未经测试且可能包含错误&错误.

对于比分配的更简单的示例,考虑函数范围(a,b),其产生从(包括)到b(不包括)的整数列表.递归：

List<int>* range(int a, int b) {
    if (a >= b) {
       // base case
       return new List<int>();
    }
    // recursive case
    return List<int>::cons(a, range(a+1, b));
}

要将其转换为尾调用,通常会添加一个(或多个)变量来累积计算中的值,并具有用于递归和初始化的单独函数：

List<int>* range_recur (int a, int b, List<int>* xs) {
    if (b < a) {
        // base case
        return xs;
    }
    // recursive case
    return range_recur(a, b-1, List<int>::cons(b, xs));
}

List<int>* range(int a, int b) {
    return range_recur(a, b-1, new List<int>());
}

注意,还需要进行一些其他更改,主要是如何处理边界,以便可以在递归调用之前将cons操作移动到.

基本情况对应于循环条件,但它是何时退出循环.因此,让我们通过否定测试并交换两种情况来重写range_recur()以更接近迭代版本.

List<int>* range_recur (int a, int b, List<int>* xs) {
    // recursive case test
    if (b >= a) {
        // recursive case
        return range_recur(a, b-1, List<int>::cons(b, xs));
    }
    // base case
    return xs;
}

转换为迭代版本相当简单：不是递归地传递每个变量,而是分配它们(如果值是相互依赖的,可能使用临时版本). if条件成为循环条件.初始化函数体在循环之前,基本情况之后.

List<int>* range (int a, int b) {
    // range():
    List<int> *xs = new List<int>();
    b = b - 1;
    // range_recur():
    // recursive case test:
    while (b >= a) {
        // recursive case
        xs = List<int>::cons(b, xs);
        b = b - 1;
    }
    // base case
    return xs;
}

然后你可能会进行一次清理重写,使用更多的惯用操作(递减和一个for循环;练习留给读者).

无关

作业可能没有提到内存管理,但它是一个重要的主题.样本类像渔网一样泄漏(使用带有临时值的RotateList会遇到麻烦),这大部分都不会成为问题,因为这个过程不会长到足以让它成为一个.但是,如果这些类在另一个程序中使用,则可能会出现问题.目前,生产中的最佳实践是使用某种类型的smart pointers来管理对象.对于某些作业(特别是那些你已经掌握的作业),自己照顾记忆管理是一个很好的练习.

点赞