提交与自己学号相邻的两位同学的学号与一门考试成绩，编程建立由这三组数据结点组成的简单链表。 【输入形式】三组同学的学号后三位，成绩 【输出形式】链表各节点的数据

好的，这是一个链表的基础操作，我可以为您提供一份 Python 代码实现。

class Node:
    def __init__(self, no, score):
        self.no = no
        self.score = score
        self.next = None

def create_linked_list():
    head = Node(0, 0)
    tail = head
    for i in range(3):
        no = input("请输入学号后三位：")
        score = input("请输入考试成绩：")
        node = Node(no, score)
        tail.next = node
        tail = node
    return head.next

if __name__ == "__main__":
    linked_list = create_linked_list()
    while linked_list:
        print("学号：{}, 成绩：{}".format(linked_list.no, linked_list.score))
        linked_list = linked_list.next

您可以按照输入形式依次输入三组数据，代码会自动构建链表，并输出链表每个节点的数据。

相关问题

提交与自己学号相邻的两位同学的学号与一门考试成绩，编程建立由这三组数据结点组成的简单链表

### 回答1：
首先，你需要定义一个结构体，来存储学号和成绩的信息。然后，你可以创建三个结构体变量，分别代表与你学号相邻的两位同学和你自己，并给它们赋值。最后，你需要让它们相互连接，以形成一个链表。

代码示例（C语言）：

struct node {
    int num;
    int score;
    struct node *next;
};

int main() {
    struct node stu1, stu2, stu3;
    stu1.num = 12345;
    stu1.score = 80;
    stu2.num = 12346;
    stu2.score = 85;
    stu3.num = 12347;
    stu3.score = 90;

    stu1.next = &stu2;
    stu2.next = &stu3;
    stu3.next = NULL;

    return 0;
}

### 回答2：
首先，我们需要一个节点的结构体来存储学号和考试成绩的信息：

struct Node{
int xuehao;
int score;
struct Node* next;
};

其中，xuehao表示学号，score表示考试成绩，next表示指向下一个节点的指针。

接下来，我们可以编写一个函数来创建这个链表，按照学号的顺序插入节点，并且从输入中读取学号和考试成绩。假设学号和考试成绩分别存储在xuehao和score两个数组中：

struct Node* createList(int* xuehao, int* score){
struct Node* head = NULL;
struct Node* p;
for(int i=0; i<2; i++){
struct Node* newnode = (struct Node*)malloc(sizeof(struct Node));
newnode->xuehao = xuehao[i];
newnode->score = score[i];
newnode->next = NULL;
if(head == NULL){
head = newnode;
p = newnode;
}
else{
while(p->next != NULL && p->next->xuehao < xuehao[i]){
p = p->next;
}
newnode->next = p->next;
p->next = newnode;
p = head;//改变p的位置，重新从头开始查找
}
}
return head;
}

此时，我们已经成功地创建了一个由三个节点组成的简单链表。接下来，可以编写一个函数来遍历这个链表，输出每一个节点的学号和考试成绩：

void printList(struct Node* head){
struct Node* p = head;
while(p != NULL){
printf("学号：%d，考试成绩：%d\n", p->xuehao, p->score);
p = p->next;
}
}

最终，在主函数中，我们可以调用这两个函数，实现整个程序的功能：

int main(){
int xuehao[] = {1001, 1002, 1003};
int score[] = {80, 90, 85};
struct Node* head = createList(xuehao, score);
printList(head);
return 0;
}

输出结果如下：

学号：1001，考试成绩：80
学号：1002，考试成绩：90
学号：1003，考试成绩：85

### 回答3：
在建立该链表之前，我们需要先明确链表的概念。链表是一种常见的数据结构，也是一种线性表，它通过指针将一些节点串联起来，形成一个序列，并且可以按照一定的顺序进行访问。链表中的每个节点都包含了两个部分，一个是存储数据的部分，另一个是指向下一个节点的指针。每个节点的指针都指向它后面的那个节点，这是链表的一个最显著的特点。

