使用递归删除给定数的倍数的节点[C编程]

我在尝试实现一个函数时遇到了问题，这是程序应该做的： 用户必须首先输入一个整数（该数字不会添加到列表中）。 然后，我必须编写一个函数，递归删除列表中的所有节点，这些节点是输入数的倍数

这是我当前的代码：

#include <stdio.h>
#include <stdlib.h>

#define true 1 
#define false 0
#define bool int

typedef struct node {
    int data;
    struct node *next; 

} Node;

void addToHead(Node **head, int value);
void printList(Node *head);
bool isMultipleOf(int value, int n);
void deleteMultipleOfNNodes(Node **head, int n);


int main() {
    // Create head 
    Node *head = NULL;

    int loop = true;
    int input;

    // The value whose multiples must be deleted from the list
    int n;
    scanf("%d", &n);

    while (loop) {
        scanf("%d", &input);

        // End loop - print list
        if (input < 0) {
            deleteMultipleOfNNodes(&head, n);
            printList(head);
            loop = false;
        } else {
        // Add value to the head
            addToHead(&head, input);
        }

    }
    return 0;
}


void addToHead(Node **head, int value) {
    Node *temp;

    if (*head != NULL) { 
        // Create new node
        Node *newNode = (Node*) malloc(sizeof(Node));
        // Set new node data
        newNode -> data = value;
        // New node links to the head
        newNode -> next = *head;
        // New node is now the head of the list
        *head = newNode;

    } else {
        // Create head
        *head = (Node*) malloc(sizeof(Node));
        // Set head data
        (*head) -> data = value;
        // Head links to NULL
        (*head) -> next = NULL;

    }
}

void printList(Node *head) {
    Node *temp = head;
    while (temp != NULL) {
        if (temp -> next != NULL) {
            printf("%d -> ", temp->data);
        } else {
            printf("%d -> NULL", temp -> data);
        }
        temp = temp->next; 
    }

}

bool isMultipleOf(int value, int n) {
    // While the value is greater than zero, keep on subtracting the number
    while (value > 0) { 
        value -= n; 
    }

    return (value == 0);

}

void deleteMultipleOfNNodes(Node **head, int n) {
     // ========= CODE ================
}

#包括
#包括
#定义真1
#定义false 0
#定义布尔整数
类型定义结构节点{
int数据；
结构节点*下一步；
}节点；
void addToHead（节点**head，int值）；
作废打印列表（节点*头）；
bool-isMultipleOf（int-value，int-n）；
void deleteMultipleOfNNodes（节点**头，int n）；
int main（）{
//制造头部
Node*head=NULL；
int循环=真；
int输入；
//必须从列表中删除其倍数的值
int n；
scanf（“%d”和“&n”）；
while（循环）{
scanf（“%d”，输入（&I））；
//结束循环-打印列表
如果（输入<0）{
删除多个节点（&head，n）；
印刷品清单（标题）；
循环=假；
}否则{
//为头部增值
addToHead（&head，输入）；
}
}
返回0；
}
void addToHead（节点**head，int值）{
节点*温度；
如果（*head！=NULL）{
//创建新节点
Node*newNode=（Node*）malloc（sizeof（Node））；
//设置新节点数据
新建节点->数据=值；
//新节点链接到头部
新建节点->下一步=*头部；
//新节点现在是列表的头
*头=新节点；
}否则{
//制造头部
*头=（节点*）malloc（节点大小）；
//设定水头数据
（*头部）->数据=数值；
//头链接为空
（*head）->next=NULL；
}
}
无效打印列表（节点*头）{
节点*温度=头部；
while（temp！=NULL）{
如果（临时->下一步！=NULL）{
printf（“%d->”，临时->数据）；
}否则{
printf（“%d->NULL”，临时->数据）；
}
温度=温度->下一步；
}
}
布尔isMultipleOf（int值，int n）{
//当值大于零时，继续减去该数字
而（值>0）{
值-=n；
}
返回值（值==0）；
}
void deleteMultipleOfNNodes（节点**head，int n）{
//==========代码================
}

---

提前感谢您的帮助

该函数看起来非常简单

void deleteMultipleOfNNodes( Node **head, int n )
{
    Node *tmp = *head;

    if ( tmp != NULL )
    {
        tmp->data % n == 0 ? ( *head ) = ( *head )->next, free( tmp ) 
                           : ( void )(  head = &( *head )->next );
        deleteMultipleOfNNodes( head, n );
    }
}

注意这个功能

bool isMultipleOf(int value, int n) {
    // While the value is greater than zero, keep on subtracting the number
    while (value > 0) { 
        value -= n; 
    }

    return (value == 0);

}

在一般情况下无效，因为值或n可以为负数

所以定义函数如下

bool isMultipleOf( int value, int n ) 
{
    return value % n == 0;
}

在这种情况下，可以像这样重写上面的函数

void deleteMultipleOfNNodes( Node **head, int n )
{
    Node *tmp = *head;

    if ( tmp != NULL )
    {
        isMultipleOf( tmp->data, n ) ? ( *head ) = ( *head )->next, free( tmp ) 
                                     : ( void )(  head = &( *head )->next );
        deleteMultipleOfNNodes( head, n );
    }
}

函数

addToHead

太复杂了。它可以用下面的方式写

bool addToHead(Node **head, int value) 
{
    Node *newNode = malloc( sizeof( Node ) );
    bool success = newNode != NULL;

    if ( success )
    {
        newNode -> data = value;
        newNode -> next = *head;
        *head = newNode;
    }

    return success;
}

这是一个演示程序。它只包含演示递归函数所需的函数

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct node {
    int data;
    struct node *next; 

} Node;

bool addToHead(Node **head, int value) 
{
    Node *newNode = malloc( sizeof( Node ) );
    bool success = newNode != NULL;

    if ( success )
    {
        newNode -> data = value;
        newNode -> next = *head;
        *head = newNode;
    }

    return success;
}

bool isMultipleOf( int value, int n ) 
{
    return value % n == 0;
}

void deleteMultipleOfNNodes( Node **head, int n )
{
    Node *tmp = *head;

    if ( tmp != NULL )
    {
        isMultipleOf( tmp->data, n ) ? ( *head ) = ( *head )->next, free( tmp ) 
                                     : ( void )(  head = &( *head )->next );
        deleteMultipleOfNNodes( head, n );
    }
}

void printList( const Node *head )
{
    for ( ; head != NULL; head = head->next )
    {
        printf( "%d --> ", head->data );
    }

    puts( "NULL" );
}

int main(void) 
{
    Node *head = NULL;
    const int N = 10;

    for ( int i = N; i != 0; i-- )
    {
        addToHead( &head, i );
    }

    printList( head );

    deleteMultipleOfNNodes( &head, 2 );

    printList( head );

    return 0;
}

---

嘿，男人：），我们不能给你答案（你不会像这样学习的）。试着做一些代码，告诉我们你做了什么，有什么错误。学习对你来说会更好是的，我知道，但我已经花了好几个小时在代码上苦苦挣扎，我想一个帮助肯定会让我头脑清醒的（哈哈）

1 --> 2 --> 3 --> 4 --> 5 --> 6 --> 7 --> 8 --> 9 --> 10 --> NULL
1 --> 3 --> 5 --> 7 --> 9 --> NULL