请用尾插发建立一个带头结点的单链表，并用头插法完成单链表的就地逆置，输出单链表中的数据，验证程序是否正确。

### 回答1：
好的，以下是回复：

尾插法建立带头结点的单链表的步骤如下：

1. 定义一个头结点，并将其初始化为 NULL。
2. 定义一个指针 p，指向头结点。
3. 循环读入数据，每读入一个数据就新建一个结点，并将数据存入结点中。
4. 将 p 指向新建的结点，并将新建的结点的 next 指针指向 NULL。
5. 将 p 指向新建的结点。

头插法完成单链表的就地逆置的步骤如下：

1. 定义三个指针：p、q、r，分别指向头结点、第一个结点和第二个结点。
2. 将 p 的 next 指针指向 NULL。
3. 循环执行以下操作：
a. 将 q 的 next 指针指向 p。
b. 将 p 指向 q。
c. 将 q 指向 r。
d. 如果 r 不为 NULL，则将 r 指向 r 的下一个结点。
4. 将头结点的 next 指针指向 p。

最后，遍历单链表并输出其中的数据，即可验证程序是否正确。

### 回答2：
题目要求使用尾插法建立一个带头节点的单链表，并使用头插法完成单链表的就地逆置。要检验程序是否正确，可以输出单链表中的数据进行验证。

首先，我们需要明确什么是带有头节点的单链表。带有头节点的单链表是在单链表的头部增加一个空节点作为头节点，便于访问第一个节点和实现一些操作。尾插法是在单链表尾部插入新节点。头插法是在单链表头部插入新节点。就地逆置是将单链表的节点顺序全部反转。

下面是一个带有头节点的单链表的结构定义：

typedef struct Node{
    int data;               // 数据域
    struct Node *next;      // 指针域
}Node, *LinkList;

使用尾插法建立单链表的代码如下：

void createList(LinkList L, int n){
    L = (LinkList)malloc(sizeof(Node));  // 创建头节点
    L->next = NULL;                      // 头节点的指针域为空
    Node *p, *q;
    q = L;                               // q指向头节点
    for(int i=0; i<n; i++){
        p = (Node*)malloc(sizeof(Node));
        scanf("%d", &p->data);
        q->next = p;
        q = p;
    }
    q->next = NULL;                      // 尾节点指针域为空
}

接下来，使用头插法完成单链表的就地逆置：

void reverseList(LinkList L){
    Node *p, *q, *r;
    p = L->next;
    q = NULL;
    while(p != NULL){
        r = p->next;      // r指向p的下一个节点
        p->next = q;      // 将p节点的指针域指向q
        q = p;            // q指向p
        p = r;            // p指向r
    }
    L->next = q;          // 头节点指针域指向反转后的头节点
}

最后，输出单链表的数据进行验证：

void printList(LinkList L){
    Node *p = L->next;
    while(p != NULL){
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

完整代码如下：

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

typedef struct Node{
    int data;
    struct Node *next;
}Node, *LinkList;

void createList(LinkList L, int n){
    L = (LinkList)malloc(sizeof(Node));
    L->next = NULL;
    Node *p, *q;
    q = L;
    for(int i=0; i<n; i++){
        p = (Node*)malloc(sizeof(Node));
        scanf("%d", &p->data);
        q->next = p;
        q = p;
    }
    q->next = NULL;
}

void reverseList(LinkList L){
    Node *p, *q, *r;
    p = L->next;
    q = NULL;
    while(p != NULL){
        r = p->next;
        p->next = q;
        q = p;
        p = r;
    }
    L->next = q;
}

void printList(LinkList L){
    Node *p = L->next;
    while(p != NULL){
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

int main(){
    int n;
    LinkList L = NULL;
    scanf("%d", &n);
    createList(L, n);
    printList(L);
    reverseList(L);
    printList(L);
    return 0;
}

这一程序使用了尾插法建立了一个带头节点的单链表，并使用头插法完成单链表的就地逆置，最后输出了单链表中的数据。我们可以通过手动输入一些数据来验证程序的正确性。

### 回答3：
在C语言中，用结构体来表示单链表的结点，结构体包含两个成员：data（用于存放数据）、next（指向下一个结点的指针）。下面是用尾插法创建一个带头结点的单链表的代码：

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

typedef struct Node {
    int data;
    struct Node* next;
} Node;

void createList(Node* head) {
    Node* p = head;
    int x;

    printf("请输入单链表中的数据（以-1结束）：\n");
    while (1) {
        scanf("%d", &x);
        if (x == -1)
            break;
        Node* newNode = (Node*)malloc(sizeof(Node));
        newNode->data = x;
        newNode->next = NULL;
        p->next = newNode;
        p = p->next;
    }
}

void reverseList(Node* head) {
    Node *p, *q;
    p = head->next;
    head->next = NULL;

    while (p) {
        q = p->next;
        p->next = head->next;
        head->next = p;
        p = q;
    }
}

void printList(Node* head) {
    Node* p = head->next;

    printf("单链表中的数据为：\n");
    while (p) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

int main() {
    Node* head = (Node*)malloc(sizeof(Node));
    head->next = NULL;
    createList(head);
    reverseList(head);
    printList(head);

    return 0;
}

在代码中，createList()函数用于通过读取用户输入，创建一个带头结点的单链表；reverseList()函数使用头插法将单链表就地逆置；printList()函数用于输出单链表中的数据。最后在main()函数中，分别调用这三个函数，验证程序是否正确。

总的来说，带头结点的单链表使用尾插法来创建，而使用头插法进行就地逆置。代码中的实现方法是比较基础的，也可参考其他的实现方法，如递归实现等。