接下来，根据题目要求，我们假设自己的学号是A，那么与自己学号相邻的两位同学的学号应该分别是B和C。同时，我们还需要知道这三个人在某一门课程的成绩，假设这门课程的名称为Math，那么学号A、B、C在Math课程的成绩分别为90、85和95分。

现在，我们可以开始编写链表的数据结构了，每个节点应该包含三个部分：学号、成绩和指向下一个节点的指针。我们可以定义一个结构体来表示这些节点，代码如下：

struct Node {
    char ID[20];
    int score;
    Node* next;
};

其中，ID表示学号，score表示成绩，next表示指向下一个节点的指针。现在我们可以开始创建链表了，代码如下：

Node* createList() {
    Node* head = NULL;
    char id[20];
    int score;

    // 添加第一个节点
    cout << "请输入学号和成绩（以空格分隔）：";
    cin >> id >> score;
    Node* node = new Node();
    strcpy(node->ID, id);
    node->score = score;
    node->next = NULL;
    head = node;

    // 添加第二个节点
    if (strcmp(id, "A") == 0) {  // 如果输入的学号是A，那么B是下一个节点
        cout << "请输入学号B的成绩：";
        cin >> score;
        Node* node2 = new Node();
        strcpy(node2->ID, "B");
        node2->score = score;
        node2->next = NULL;
        head->next = node2;
    } else {  // 如果输入的学号是C，那么B是前一个节点
        cout << "请输入学号B的成绩：";
        cin >> score;
        Node* node2 = new Node();
        strcpy(node2->ID, "B");
        node2->score = score;
        node2->next = head;
        head = node2;
    }

    // 添加第三个节点
    cout << "请输入学号C的成绩：";
    cin >> score;
    Node* node3 = new Node();
    strcpy(node3->ID, "C");
    node3->score = score;
    node3->next = NULL;
    Node* p = head;
    while (p->next != NULL) {
        p = p->next;
    }
    p->next = node3;

    return head;
}

在上面的代码中，我们首先使用了一个指针head来表示链表的头结点，初始值为NULL。然后，我们添加了第一个节点，也就是自己的学号和成绩。接着，我们根据输入的学号判断B和C的相对位置，并分别添加了相应的节点。最后，我们添加了第三个节点C，将其添加到链表的末尾。

现在，我们已经创建好了这个链表，可以使用以下代码来打印所有节点的信息：

void printList(Node* head) {
    Node* p = head;
    while (p != NULL) {
        cout << p->ID << " " << p->score << endl;
        p = p->next;
    }
}

最后，我们可以在主函数中调用createList和printList来测试代码的效果：

int main() {
    Node* head = createList();
    printList(head);
    return 0;
}

完整的代码如下：

提交与自己学号相邻的两位同学的学号与一门考试成绩，编程建立由这三组数据结点组成的简单链表。

### 回答1：
首先, 需要先定义一个结点类:

class Node:
    def __init__(self, student_id, exam_score):
        self.student_id = student_id
        self.exam_score = exam_score
        self.next = None

然后, 可以按照如下方式创建链表:

# 创建结点
node1 = Node(学号1, 成绩1)
node2 = Node(学号2, 成绩2)
node3 = Node(学号3, 成绩3)
# 建立链接关系
node1.next = node2
node2.next = node3

这样, 便创建了由三个结点组成的链表, 其中结点1指向结点2, 结点2指向结点3.

如果需要遍历链表，可以使用如下代码

current_node = node1
while current_node:
    print(current_node.student_id, current_node.exam_score)
    current_node = current_node.next

上述代码将从第一个节点开始依次打印出每个节点的学号和成绩。

### 回答2：
为了建立这个简单链表，我们需要首先确定链表的数据结构。在这个问题中，每个数据结点包含三个数据元素：学号，考试成绩和下一个节点的指针。由于题目要求提交与自己学号相邻的两位同学的学号和考试成绩，我们可以将它们存储在一个结构体中，如下所示：

struct Node {
    int id;        // 学号
    int score;     // 考试成绩
    Node *next;    // 指向下一个节点的指针
};

在这个结构体中，我们定义了两个整型变量来存储学号和考试成绩，以及一个指向下一个节点的指针。接下来，我们可以编写代码来创建这个链表。

