C 删除功能无法删除除链表中的第一个节点之外的节点

我一直在研究图书馆管理系统。我差不多做完了。下面的程序是在C上使用代码块编辑器编写的

我有两个问题 1.如果我尝试删除第一个节点以外的节点，程序将停止响应

omit（）

function

else

语句似乎有问题。 2.

bsort（）

函数是链表中冒泡排序的正确实现吗？它工作得很好。我只是想知道称之为泡泡排序是否合适

// Imports
//---------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//---------------------------------------------
// Definitions
//---------------------------------------------
#define MAX_STRING_LENGTH 50
//---------------------------------------------
// Type definitions to make the code more readable
//---------------------------------------------
typedef struct node {
    char *name;
    char *author;
    struct node * next;
} Node;
//---------------------------------------------
// Global Variable
//---------------------------------------------
Node* head = NULL;
//---------------------------------------------
// Function protoypes
//---------------------------------------------
void insert(char *q, char *r);
void print_the_list();
void bsort();
void search();
void omit();
//---------------------------------------------
// Main Function :
// Ask the user to insert some books then
// print the list of books
// normally or sorted by book name
//---------------------------------------------
int main() {
    head = NULL; //Initially head is null
    char *book_name=NULL, *book_author=NULL;
    int n=NULL,i=NULL; // Number of book that the user want to enter
    printf("How many books you want to enter?: \n");
    scanf("%d", &n);
    for (i = 1; i <= n; i++){ // Loop iterate the number of times we have books 
    in quantity.
        // To clear buffer memory
        fflush(stdin);
        printf("Enter a Book name: ");
        fflush(stdin); // To clear buffer memory
        book_name = (char*) malloc(MAX_STRING_LENGTH*sizeof(char));
        gets(book_name); // Same as scanf
        printf("Author: ");
        book_author = (char*) malloc(MAX_STRING_LENGTH*sizeof(char));
        gets(book_author);
        // add it to the list
        insert(book_name, book_author);
        }
    print_the_list();
    char d=NULL;
    printf("Do you want to sort the data in ascending order?(y/n): \n\t");
    scanf("%c", &d);
    if (d == 'y') {
        printf("Sorting the list!");
        bsort();
    } else
        printf("alright!");

    print_the_list();
    omit();
    printf("Printing the modified list");
    print_the_list();
    search();
    return 0;
}
//---------------------------------------------
// insert(name of the book, author of the book):
// O(n_of_element_in_the_list)
// append the new book the global list
//---------------------------------------------
void insert(char* name, char* author){ //Adding items at the end of linked list
    // create and initialize the new node
    Node* new_node = (Node* ) malloc(sizeof(Node));
    new_node->author = author;
    new_node->name   = name;
    new_node->next   = NULL; // Since we are adding a node to the end, we are linking it to NULL.

    // if the list is empty then add the node as the head of the list
    if (head == NULL) {
        head = new_node;
    }
    else {
        Node * temp = head;
        // Traverse the list till the end
        while (temp->next != NULL)
            temp = temp->next;
        // add the new node as the successor of the last node
        temp->next = new_node;
    }
}
//---------------------------------------------
// print_the_list():
// O(n_of_element_in_the_list)
// print the whole content of the global list
//---------------------------------------------
void print_the_list() //Traversing
{
    printf("\n");
    printf("The Library data is as follows: \n");
    Node* temp=head;
    printf("\n");
    while(temp!=NULL)
    {
        printf("%25s",temp->name);
        printf("%25s",temp->author);
        temp=temp->next;
        printf("\n");
    }
}

