递归反转链表数组并不是按顺序反转所有节点
我有一个链表数组，我正试图递归地反转它。当我调用函数反转时，它不会反转所有节点，而是反转几个节点。
反向功能似乎是删除第一个节点（基本情况）并用最后一个节点（子情况的结尾）填充其位置。我认为问题在于在reverse_nodes函数中调用for循环，但这似乎无法解决问题。
下面是一些输出。。
pre-reverse function:
-----
group 0
alice, 2
-----
group 1
martin, 4
-----
group 2
keanu, 6
-----
group 3
miles, 8
post - reverse function
-----
group 0
miles, 8
-----
group 1
martin, 4
-----
group 2
keanu, 6
-----
group 3
miles, 8
我试着让它倒过来，它写着：8，6，4，2
请注意，我只包含了相关的代码块，如结构体系结构、头/尾结构、在读取二进制文件之前删除所有节点、将二进制文件读取到节点以及主功能。我能得到一些帮助，弄清楚是什么在反转功能中导致它不能完全反转吗？谢谢你抽出时间。请参阅下面的代码！
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct node
{
char name[20];
int size;
struct node *next;
}node;
node* head[4]={NULL,NULL,NULL,NULL};
node* tail[4]={NULL,NULL,NULL,NULL};
void wipe_nodes()
{
int i;
node *p=NULL;
for(i=4; i>0; i--)
{
p=head[i];
if(p == NULL)
{
printf("Nodes are clear!\n");
}
while(p != NULL)
{
delete_party(p->name, p->size); // cant call name and size
p = p -> next;
}
}
}
void bin_to_list(char *filename)
{
FILE *fp;
int ret;
fp = fopen(filename, "rb");
if (fp == NULL)
{
printf("Null file!\n");
return;
}
node temp;
//temp = (node *)malloc(sizeof(node));
while((ret = fread(&temp, sizeof(node), 1, fp) > 0))
{
printf("%s %d", temp.name, temp.size);
if(temp.size == 0)
{
printf("\nThat is not a valid command. Party not added!\n");
}
if(temp.size >= 1 && temp.size <= 2)
{
add_party(0, temp.name, temp.size);
}
else if(temp.size >= 3 && temp.size <= 4)
{
add_party(1, temp.name, temp.size);
}
else if(temp.size >= 5 && temp.size <= 6)
{
add_party(2, temp.name, temp.size);
}
else if(temp.size >= 7)
{
add_party(3, temp.name, temp.size);
}
}
fclose(fp);
return;
}
void reverse_nodes(node *p, node *q)
{
int i;
for(i=0; i<4; i++)
{
//node *p=head[i];
if(p == NULL)
{
printf("Error, no nodes!\n");
return;
}
if (p->next == NULL)
{
printf("LOL, only one node! Can't reverse!\n");
head[i] = p;
}
else
{
reverse_nodes(p->next, p);
}
p->next = q;
return;
int main(int argc, char *argv[])
{
int x, i;
read_to_list(argv[1]);
bin_to_list(argv[2]);
while (1)
{
fflush(stdin);
printf("\n\nEnter 1 to add a party\nEnter 2 to remove a party\nEnter 3 for the list of the party\nEnter 4 to change party size.\nEnter 5 to quit (write to .txt file).\nEnter 6 to read from bin file.\nEnter 7 to reverse the list.\n\n");
scanf("%d",&x);
char name[20];
int size;
switch(x)
{
case 1:
printf("\nParty Name: ");
scanf("%s", name);
printf("\nParty Size: ");
scanf("%d", &size);
if(size == 0)
{
printf("\nThat is not a valid command. Party not added!\n");
}
if(size >= 1 && size <= 2)
{
add_party(0, name, size);
}
else if(size >= 3 && size <= 4)
{
add_party(1, name, size);
}
else if(size >= 5 && size <= 6)
{
add_party(2, name, size);
}
else if(size >= 7)
{
add_party(3, name, size);
}
break;
case 2:
printf("\nSize of party to delete: ");
scanf("%i", &size);
delete_party(NULL, size);
break;
case 3:
list_parties();
break;
case 4:
change_partysize(name, size);
break;
case 5:
write_to_file(argv[1]);
write_to_bin(argv[2]);
exit(0);
break;
case 6:
wipe_nodes();
bin_to_list(argv[2]);
break;
case 7:
for(i=0; i<4; i++)
{
reverse_nodes(head[i], NULL);
}
break;
default:
continue;
}
}
}
共有2个答案
您的reverse\u nodes函数只是设置节点的下一个成员，而不是当前节点，因此当它到达列表末尾时，它会将最后一个成员的下一个设置为链接列表中的上一个成员，但保持最后一个成员不变。
这对我很有用：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct node
{
char name[20];
int size;
struct node *next;
}node;
node* head;
void reverse_nodes(node ** pphead)
{
node *prev = NULL;
node *current = *pphead;
node *next;
while (current != NULL)
{
next = current->next;
current->next = prev;
prev = current;
current = next;
}
*pphead = prev;
}
void main(void)
{
int i;
node * phead;
head = phead = (node *)malloc(sizeof(node));
phead->size = 0;
for (i = 0; i < 4; i++)
{
node * p;
phead->next = (node *)malloc(sizeof(node));
phead = phead->next;
phead->size = i + 1;
phead->next = NULL;
}
reverse_nodes(&head);
phead = head;
while (phead)
{
printf("%d\r\n", phead->size);
phead = phead->next;
}
}
编辑：
递归通常是个坏主意，因为你最终可能会搞砸堆栈——如果可能的话，最好尝试在一个（或者多个）函数中做你需要做的事情，在这种情况下这是很容易做到的。
#include<stdio.h>
#include<stdlib.h>
/* Link list node */
struct Node
{
int data;
struct Node* next;
};
/* Function to reverse the linked list */
static void reverse(struct Node** head_ref)
{
struct Node* prev = NULL;
struct Node* current = *head_ref;
struct Node* next;
while (current != NULL)
{
next = current->next;
current->next = prev;
prev = current;
current = next;
}
*head_ref = prev;
}
/* Function to push a node */
void push(struct Node** head_ref, int new_data)
{
/* allocate node */
struct Node* new_node =
(struct Node*) malloc(sizeof(struct Node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Function to print linked list */
void printList(struct Node *head)
{
struct Node *temp = head;
while(temp != NULL)
{
printf("%d ", temp->data);
temp = temp->next;
}
}
/* Driver program to test above function*/
int main()
{
/* Start with the empty list */
struct Node* head = NULL;
push(&head, 20);
push(&head, 4);
push(&head, 15);
push(&head, 85);
printf("Given linked list\n");
printList(head);
reverse(&head);
printf("\nReversed Linked list \n");
printList(head);
getchar();
}
-
我做了一个使用递归方法反转单链表的函数。然而，我在执行下面的代码时遇到了一些困难： 我应该如何在ReverseCursive函数/方法中传递第二个参数，以便执行它？ 作为第二个参数，我想简单地传递链表的头节点。但是我不知道如何从类的init方法中获取头节点linked_list 我试了几件事，但都解决不了。也许我不太擅长OOP概念。有人能帮我解决这个问题吗？
-
问题内容： 我还没有找到满足我的功能特定需求的任何东西，是的，这是用于家庭作业。 所以我有： 前提条件：x.length> 0 我不能让函数返回任何东西，而唯一的参数是数组这一事实使我感到困惑。 我已经尝试过将循环与递归一起使用，但是我尝试过的一切似乎都以生成函数的无限实例结束。 我已经有了一个想法/建议与该函数一起使用另一个函数，但是，当前如何递归地使用原始函数超出了我的范围。 任何帮助表示赞赏
-
问题内容： 我已经在一个类的Java项目上工作了一段时间。它是链表（此处称为，包含称为的简单节点）的实现。问题是，一切都必须使用递归算法来完成。我可以用一种方法来做所有的事情： 现在，我的函数只是调用一个带有参数以允许递归的辅助函数。 我的助手功能具有的签名。 目前，我使用堆栈来迭代工作，但这不是规范所要求的。我在C语言中找到了一种算法，该算法可以递归地将其递归逆转并将其转换为Java代码，并且可
-
请检查下面的反转功能。剩下的代码应该没问题。由于某种原因，该函数没有反转双链接列表。 双链表节点结构 双链表结构 按从头部到尾部的顺序排列。 请检查下面的反向函数，因为此函数不会返回反向双链接列表。检查是否有任何错误并让我知道。
-
本文向大家介绍单链表反转 递归法Java实现相关面试题，主要包含被问及单链表反转 递归法Java实现时的应答技巧和注意事项，需要的朋友参考一下 经历了很多面试，面试官最爱考察的算法无非是斐波那契数列和单链表反转，尽管是这些都是基础知识，然而我对单链表反转有更多的想法。 递归法是我早期最爱在面试中使用的算法，很有逼格，写起来非常优雅，非常好理解。 先定义链表数据结构 如上代码所示 递归法会逐层确定该
-
我刚刚开始学习递归，并能够使用它编写一个简单的阶乘程序，没有太多问题。现在我正在尝试编写一个递归方法，该方法以相反的顺序写入数组，但我不知道我做错了什么。我错过了什么？非常感谢。