我不断收到以下错误。 “错误：预期';'在'p'之前
出现此错误是因为编译器希望您使用分号 ; 完成 statement。
在您的情况下，您的表达式是函数 delete 的 name ！编译器知道delete 是什么。否则你会得到不同的错误。
这在 cmets 中由以下程序说明：
/* $gcc -o main *.c -Wall -pedantic -ansi */
#include <stdio.h>
void foo(void)
{
int p;
foo p; /* error: expected ‘;’ before ‘p’ */
foo; p; /* warning: statement with no effect [-Wunused-value] */
fxx; /* error: ‘fxx’ undeclared (first use in this function) */
p; /* warning: statement with no effect [-Wunused-value] */
}
int main()
{
return 0;
}
C standard 处理Expression and null statements 涵盖了您的特定场景。
int delete(struct node *start, int data) 的逻辑需要大量的工作。
当前的回复都没有解决delete 中的所有逻辑问题。
当start == p 时，所有解决方案都会崩溃。
管理链表并不难，但需要注意细节。
请用测试程序看一下完整的单链表simple implementation。
#include<stdio.h>
#include<stdlib.h>
// Basic simple single list implementation to illustrate
// proper deletion of the node
// Node in List
typedef struct node {
int data;
struct node* next; // pointer to next node
}node;
// List structure
typedef struct list {
node* head; // The entry point into a linked list. If the list is empty then the head is a null reference.
} list;
// Create list
list* list_create()
{
list* new_list = malloc(sizeof(list));
if(new_list == NULL)
return NULL; // protection
new_list->head = NULL; // If the list is empty then the head is a null reference. no elements in the list
return new_list; // return created new list
}
// returns newly created node
node* node_new(int data)
{
node* new_node = malloc(sizeof(node)); // allocate memory for the node
if (new_node == NULL)
return NULL; // protection
new_node->data = data; // remember the data
new_node->next = NULL; // no next node
return new_node; // return new created node
}
// The method creates a node and prepends it at the beginning of the list.
//
// Frequently used names for this method:
//
// insert at head
// add first
// prepend
//
// returns new head or NULL on failer
node* prepend_node(list* in_list, node* new_node)
{
// Add item to the front of the in_list, return pointer to the prepended node (head)
if(in_list == NULL)
return NULL;
if(new_node == NULL) // problem, not enough memory
return NULL; // in_list->head has not changed
/*
new_node
|*| --> NULL
next
*/
if(in_list->head == NULL) // if list is empty
{
in_list->head = new_node; // the new_node becomes a head
}
else // list already have a head node
{
/*
|2|-->|1|-->NULL
^
|
*
head (2) (list pointer)
*/
new_node->next = in_list->head; // now, the new node next pointer points to the node pointed by the list head, see below:
/*
new_node
|3|--> |2|-->|1|-->NULL
^
|
*
head (list pointer)
*/
in_list->head = new_node; // the list head has to move to new_node ( a new prepanded node)
/*
new_node
|3|--> |2|-->|1|-->NULL
^
|
*
head (3) (list pointer)
*/
}
return in_list->head; // we are returning pinter to new_node
}
// Print out list
void print_list(list* in_list)
{
node* node;
if (in_list == NULL)
{
return;
}
if (in_list->head == NULL)
{
printf("List is empty!\n");
return;
}
printf("List: ");
node = in_list->head;
while(node != NULL)
{
printf(" %d", node->data);
node = node->next;
}
printf("\n");
}
struct node *find(struct node *start, int data) // find p to be removed
{
node* node;
if (start == NULL)
return NULL;
node = start;
while(node != NULL)
{
if (node->data == data)
return node;
node = node->next;
}
return NULL;
}
int delete(struct node *start, int data){
// This function will crash if start == p
// Has other problems too
// For better implementation see sg7_delete.
struct node *q, *p;
p = find(start, data);
if (p != NULL){
q = start;
while (q->next != p){
q = q->next;
}
q->next = p->next;
free(p);
return 1;
}
return 0;
}
int sg7_delete(struct node **start, int data)
{
struct node *p, *prev, *next, *to_free;
if (start == NULL) // protection
return 0;
p = find(*start, data); // find p to be removed
if (p == NULL)
return 0;
if (*start == NULL)
return 0; // protection
if(*start == p) // head == p
{
if((*start)->next !=NULL)
{
*start = (*start)->next; // remember next
free(p);
printf("Head removed\n");
return 1;
}
else // the only node
{
free(p);
printf("Last node removed\n");
*start = NULL;
return 1;
}
}
// p != start:
next = *start;
while (next != NULL)
{
prev = next;
to_free = next->next; // candidate to be freed
if( to_free == p )
{
prev->next = to_free->next; // connect nodes before deletion
free(to_free); // now free the remembered `next`
to_free = NULL; // so it does not point to the released memory
return 1;
}
next = next->next; // this node was not a match
} //while
return 0;
}
int main() {
list* new_list = list_create();
node *n1 = node_new(1);
node *n2 = node_new(2);
node *n3 = node_new(3);
// list is empty
print_list(new_list);
prepend_node(new_list, n1);
prepend_node(new_list, n2);
prepend_node(new_list, n3);
// list has 3 elements
print_list(new_list);
sg7_delete(&new_list->head, 3);
print_list(new_list);
sg7_delete(&new_list->head, 1);
print_list(new_list);
sg7_delete(&new_list->head, 2);
// list has 2 elements
print_list(new_list);
printf("head: %p\n",new_list->head);
print_list(new_list);
#if 0
// printf("TEST OF THE ORIGINAL FUNCTION\n");
n1 = node_new(1);
n2 = node_new(2);
n3 = node_new(3);
prepend_node(new_list, n1);
prepend_node(new_list, n2);
prepend_node(new_list, n3);
print_list(new_list);
delete(new_list->head, 1); // REMOVE THE TAIL
print_list(new_list);
//delete(new_list->head, 3); // WILL CRASH IF HEAD IS REMOVED - signal 11
//delete(new_list->head, 2); // WILL CRASH IF HEAD IS REMOVED - signal 11
#endif
free (new_list); // after deleting all elements, delete the list itself
return 0;
}
输出：
List is empty!
List: 3 2 1
Head removed
List: 2 1
List: 2
Last node removed
List is empty!
head: (nil)
List is empty!