输入若干个不超过一百的整数，建立单链表，然后通过一趟遍历在单链表中确定值最小的结点，输出该结点的值

思路：

1. 定义一个链表节点结构体，包括值和指向下一个节点的指针。
2. 输入若干个整数，依次创建节点并将其加入链表的尾部。
3. 遍历链表，记录最小值及其对应的节点，最后输出最小值即可。

代码实现如下：

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

head = ListNode() # 创建一个空的头结点
p = head

n = int(input("请输入整数个数："))
for i in range(n):
    val = int(input("请输入一个整数："))
    node = ListNode(val)
    p.next = node
    p = node

# 遍历链表，找到最小值
min_val = head.next.val
min_node = head.next
p = head.next.next
while p:
    if p.val < min_val:
        min_val = p.val
        min_node = p
    p = p.next

print("最小值为：", min_val)

相关问题

输入若干个不超过100的整数，建立单链表，然后通过一趟遍历在单链表中确定值最小的结点。输出该结点的值

算法步骤：

1. 定义结点结构体，包含数据域和指针域。
2. 读入若干个整数，创建单链表。
3. 遍历单链表，记录当前最小值和对应的结点。
4. 输出最小值。

代码实现：

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

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

int main() {
    int n;
    scanf("%d", &n);

    // 创建头结点
    Node *head = (Node *) malloc(sizeof(Node));
    head->next = NULL;

    // 读入数据，创建单链表
    Node *p = head;
    for (int i = 0; i < n; i++) {
        int x;
        scanf("%d", &x);
        Node *q = (Node *) malloc(sizeof(Node));
        q->data = x;
        q->next = NULL;
        p->next = q;
        p = q;
    }

    // 遍历单链表，找到值最小的结点
    int min_val = head->next->data;  // 初始值为第一个结点的值
    Node *min_node = head->next;
    p = head->next->next;
    while (p != NULL) {
        if (p->data < min_val) {
            min_val = p->data;
            min_node = p;
        }
        p = p->next;
    }

    // 输出值最小的结点的值
    printf("%d\n", min_node->data);

    // 释放内存
    p = head->next;
    while (p != NULL) {
        Node *q = p;
        p = p->next;
        free(q);
    }
    free(head);

    return 0;
}

请解释输入若干个不超过100的整数，建立单链表，然后通过一趟遍历在单链表中确定值最小的结点。输出该结点的值

首先，建立单链表的过程如下：

1. 定义一个链表结构体，包含一个整型数据和一个指向下一个节点的指针。

2. 输入第一个整数，作为链表的头节点。

3. 依次输入剩下的整数，每输入一个整数就创建一个新节点，并将其加入链表末尾。

4. 输入完成后，返回头节点即可。

最小值结点的查找过程如下：

1. 定义一个指向链表头节点的指针，并定义一个整型变量用于存储最小值，初值为链表头节点的值。

2. 从头节点开始遍历整个链表，比较每个节点的值与最小值的大小，如果小于最小值，则将最小值更新为该节点的值，并记录该节点的指针。

3. 遍历完成后，输出最小值即可。

以下是示例代码：

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

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

Node* createList() {
    Node *head, *tail, *p;
    head = tail = (Node*) malloc(sizeof(Node));
    head->next = NULL;
    int num;
    scanf("%d", &num);
    while (num <= 100) {
        p = (Node*) malloc(sizeof(Node));
        p->data = num;
        p->next = NULL;
        tail->next = p;
        tail = p;
        scanf("%d", &num);
    }
    return head;
}

int findMin(Node *head, Node **minNode) {
    int minVal = head->next->data;
    Node *p = head->next;
    *minNode = p;
    while (p != NULL) {
        if (p->data < minVal) {
            minVal = p->data;
            *minNode = p;
        }
        p = p->next;
    }
    return minVal;
}

int main() {
    Node *head = createList();
    Node *minNode;
    int minVal = findMin(head, &minNode);
    printf("minVal = %d\n", minVal);
    return 0;
}