C 从我的动态列表中删除节点

我创建了一个动态列表，其中每个节点都包含一个单词，我创建了一个函数来删除单个节点并释放节点正在使用的内存，但是我的函数不会删除节点。当我输入它应该删除的世界时，我只得到“notfound”作为输出，错误在delete函数中，但我正在努力找到它，可能是if语句应该循环通过节点并找到要删除的那个吗

    // Inserting and deleting nodes in a list
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// self-referential structure                       
struct listNode {                                      
   char *data; // each listNode contains a character 
   struct listNode *nextPtr; // pointer to next node
}; 
typedef struct listNode ListNode; // synonym for struct listNode
typedef ListNode *ListNodePtr; // synonym for ListNode*

// prototypes
void insert(ListNodePtr *sPtr, char *value);
char delete(ListNodePtr *sPtr, char value);
int isEmpty(ListNodePtr sPtr);
void printList(ListNodePtr currentPtr);
void instructions(void);
int main(void)
{ 
   ListNodePtr startPtr = NULL; // initially there are no nodes
   char item[20]; // char entered by user
   instructions(); // display the menu
   printf("%s", "? ");
   unsigned int choice; // user's choice
   scanf("%u", &choice);
   // loop while user does not choose 3
   while (choice != 3) { 
      switch (choice) { 
         case 1:
            printf("%s", "Enter a character: ");
            scanf("%s", item);
            insert(&startPtr, item); // insert item in list
            printList(startPtr);
            break;

     case 2: // delete an element
            // if list is not empty
            if (!isEmpty(startPtr)) { 
               printf("%s", "Enter character to be deleted: ");
               scanf("%s", &item);
               // if character is found, remove it
               if (delete(&startPtr, *item)) { // remove item
                  printf("%s deleted.\n", &item);
                  printList(startPtr);
               } 
               else {
                  printf("%s not found.\n\n", &item);
               } 
            } 
            else {
               puts("List is empty.\n");
            } 
            break;

         default:
            puts("Invalid choice.\n");
            instructions();
            break;
      } // end switch
      printf("%s", "? ");
      scanf("%u", &choice);
   } 
   puts("End of run.");
} 
// display program instructions to user
void instructions(void)
{ 
   puts("Enter your choice:\n"
      "   1 to insert an element into the list.\n"
      "   2 to delete an element from the list.\n"
      "   3 to end.");
}

// insert a new value into the list in sorted order
void insert(ListNodePtr *sPtr, char *value)
{ 
   ListNodePtr newPtr = malloc(sizeof(ListNode)); // create node

   if (newPtr != NULL) { // is space available
      newPtr->data= malloc(strlen(value)+1);
      strcpy(newPtr->data, value);
      newPtr->nextPtr = NULL; // node does not link to another node
      ListNodePtr previousPtr = NULL;
      ListNodePtr currentPtr = *sPtr;
      // loop to find the correct location in the list       
      while (currentPtr != NULL && value > currentPtr->data) {
         previousPtr = currentPtr; // walk to ...               
         currentPtr = currentPtr->nextPtr; // ... next node 
      }                                          
      // insert new node at beginning of list
      if (previousPtr == NULL) { 
         newPtr->nextPtr = *sPtr;
         *sPtr = newPtr;
      } 
      else { // insert new node between previousPtr and currentPtr
         previousPtr->nextPtr = newPtr;
         newPtr->nextPtr = currentPtr;
      } 
   } 
   else {
      printf("%s not inserted. No memory available.\n", value);
   } 
} 

// delete a list element
char delete(ListNodePtr *sPtr, char value)
{ 
   // delete first node if a match is found
   if (&value == (*sPtr)->data) { 
      ListNodePtr tempPtr = *sPtr; // hold onto node being removed
      *sPtr = (*sPtr)->nextPtr; // de-thread the node
      free(tempPtr); // free the de-threaded node
      return value;
   } 
   else { 
      ListNodePtr previousPtr = *sPtr;
      ListNodePtr currentPtr = (*sPtr)->nextPtr;
      // loop to find the correct location in the list
      while (currentPtr != NULL && currentPtr->data != value) { 
         previousPtr = currentPtr; // walk to ...  
         currentPtr = currentPtr->nextPtr; // ... next node  
      } 
      // delete node at currentPtr
      if (currentPtr != NULL) { 
         ListNodePtr tempPtr = currentPtr;
         previousPtr->nextPtr = currentPtr->nextPtr;
         free(tempPtr);
         return value;
      } 
   } 
   return '\0';
} 

// return 1 if the list is empty, 0 otherwise
int isEmpty(ListNodePtr sPtr)
{ 
   return sPtr == NULL;
} 


// print the list
void printList(ListNodePtr currentPtr)
{ 
   // if list is empty
   if (isEmpty(currentPtr)) {
      puts("List is empty.\n");
   } 
   else { 
      puts("The list is:");
      // while not the end of the list
      while (currentPtr != NULL) { 
         printf("%s --> ", currentPtr->data);
         currentPtr = currentPtr->nextPtr;   
      } 
      puts("NULL\n");
   } 
} 