//---------------------------------------------
// sort():
// O(n_of_element_in_the_list^2)
// sort the whole list by name in Ascending Order
//---------------------------------------------
void bsort(){ //Bubble Sort Algorithm to arrange Library data in Ascending Order

    // If he list is empty then is already sorted
    if(head == NULL)
        return;

    // Temp pointers to swap two nodes.
    char *swap_ptr_name, *swap_ptr_author;
    // Variable that keep track if at least one swap was made in the for.
    int swapped;
    Node* current_node=NULL;
    Node* next_node;
    do{
        // Reset the flag
        swapped = 0;
        // for each node in the list except the last one
        for (current_node = head; current_node->next != NULL;  current_node = current_node->next) {
            // Set the next node
            next_node = current_node->next;
            // if the current_node is bigger than the next_node swap them
            if (strcmp(current_node->name,next_node->name) > 0) {
                // Save the name and author of the current_minimum
                swap_ptr_name   = next_node->name;
                swap_ptr_author = next_node->author;

                // Place the current node as the minimum
                next_node->name   = current_node->name;
                next_node->author = current_node->author;

                // Place the old minimum in the place of the current_node
                current_node->name   = swap_ptr_name;
                current_node->author = swap_ptr_author;

                // We swapped two nodes so the flag is setted
                swapped = 1;
            }
        }
    }while(swapped == 1);
}

void search()
{
    char *keyword=NULL;
    Node* current=head;
    printf("Enter a book name or author name to search: ");
    fflush(stdin);
    keyword=(char*) malloc(MAX_STRING_LENGTH*sizeof(char));
    gets(keyword);
    for (current=head;current!=NULL;current=current->next)
    {
        if ((strcmp(current->name,keyword)==0) || (strcmp(current->author,keyword)==0)) {//||(strcmp(current->author,keyword))==0) {
            puts(current->name);
            puts(current->author);
        }
    }
}
void omit()
{
    char *keyword;
    char d;
    Node* current=head;
    Node* temp;
    printf("Enter a book name or author name to delete: ");
    fflush(stdin);
    keyword=(char*) malloc(MAX_STRING_LENGTH*sizeof(char));
    gets(keyword);
    printf("\nTrying to delete\n");
    for (current=head;current!=NULL;current=current->next)
    {
        if ((strcmp(current->name,keyword)==0) || (strcmp(current->author,keyword)==0)) {
            puts(current->name);
            puts(current->author);
            printf("Are you sure you want to delete[y/n]: ");
            fflush(stdin);
            scanf("%c",&d);
            if (d=='y') {
            printf("\nTrying to delete\n");
            if (current==head)
                {
                    head=current->next;
                    free(current);
                }
            else
                {
                    temp->next=current;
                    temp->next=current->next;
                    free(current);
                }
            }
        }
    }
}