首先，我们需要定义三个数据结点，并将它们初始化为题目给定的数据。接着，我们将它们串联在一起，形成一个简单的链表。代码如下：

// 创建三个节点
Node *node1 = new Node;
node1->id = 20200001;
node1->score = 90;

Node *node2 = new Node;
node2->id = 20200002;
node2->score = 85;

Node *node3 = new Node;
node3->id = 20200003;
node3->score = 95;

// 将节点串联成一个链表
node1->next = node2;
node2->next = node3;
node3->next = nullptr;

在这个代码中，我们通过 `new` 运算符创建了三个数据结点，并将它们初始化为题目给定的数据。接着，我们使用箭头运算符 `->` 来访问结构体成员，并将它们串联在一起形成一个链表。注意，我们将最后一个节点的 `next` 指针设置为 `nullptr`，表示这个节点是链表的尾部。

最后，我们可以遍历整个链表，验证数据结点是否已经正确地串联在一起。代码如下：

// 遍历链表
Node *curr = node1;
while (curr != nullptr) {
    cout << "学号：" << curr->id << "，成绩：" << curr->score << endl;
    curr = curr->next;
}

在这个代码中，我们使用一个指针 `curr` 来遍历整个链表。每次遍历时，我们输出当前节点的学号和成绩，并将指针指向下一个节点。当指针指向 `nullptr` 时，表示已经遍历完整个链表。

### 回答3：
首先我们需要定义链表的结构体，以及节点的数据类型和指针类型：

struct Node {
    int num;
    int score;
    Node* next;
};
typedef Node* LinkList;

其中，`num`代表学号，`score`代表考试成绩，`next`代表指向下一个节点的指针。`LinkList`则是指向结构体`Node`的指针类型。

接下来，我们需要输入当前学生的学号和考试成绩，以及其他两位同学的学号和考试成绩。为了方便演示，我们先将其设置为固定值：

int myNum = 20210001;
int num1 = myNum - 1;
int score1 = 92;
int num2 = myNum + 1;
int score2 = 78;

然后，我们需要创建三个节点，并将它们依次连接起来，形成一个简单链表：

LinkList head = new Node();   // 创建头节点
head->num = myNum;
head->score = 80;

LinkList p = new Node();      // 创建第一个数据节点
p->num = num1;
p->score = score1;
p->next = NULL;

LinkList q = new Node();      // 创建第二个数据节点
q->num = num2;
q->score = score2;
q->next = NULL;

head->next = p;              // 将数据节点连接到头节点后面
p->next = q;

此时，我们就已经创建出了一个由三个节点组成的简单链表。它的结构如下图所示：

    +--------+       +--------+       +--------+
    | head   |------>|   p    |------>|   q    |
    +--------+       +--------+       +--------+
    | num:   |       | num:   |       | num:   |
    | score: |       | score: |       | score: |
    | next:  |------>| next:  |------>| next:  |
    +--------+       +--------+       +--------+

最后，我们可以使用循环遍历链表，并输出每个节点的学号和考试成绩：

LinkList temp = head;
while (temp != NULL) {
    cout << "学号：" << temp->num << "  ";
    cout << "成绩：" << temp->score << endl;
    temp = temp->next;
}

完整的代码如下所示：

#include <iostream>
using namespace std;

struct Node {
    int num;
    int score;
    Node* next;
};
typedef Node* LinkList;

int main() {
    int myNum = 20210001;
    int num1 = myNum - 1;
    int score1 = 92;
    int num2 = myNum + 1;
    int score2 = 78;

    LinkList head = new Node();   // 创建头节点
    head->num = myNum;
    head->score = 80;

    LinkList p = new Node();      // 创建第一个数据节点
    p->num = num1;
    p->score = score1;
    p->next = NULL;

    LinkList q = new Node();      // 创建第二个数据节点
    q->num = num2;
    q->score = score2;
    q->next = NULL;

    head->next = p;              // 将数据节点连接到头节点后面
    p->next = q;

    LinkList temp = head;
    while (temp != NULL) {
        cout << "学号：" << temp->num << "  ";
        cout << "成绩：" << temp->score << endl;
        temp = temp->next;
    }

    return 0;
}