//在列表中插入和删除节点
#包括
#包括
#包括
//自指结构
结构listNode{
char*data；//每个listNode包含一个字符
struct listNode*nextPtr；//指向下一个节点的指针
}; 
类型定义结构listNode listNode；//结构listNode的同义词
typedef ListNode*ListNodePtr；//ListNode的同义词*
//原型
无效插入（ListNodePtr*sPtr，char*value）；
字符删除（ListNodePtr*sPtr，字符值）；
int isEmpty（ListNodePtr sPtr）；
作废打印列表（ListNodePtr currentPtr）；
无效指示（无效）；
内部主（空）
{ 
ListNodePtr startPtr=NULL；//最初没有节点
字符项[20]；//用户输入的字符
说明（）；//显示菜单
printf（“%s”和“？”）；
unsigned int choice；//用户的选择
scanf（“%u”，选择（&C）；
//在用户未选择3时循环
while（choice！=3）{
开关（选择）{
案例1：
printf（“%s”，“输入字符：”）；
scanf（“%s”，项目）；
插入（&startPtr，item）；//在列表中插入项
打印列表（startPtr）；
打破
案例2://删除一个元素
//如果列表不是空的
如果（！isEmpty（startPtr））{
printf（“%s”，“输入要删除的字符：”）；
scanf（“%s”和项目）；
//如果找到字符，请将其删除
if（删除（&startPtr，*item））{//删除项
printf（“%s已删除。\n”，&item）；
打印列表（startPtr）；
} 
否则{
printf（“%s未找到。\n\n”，&item）；
} 
} 
否则{
puts（“列表为空。\n”）；
} 
打破
违约：
puts（“无效选择。\n”）；
指令（）；
打破
}//结束开关
printf（“%s”和“？”）；
scanf（“%u”，选择（&C）；
} 
出售（“结束运行”）；
} 
//向用户显示程序指令
作废指示（作废）
{ 
放置（“输入您的选择：\n”
“1将元素插入列表。\n”
“2从列表中删除元素。\n”
“3结束。”）；
}
//按排序顺序在列表中插入新值
无效插入（ListNodePtr*sPtr，char*value）
{ 
ListNodePtr newPtr=malloc（sizeof（ListNode））；//创建节点
如果（newPtr！=NULL）{//有可用空间吗
newPtr->data=malloc（strlen（值）+1）；
strcpy（newPtr->数据，值）；
newPtr->nextPtr=NULL；//节点未链接到其他节点
ListNodePtr previousPtr=NULL；
ListNodePtr currentPtr=*sPtr；
//循环以在列表中找到正确的位置
while（currentPtr！=NULL&&value>currentPtr->data）{
previousPtr=currentPtr；//步行到。。。
currentPtr=currentPtr->nextPtr；/…下一个节点
}                                          
//在列表的开头插入新节点
如果（previousPtr==NULL）{
newPtr->nextPtr=*sPtr；
*sPtr=newPtr；
} 
else{//在上一个PTR和当前PTR之间插入新节点
上一个PTR->下一个PTR=newPtr；
newPtr->nextPtr=currentPtr；
} 
} 
否则{
printf（“%s未插入。没有可用内存。\n”，值）；
} 
} 
//删除列表元素
字符删除（ListNodePtr*sPtr，字符值）
{ 
//如果找到匹配项，则删除第一个节点
如果（&value==（*sPtr）->数据）{
ListNodePtr temptr=*sPtr；//保留要删除的节点
*sPtr=（*sPtr）->nextPtr；//取消节点线程
free（temptr）；//释放去线程化节点
返回值；
} 
否则{
ListNodePtr previousPtr=*sPtr；
ListNodePtr currentPtr=（*sPtr）->nextPtr；
//循环以在列表中找到正确的位置
而（currentPtr！=NULL&¤tPtr->data！=value）{
previousPtr=currentPtr；//步行到。。。
currentPtr=currentPtr->nextPtr；/…下一个节点
} 
//删除当前PTR上的节点
如果（currentPtr！=NULL）{
ListNodePtr temptr=当前ptr；
上一个PTR->nextPtr=当前PTR->nextPtr；
免费（tempPtr）；
返回值；
} 
} 
返回“\0”；
} 
//如果列表为空，则返回1，否则返回0
int isEmpty（ListNodePtr sPtr）
{ 
返回sPtr==NULL；
} 
//打印列表
无效打印列表（ListNodePtr currentPtr）
{ 
//如果列表为空
如果（isEmpty（currentPtr））{
puts（“列表为空。\n”）；
} 
否则{
puts（“列表为：”）；
//而不是列表的末尾
while（currentPtr！=NULL）{
printf（“%s-->”，currentPtr->data）；
currentPtr=currentPtr->nextPtr；
} 
放置（“空\n”）；
} 
} 

使用指针时出现问题 如果为ListNode*的ListNodePtr设置了特殊的typedef，那么请使用它。为什么需要ListNodePtr*？ 所以在某些地方，您使用指向对象指针的指针 这使得您的代码更难理解

（currentPtr！=NULL&¤tPtr->data！=value）

这里的“值”是一个字符，你们试着把它和“数据”进行比较，数据实际上是指针 你最好使用类似strcmp（）的东西

因此，问题从函数声明的更高层开始 你不需要那样做

字符删除（ListNodePtr*sPtr，字符值） 但那 char delete（ListNodePtr*sPtr，char*value）

及

if (&value == (*sPtr)->data)

 // loop to find the correct location in the list       
      while (currentPtr != NULL && value > currentPtr->data) {