//导入
//---------------------------------------------
#包括
#包括
#包括
//---------------------------------------------
//定义
//---------------------------------------------
#定义最大字符串长度50
//---------------------------------------------
//键入定义以使代码更具可读性
//---------------------------------------------
类型定义结构节点{
字符*名称；
char*作者；
结构节点*下一步；
}节点；
//---------------------------------------------
//全局变量
//---------------------------------------------
Node*head=NULL；
//---------------------------------------------
//函数原型
//---------------------------------------------
无效插入（char*q，char*r）；
作废打印列表（）；
void bsort（）；
无效搜索（）；
void省略（）；
//---------------------------------------------
//主要功能：
//然后请用户插入一些书籍
//打印书单
//通常按书名排序
//---------------------------------------------
int main（）{
head=NULL；//最初head为NULL
char*book\u name=NULL，*book\u author=NULL；
int n=NULL，i=NULL；//用户要输入的图书数量
printf（“您要输入多少本书？：\n”）；
scanf（“%d”和“&n”）；
for（i=1；i author=author；
新建节点->名称=名称；
new_node->next=NULL；//因为我们要在末尾添加一个节点，所以我们要将它链接到NULL。
//如果列表为空，则添加节点作为列表的标题
if（head==NULL）{
head=新的_节点；
}
否则{
节点*温度=头部；
//遍历列表直到结束
while（临时->下一步！=NULL）
温度=温度->下一步；
//添加新节点作为最后一个节点的后续节点
temp->next=新节点；
}
}
//---------------------------------------------
//打印列表（）：
//O（元素列表中元素的n个）
//打印全局列表的全部内容
//---------------------------------------------
void print\u\u list（）//遍历
{
printf（“\n”）；
printf（“库数据如下：\n”）；
节点*温度=头部；
printf（“\n”）；
while（temp！=NULL）
{
printf（“%25s”，临时->名称）；
printf（“%25s”，临时->作者）；
温度=温度->下一步；
printf（“\n”）；
}
}
//---------------------------------------------
//排序（）：
//O（列表^2中元素的n个）
//按名称按升序对整个列表进行排序
//---------------------------------------------
void bsort（）{//按升序排列库数据的气泡排序算法
//如果列表为空，则已排序
if（head==NULL）
返回；
//交换两个节点的临时指针。
字符*swap_ptr_名称，*swap_ptr_作者；
//变量，用于跟踪是否在for中进行了至少一次交换。
int交换；
节点*当前节点=空；
节点*下一个_节点；
做{
//重置标志
交换=0；
//对于列表中除最后一个节点外的每个节点
对于（当前\u节点=头部；当前\u节点->下一步！=NULL；当前\u节点=当前\u节点->下一步）{
//设置下一个节点
下一个节点=当前节点->下一个；
//如果当前的_节点大于下一个_节点，则交换它们
if（strcmp（当前节点->名称，下一个节点->名称）>0）{
//保存当前文档的名称和作者
交换\u ptr\u name=下一个\u节点->名称；
交换\u ptr\u author=下一个\u节点->作者；
//将当前节点放置为最小值
下一个\u节点->名称=当前\u节点->名称；
下一个节点->作者=当前节点->作者；
//将旧的最小值放置在当前_节点的位置
当前\u节点->名称=交换\u ptr\u名称；
当前节点->作者=交换作者；
//我们交换了两个节点，因此设置了标志
交换=1；
}
}
}而（交换==1）；
}
无效搜索（）
{
char*关键字=NULL；
节点*电流=头部；
printf（“输入要搜索的书名或作者姓名：”）；
fflush（stdin）；
关键字=（char*）malloc（最大字符串长度*sizeof（char））；
获取（关键字）；
对于（当前=头部；当前！=NULL；当前=当前->下一步）
{
如果（（strcmp（当前->姓名，关键字）==0）| |（strcmp（当前->作者，关键字）==0））{//| |（strcmp（当前->作者，关键字））==0）{
放置（当前->名称）；
放置（当前->作者）；
}
}
}
void省略（）
{
字符*关键字；
chard；
节点*电流=头部；
节点*温度；
printf（“输入要删除的书名或作者姓名：”）；
fflush（stdin）；
关键字=（char*）malloc（最大字符串长度*sizeof（char））；
获取（关键字）；
printf（“\n正试图删除\n”）；
对于（当前=头部；当前！=NULL；当前=当前->下一步）
{
如果（（strcmp（当前->名称，关键字）==0）| |（strcmp（当前->作者，关键字）==0））{
放置（当前->名称）；
放置（当前->作者）；
printf（“您确定要删除[y/n]：”；
fflush（stdin）；
scanf（“%c”、&d）；
如果（d=='y'）{
printf（“\n正试图删除\n”）；
如果（当前==水头）
{
头部=当前->下一步；
自由（电流）；
}
其他的
{
温度->下一步=当前；
if ((strcmp(current->name,keyword)==0) || (strcmp(current->author,keyword)==0)) {
        puts(current->name);
        puts(current->author);
        printf("Are you sure you want to delete[y/n]: ");
        fflush(stdin);
        scanf("%c",&d);
        if (d=='y') 
        {
            printf("\nTrying to delete\n");
            if (current==head)
            {
                head=current->next;
                free(current);
            }
            else
            {
                if(temp == head)
                {
                    head->next = current->next;
                }
                temp->next=current->next;
                free(current);
            }
        }
        temp = current;
    }