用c语言写一个程序：有两个链表a和b(静态链表，每个链表包含6个节点，结点数据从键盘输入)，每个节点包含学号和姓名。从链表a中删去与链表b中具有相同学号的结点，并输出链表a。

### 回答1：
以下是用C语言实现的程序：

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

#define MAX_LEN 20  // 定义字符串最大长度
#define NODE_NUM 6   // 定义每个链表节点数

// 定义节点结构体
typedef struct Node {
    char id[MAX_LEN];   // 学号
    char name[MAX_LEN]; // 姓名
    int next;           // 指向下一个节点的指针
} Node;

// 初始化链表
void initList(Node list[], int n) {
    for (int i = 0; i < n; i++) {
        printf("请输入第%d个节点的学号和姓名：", i + 1);
        scanf("%s%s", list[i].id, list[i].name);
        list[i].next = i + 1;
    }
    list[n - 1].next = -1; // 最后一个节点的指针指向-1
}

// 输出链表
void printList(Node list[], int head) {
    int p = head;
    while (p != -1) {
        printf("%s\t%s\n", list[p].id, list[p].name);
        p = list[p].next;
    }
}

// 删除链表a中与链表b具有相同学号的节点
void delSameNodes(Node a[], Node b[]) {
    int pa = 0, pb = 0, prev = -1;
    while (pa != -1 && pb != -1) {
        if (strcmp(a[pa].id, b[pb].id) == 0) { // 当前a和b节点的学号相同
            if (prev == -1) {   // 如果相同节点是a链表的头节点
                a[pa].next = a[a[pa].next].next;
                prev = pa;      // 记录上一个节点
            } else {            // 如果相同节点不是a链表的头节点
                a[prev].next = a[pa].next;
                pa = a[prev].next;
            }
            pb = b[pb].next;
        } else if (strcmp(a[pa].id, b[pb].id) < 0) { // 当前a节点的学号小于b节点的学号
            prev = pa;
            pa = a[pa].next;
        } else {    // 当前a节点的学号大于b节点的学号
            pb = b[pb].next;
        }
    }
}

int main() {
    Node a[NODE_NUM], b[NODE_NUM];
    printf("初始化链表a：\n");
    initList(a, NODE_NUM);
    printf("链表a：\n");
    printList(a, 0); // 输出链表a

    printf("初始化链表b：\n");
    initList(b, NODE_NUM);
    printf("链表b：\n");
    printList(b, 0); // 输出链表b

    printf("删除链表a中与链表b具有相同学号的节点后，链表a：\n");
    delSameNodes(a, b); // 删除链表a中与链表b具有相同学号的节点
    printList(a, 0); // 输出链表a

    return 0;
}

运行程序，输入每个节点的学号和姓名，输出链表a和链表b，然后输出删除链表a中与链表b具有相同学号的节点后的链表a。

### 回答2：
可以使用C语言编写一个程序来实现该功能。首先我们需要定义一个节点的结构体，包含学号和姓名两个字段：

#include <stdio.h>
#include <string.h>

#define MAX_NODES 6

typedef struct Node {
    int studentId;
    char name[20];
    struct Node* next;
} Node;

接下来，我们可以实现一个函数来创建一个节点，该函数从键盘输入学号和姓名，并返回创建的节点：

Node* createNode() {
    Node* newNode = (Node*)malloc(sizeof(Node));
    printf("请输入学号：");
    scanf("%d", &(newNode->studentId));
    printf("请输入姓名：");
    scanf("%s", newNode->name);
    newNode->next = NULL;
    return newNode;
}

然后，我们可以实现函数来创建链表a和链表b，每个链表包含6个节点，调用createNode()函数来逐个创建节点，并将新节点加入链表的末尾：

void createList(Node** head) {
    *head = createNode();
    Node* temp = *head;
    
    int i;
    for(i = 1; i < MAX_NODES; i++) {
        temp->next = createNode();
        temp = temp->next;
    }
}

接下来，我们实现一个函数来删除链表a中与链表b具有相同学号的节点，传入两个链表的头指针，遍历链表a和b，比较学号，如果学号相同，则删除链表a中的节点：

void deleteCommonNodes(Node* listA, Node* listB) {
    Node* tempA = listA;
    Node* prevA = NULL;
    while (tempA != NULL) {
        Node* tempB = listB;
        while (tempB != NULL) {
            if (tempA->studentId == tempB->studentId) {
                if (prevA == NULL) {
                    listA = tempA->next;
                    free(tempA);
                    tempA = listA;
                } else {
                    prevA->next = tempA->next;
                    free(tempA);
                    tempA = prevA->next;
                }
                break;
            }
            tempB = tempB->next;
        }
        if (tempB == NULL) {
            prevA = tempA;
            tempA = tempA->next;
        }
    }
}

