本关任务：为 Student 表创建一个名为 dele_s2 的 DELETE 触发器，该触发器的作用是删除 Student 表中的记录时删除 SC 表中该学生的选课纪录。

创建一个名为 dele_s2 的 DELETE 触发器，通常用于数据库设计中，当在 Student 表中删除一条学生记录时，自动地同步删除 SC 表中对应该学生的选课信息。这可以确保数据的一致性和完整性。以下是这个触发器的基本结构，假设我们正在使用 SQL Server：

CREATE TRIGGER dele_s2
ON Student
AFTER DELETE
AS
BEGIN
    DELETE FROM SC
    WHERE StudentID IN (SELECT StudentID FROM deleted) -- 'deleted' 是删除操作中被删除的数据集别名
END;

在这个例子中：
- `CREATE TRIGGER` 开始创建触发器声明。
- `dele_s2` 是触发器的名称。
- `ON Student` 指定触发事件是在 Student 表上发生。
- `AFTER DELETE` 表示触发器将在记录被删除之后立即执行。
- `AS` 后面的块包含触发器的实际操作，即从 SC 表中删除 StudentID 匹配已删除 Student 记录的行。

相关问题

针对学生表dele_jl，定义一触发器用来保证参照完整性，实现级联删除。

假设学生表为 student，学籍表为 school_roll，学籍表中的学生编号为 stu_id。下面是一个触发器的示例代码：

CREATE TRIGGER trg_del_student
BEFORE DELETE ON student
FOR EACH ROW
BEGIN
    DELETE FROM school_roll WHERE stu_id = OLD.stu_id;
END;

这个触发器会在删除学生表中的一行记录之前触发，然后会删除学籍表中与该学生相应的记录。其中，OLD.stu_id 表示即将被删除的学生表中的记录的学生编号，这个值会被用于删除学籍表中相应的记录。这样，当删除学生表中的一条记录时，与之相关的学籍表中的记录也会被自动删除，从而保证了参照完整性。

c语言，写一个函数来删除动态链表中指定的节点函数原型为struct Student *del(struct Student *head, struct Student *dele)。返回值是什么自行推断。

### 回答1：
下面是一个示例代码，用于删除动态链表中指定的节点：

#include <stdlib.h>

struct Student {
    int id;
    struct Student *next;
};

struct Student *del(struct Student *head, struct Student *dele) {
    struct Student *p = head;
    struct Student *prev = NULL;

    while (p != NULL && p != dele) {
        prev = p;
        p = p->next;
    }

    if (p == NULL) {
        // 指定节点不在链表中
        return head;
    }

    if (prev == NULL) {
        // 删除头节点
        head = head->next;
    } else {
        prev->next = p->next;
    }

    free(p);
    return head;
}

函数 `del` 接受两个参数：指向链表头部的指针 `head` 和指向要删除的节点的指针 `dele`。函数的返回值是指向链表头部的指针。

在函数中，我们首先遍历整个链表，找到要删除的节点 `dele`。我们使用两个指针 `p` 和 `prev` 来遍历链表，其中 `p` 指向当前节点，`prev` 指向当前节点的前一个节点。当找到要删除的节点时，我们将 `prev->next` 指向 `p->next`，然后释放节点 `p`。如果要删除的节点是头节点，则将 `head` 指向下一个节点。

需要注意的是，如果要删除的节点不在链表中，则函数不会对链表进行任何修改，直接返回原链表的头部指针。

### 回答2：
函数的返回值是删除节点后链表的头指针。如果传入的头指针为空，说明链表为空，直接返回空指针即可。

如果传入的头指针不为空，就先判断头节点是否就是要删除的节点，如果是的话，将头指针指向下一个节点，并释放删除节点的内存，然后返回新的头指针。

如果头节点不是要删除的节点，就需要遍历链表找到要删除的节点的前一个节点。遍历可以使用一个指针指向当前节点，一个指针指向前一个节点，比较当前节点是否是要删除的节点，如果是的话，将前一个节点的next指针指向当前节点的下一个节点，释放删除节点的内存，然后返回头指针。

具体实现如下：

struct Student {
    int data;
    struct Student *next;
};

struct Student *del(struct Student *head, struct Student *dele) {
    if (head == NULL) {  // 空链表直接返回空指针
        return NULL;
    }
    
    if (head == dele) {  // 头节点就是要删除的节点
        struct Student *temp = head->next;
        free(head);
        return temp;
    }
    
    struct Student *cur = head;
    struct Student *prev = NULL;
    
    while (cur != NULL && cur != dele) {  // 遍历链表找到要删除的节点的前一个节点
        prev = cur;
        cur = cur->next;
    }
    
    if (cur != NULL) {  // 如果找到要删除的节点
        prev->next = cur->next;
        free(cur);
    }
    
    return head;  // 返回新的头指针
}

### 回答3：
函数的返回值应为 struct Student*，即删除节点后的动态链表的头节点指针。在函数中，首先需要判断要删除的节点是不是头节点，如果是的话，将头节点指针指向下一个节点。如果不是头节点，则需要遍历链表找到要删除节点的前一个节点，然后将前一个节点的指针指向要删除节点的下一个节点。

下面是一个示例代码：

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

// 定义学生结构体
struct Student {
    int id;
    struct Student* next;
};

// 删除指定节点的函数
struct Student* del(struct Student* head, struct Student* dele) {
    
    // 判断头节点是否为要删除的节点
    if (head == dele) {
        struct Student* temp = head;
        head = head->next;
        free(temp);
        return head;
    }
    
    struct Student* current = head;
    struct Student* prev = NULL;
    
    // 遍历链表找到要删除节点的前一个节点
    while (current != NULL && current != dele) {
        prev = current;
        current = current->next;
    }
    
    // 如果找到节点，将前一个节点的指针指向要删除节点的下一个节点
    if (current != NULL) {
        prev->next = current->next;
        free(current);
    }
    
    return head;
}

int main() {
    // 创建动态链表
    struct Student* head = (struct Student*)malloc(sizeof(struct Student));
    struct Student* node1 = (struct Student*)malloc(sizeof(struct Student));
    struct Student* node2 = (struct Student*)malloc(sizeof(struct Student));
    
    head->id = 1;
    node1->id = 2;
    node2->id = 3;

    head->next = node1;
    node1->next = node2;
    node2->next = NULL;
    
    // 删除节点2
    struct Student* newHead = del(head, node2);
    
    // 打印删除节点后的链表
    struct Student* current = newHead;
    while (current != NULL) {
        printf("id: %d\n", current->id);
        current = current->next;
    }
    
    return 0;
}

运行结果：

id: 1
id: 2