L指向带头结点的单链表。编写函数实现删除表中的第一个元素。删除成功返回1 ，删除失败返回0。在主函数内显示被删除元素的值及删除后链表中每个元素的值。

### 回答1：
以下是删除表中第一个元素的代码实现：

int deleteFirstNode(ListNode* head) {
    if (head == NULL || head->next == NULL) {
        return 0; // 删除失败
    }
    ListNode* p = head->next;
    head->next = p->next;
    int val = p->val;
    delete p;
    return val; // 删除成功，返回被删除元素的值
}

在主函数中，可以这样调用该函数并显示结果：

ListNode* head = createLinkedList(); // 创建带头结点的单链表
int val = deleteFirstNode(head); // 删除第一个元素
if (val == 0) {
    cout << "删除失败" << endl;
} else {
    cout << "被删除元素的值为：" << val << endl;
    cout << "删除后链表中每个元素的值为：";
    printLinkedList(head); // 打印链表中每个元素的值
}

其中，`createLinkedList()` 和 `printLinkedList()` 分别是创建链表和打印链表的函数，这里不再赘述。

### 回答2：
首先，我们需要了解带头结点的单链表的结构。带头结点的单链表是一种通过节点指针连接在一起的数据结构，每个节点包含一个数据元素和一个指向下一个节点的指针。

要实现删除表中的第一个元素，我们可以按照以下步骤进行：

1. 首先判断链表是否为空。如果链表为空，删除失败，返回0。
2. 如果链表不为空，我们需要定义两个指针：一个指向头结点，一个指向第一个元素的节点。
3. 将头结点的指针指向第一个元素的下一个节点，即删除了第一个元素。
4. 释放被删除节点的内存空间。
5. 删除成功，返回1。

接下来，我们可以在主函数中调用删除函数，并显示被删除元素的值及删除后链表中每个元素的值。

例如，假设链表中的元素依次为：头结点 -> 1 -> 2 -> 3，代码如下所示：

#include <iostream>
using namespace std;

// 定义节点结构
struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

// 删除表中的第一个元素
int deleteFirstNode(ListNode* L) {
    if (L->next == nullptr) {  // 表为空
        return 0;
    }
    ListNode* first = L->next;  // 定义指向第一个元素的指针
    L->next = first->next;  // 头结点指向第二个元素
    cout << "删除的元素值为：" << first->val << endl;
    delete first;  // 释放被删除节点的内存空间
    return 1;
}

int main() {
    // 构造带头结点的链表
    ListNode* L = new ListNode(-1);
    ListNode* node1 = new ListNode(1);
    ListNode* node2 = new ListNode(2);
    ListNode* node3 = new ListNode(3);
    
    L->next = node1;
    node1->next = node2;
    node2->next = node3;
    
    cout << "删除前链表中每个元素的值为：" << endl;
    ListNode* p = L->next;
    while (p != nullptr) {
        cout << p->val << " ";
        p = p->next;
    }
    cout << endl;

    if (deleteFirstNode(L) == 1) {
        cout << "删除成功！" << endl;
        cout << "删除后链表中每个元素的值为：" << endl;
        p = L->next;
        while (p != nullptr) {
            cout << p->val << " ";
            p = p->next;
        }
        cout << endl;
    } else {
        cout << "删除失败！链表为空。" << endl;
    }
    
    return 0;
}

该程序运行后的输出为：

删除前链表中每个元素的值为：
1 2 3 
删除的元素值为：1
删除成功！
删除后链表中每个元素的值为：
2 3 

这样，我们就成功地实现了删除带头结点的单链表中的第一个元素，并显示了删除元素的值及删除后链表中每个元素的值。

### 回答3：
在删除表中的第一个元素之前，我们需要先判断链表是否为空。如果为空，则删除失败，返回值为0。否则，我们只需要修改头节点的指针，使其指向第二个节点即可实现删除第一个元素的功能。然后，我们遍历链表，显示每个元素的值。

下面是代码示例：

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

// 定义链表结构
typedef struct Node{
    int data;
    struct Node* next;
}Node;

// 删除链表中的第一个元素
int deleteFirstElement(Node** head){
    if(*head == NULL){
        return 0;  // 链表为空，删除失败
    }
    Node* temp = *head;
    *head = (*head)->next;  // 修改头节点的指针
    int deletedValue = temp->data;
    free(temp);  // 释放第一个节点的内存空间
    return deletedValue;  // 返回被删除的元素值
}

// 显示链表中的每个元素
void displayLinkedList(Node* head){
    if(head == NULL){
        printf("链表为空\n");
        return;
    }
    Node* curr = head;
    while(curr != NULL){
        printf("%d ", curr->data);
        curr = curr->next;
    }
    printf("\n");
}

int main(){
    // 创建链表，初始化链表元素
    Node* head = (Node*)malloc(sizeof(Node));
    Node* node1 = (Node*)malloc(sizeof(Node));
    Node* node2 = (Node*)malloc(sizeof(Node));
    Node* node3 = (Node*)malloc(sizeof(Node));
    head->data = 0;
    node1->data = 1;
    node2->data = 2;
    node3->data = 3;
    head->next = node1;
    node1->next = node2;
    node2->next = node3;
    node3->next = NULL;

    // 删除第一个元素
    int deletedValue = deleteFirstElement(&head);
    if(deletedValue == 0){
        printf("删除失败\n");
    }else{
        printf("被删除的元素值为：%d\n", deletedValue);
    }

    // 显示链表中的每个元素
    displayLinkedList(head);

    return 0;
}

执行上述代码，输出结果为：

被删除的元素值为：1
2 3