最后，我们编写一个函数来输出链表a的节点，遍历链表a，并逐个输出学号和姓名：

void printList(Node* head) {
    Node* temp = head;
    while (temp != NULL) {
        printf("学号：%d, 姓名：%s\n", temp->studentId, temp->name);
        temp = temp->next;
    }
}

在主函数中，我们可以使用以上函数来实现功能：

int main() {
    Node* listA = NULL;
    Node* listB = NULL;
    
    printf("创建链表A：\n");
    createList(&listA);
    
    printf("创建链表B：\n");
    createList(&listB);
    
    printf("链表A删除与链表B具有相同学号的节点后的结果：\n");
    deleteCommonNodes(listA, listB);
    printList(listA);
    
    return 0;
}

以上就是用C语言编写一个程序的示例，该程序会创建两个包含6个节点的链表a和链表b。然后它会从链表a中删除与链表b中具有相同学号的节点，并输出链表a。

### 回答3：
实现该程序的思路如下：
1. 首先定义一个链表节点的结构体，包含学号和姓名两个成员变量。
2. 接着定义链表a和链表b，每个链表包含6个节点。
3. 通过循环从键盘输入链表a和链表b的节点的学号和姓名。
4. 对于链表a中的每个节点，依次遍历链表b中的节点，判断学号是否相同。若相同，则删除链表a中的该节点。
5. 最后输出删除后的链表a的所有节点的学号和姓名。

以下是具体的实现代码：

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

// 定义链表节点的结构体
typedef struct Node {
    int number; // 学号
    char name[20]; // 姓名
    struct Node* next; // 指向下一个节点的指针
} Node;

// 定义链表头节点指针
Node* head_a;
Node* head_b;

// 创建节点
Node* createNode(int number, char* name) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }
    newNode->number = number;
    strcpy(newNode->name, name);
    newNode->next = NULL;
    return newNode;
}

// 插入节点到链表
void insertNode(Node** head, int number, char* name) {
    Node* newNode = createNode(number, name);
    if (*head == NULL) {
        *head = newNode;
    } else {
        Node* temp = *head;
        while (temp->next != NULL) {
            temp = temp->next;
        }
        temp->next = newNode;
    }
}

// 删除与链表b中具有相同学号的节点
void deleteSameNodesFromList() {
    Node* temp_a = head_a;
    Node* temp_b = head_b;
    
    while (temp_a != NULL && temp_b != NULL) {
        if (temp_a->number == temp_b->number) {
            // 删除temp_a节点
            Node* pre_a = head_a;
            if (pre_a == temp_a) {
                head_a = temp_a->next;
                free(temp_a);
                temp_a = head_a;
            } else {
                while (pre_a->next != temp_a) {
                    pre_a = pre_a->next;
                }
                pre_a->next = temp_a->next;
                free(temp_a);
                temp_a = pre_a->next;
            }
        } else {
            temp_a = temp_a->next;
        }
        
        temp_b = temp_b->next;
    }
}

// 输出链表的所有节点
void printList() {
    Node* temp = head_a;
    while (temp != NULL) {
        printf("学号：%d，姓名：%s\n", temp->number, temp->name);
        temp = temp->next;
    }
}

int main() {
    // 初始化头节点指针
    head_a = NULL;
    head_b = NULL;
    
    printf("请输入链表a的学号和姓名：\n");
    for (int i = 0; i < 6; i++) {
        int number;
        char name[20];
        scanf("%d %s", &number, name);
        insertNode(&head_a, number, name);
    }
    
    printf("请输入链表b的学号和姓名：\n");
    for (int i = 0; i < 6; i++) {
        int number;
        char name[20];
        scanf("%d %s", &number, name);
        insertNode(&head_b, number, name);
    }
    
    deleteSameNodesFromList(); // 删除与链表b中具有相同学号的节点
    
    printf("删除后的链表a为：\n");
    printList(); // 输出链表a
    
    return 0;
}

以上是使用C语言编写的一个删除链表a中与链表b具有相同学号的节点，并输出链表a的程序。程序首先定义了链表节点的结构体，然后根据输入创建链表a和链表b，并通过遍历链表a的每个节点，在链表b中查找是否存在相同学号的节点，若存在，则删除链表a中的该节点。最后输出删除后的链表a的所有节点。