我还在努力解决问题的递归技术。我知道有更好的方法可以解决我的问题，如下面的逆转链表。我所看到的大部分方法都是通过使用迭代或递归来开始从头部到尾部反转指针。
我试图通过首先以递归方式查找列表中的最后一个节点然后每次函数返回时更改指针来反转列表。
我到底做错了什么？或者这个方法是否可以工作，而不需要将更多参数传递给递归函数？在此先感谢您的帮助。
struct Node
{
int data;
struct Node *next;
};
Node* Reverse(Node *head)
{
static Node* firstNode = head;
// if no list return head
if (head == NULL)
{
return head;
}
Node* prev = NULL;
Node* cur = head;
// reached last node in the list, return head
if (cur->next == NULL)
{
head = cur;
return head;
}
prev = cur;
cur = cur->next;
Reverse(cur)->next = prev;
if (cur == firstNode)
{
cur->next = NULL;
return head;
}
return cur;
}
编辑：另一次尝试
Node* ReverseFromTail(Node* prev, Node* cur, Node** head);
Node* ReverseInit(Node** head)
{
Node* newHead = ReverseFromTail(*head, *head, head);
return newHead;
}
Node* ReverseFromTail(Node* prev, Node* cur, Node** head)
{
static int counter = 0;
counter++;
// If not a valid list, return head
if (head == NULL)
{
return *head;
}
// Reached end of list, start reversing pointers
if (cur->next == NULL)
{
*head = cur;
return cur;
}
Node* retNode = ReverseFromTail(cur, cur->next, head);
retNode->next = cur;
// Just to force termination of recursion when it should. Not a permanent solution
if (counter == 3)
{
cur->next = NULL;
return *head;
}
return retNode;
}
最后解决了它：
Node* NewestReverseInit(Node* head)
{
// Invalid List, return
if (!head)
{
return head;
}
Node* headNode = NewestReverse(head, head, &head);
return headNode;
}
Node* NewestReverse(Node *cur, Node* prev, Node** head)
{
// reached last node in the list, set new head and return
if (cur->next == NULL)
{
*head = cur;
return cur;
}
NewestReverse(cur->next, cur, head)->next = cur;
// Returned to the first node where cur = prev from initial call
if (cur == prev)
{
cur->next = NULL;
return *head;
}
return cur;
}
答案 0 :(得分：3)
我不会给你代码，我会给你这个想法。您可以在代码中实现这个想法。
所有递归问题的关键是找出两种情况：重复步骤和结束情况。一旦你这样做，它几乎就像神奇地一样。
应用此原则来反转链表：
head），而不是将头部添加为列表的最后一个元素。返回值将与您刚刚进行的递归调用的返回值相同。答案 1 :(得分：2)
可以做到。理解递归的关键是起点是什么？
通常我会创建一个＆＃34;启动＆＃34; 函数来准备第一个调用。有时它是一个单独的函数（就像在底部的非OO实现）。有时它只是一个特殊的第一个电话（如下面的例子）。
关键是在变量变化之前记住变量以及new head是什么。
新head是列表的最后一个元素。所以你必须从列表的底部开始。
next元素始终是您的父级。
然后诀窍是以正确的顺序完成所有事情。
Node* Reverse( Node* parent) // Member function of Node.
{
Node* new_head = next ? next->Reverse( this )
: this;
next = parent;
return new_head;
}
您可以使用：var.Reverse( nullptr);
示例：
int main()
{
Node d{ 4, nullptr };
Node c{ 3, &d };
Node b{ 2, &c };
Node a{ 1, &b };
Node* reversed = a.Reverse( nullptr );
}
那么这里发生了什么？
首先我们创建一个链表：
a->b->c->d->nullptr
然后函数调用：
a.Reverse(nullptr)被召唤。Reverse调用下一个节点b.Reverse上的a。Reverse调用下一个节点c.Reverse上的b。Reverse调用下一个节点d.Reverse上的c。d没有next节点，因此它表示新头部本身。d＆＃39; next现在是它的父c d将自己作为new_head。c：从new_head返回的d为d c＆＃39; next现在是它的父b c返回从new_head d
b：从new_head返回的c为d b＆＃39; next现在是它的父a b返回从new_head c
a：从new_head返回的b为d a＆＃39; next现在是它的父nullptr a返回从new_head b
d已退回非面向对象的实现;
Node* reverse_impl(Node* parent)
{
Node* curr = parent->next;
Node* next = curr->next;
Node* new_head = next ? reverse_impl( curr )
: curr;
curr->next = parent;
return new_head;
}
Node* reverse(Node* start)
{
if ( !start )
return nullptr;
Node* new_head = reverse_impl( start );
start->next = nullptr;
return new_head;
}
答案 2 :(得分：0)
这是我在5分钟内写完的完整实现：
python script输出：
#include <stdio.h>
struct Node
{
int data;
struct Node *next;
};
struct Node* Reverse(struct Node *n)
{
static struct Node *first = NULL;
if(first == NULL)
first = n;
// reached last node in the list
if (n->next == NULL)
return n;
Reverse(n->next)->next = n;
if(n == first)
{
n->next = NULL;
first = NULL;
}
return n;
}
void linked_list_walk(struct Node* n)
{
printf("%d", n->data);
if(n->next)
linked_list_walk(n->next);
else
printf("\n");
}
int main()
{
struct Node n[10];
int i;
for(i=0;i<10;i++)
{
n[i].data = i;
n[i].next = n + i + 1;
}
n[9].next = NULL;
linked_list_walk(n);
Reverse(n);
linked_list_walk(n+9);
}