建立单链表存储数据（10，20，30，40，50，60，70，80，90，100），要求： 1）头插法或尾插法建立单链表，并输出单链表中所有元素； 2）输出单链表中的最大值和最小值； 3）键盘输入一个值 x，输出链表中第一个值为 x 的元素的位序； 4）键盘输入一位序值 b，在第 b 个元素之前插入值为 500 的元素，输出链表中的 所有数据； 5）键盘输入位序值 m，删除位序为 m 的元素，输出链表中的所有数据； 6）输出单链表的长度。 （要求尽量将每一个操作模块化，建议将链表头指针设置成全局变量。）

单链表的建立与操作

1. 头插法或尾插法建立单链表

单链表可以通过头插法或尾插法来建立。头插法是将新元素插入到链表的头部，而尾插法则是将新元素添加到链表的尾部。以下是使用尾插法建立单链表的示例代码：

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

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

Node *head = NULL; // 定义头指针

void createListTail(int *arr, int size) {
    Node *newNode, *tail;
    for (int i = 0; i < size; i++) {
        newNode = (Node *)malloc(sizeof(Node));
        newNode->data = arr[i];
        newNode->next = NULL;
        if (head == NULL) {
            head = newNode;
            tail = head;
        } else {
            tail->next = newNode;
            tail = newNode;
        }
    }
}

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

2. 输出单链表中的最大值和最小值

遍历单链表，记录并比较每个节点的值，以找到最大值和最小值。

int findMax(Node *head) {
    int max = head->data;
    Node *temp = head->next;
    while (temp != NULL) {
        if (temp->data > max) {
            max = temp->data;
        }
        temp = temp->next;
    }
    return max;
}

int findMin(Node *head) {
    int min = head->data;
    Node *temp = head->next;
    while (temp != NULL) {
        if (temp->data < min) {
            min = temp->data;
        }
        temp = temp->next;
    }
    return min;
}

3. 输出链表中第一个值为 x 的元素的位序

从链表头部开始遍历，找到第一个值为 x 的元素，并记录其位序。

int findPosition(Node *head, int x) {
    int position = 1;
    Node *temp = head;
    while (temp != NULL) {
        if (temp->data == x) {
            printf("The first element with value %d is at position %d.\n", x, position);
            return position;
        }
        temp = temp->next;
        position++;
    }
    printf("Value %d not found in the list.\n", x);
    return -1;
}

4. 在第 b 个元素之前插入值为 500 的元素

首先找到第 b-1 个元素，然后在这个元素之后插入新节点。

void insertBefore(Node *head, int position, int value) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->data = value;
    newNode->next = NULL;
    if (position == 1) {
        newNode->next = head;
        head = newNode;
    } else {
        Node *temp = head;
        for (int i = 1; i < position - 1 && temp != NULL; i++) {
            temp = temp->next;
        }
        if (temp == NULL) {
            printf("Position out of range.\n");
        } else {
            newNode->next = temp->next;
            temp->next = newNode;
        }
    }
}

5. 删除位序为 m 的元素

找到位序为 m-1 的元素，然后删除其后继节点。

void deleteNode(Node *head, int position) {
    if (position == 1) {
        head = head->next;
    } else {
        Node *temp = head;
        for (int i = 1; i < position - 1 && temp != NULL; i++) {
            temp = temp->next;
        }
        if (temp == NULL || temp->next == NULL) {
            printf("Position out of range.\n");
        } else {
            Node *toDelete = temp->next;
            temp->next = toDelete->next;
            free(toDelete);
        }
    }
}

6. 输出单链表的长度

遍历链表，计数节点数量。

int listLength(Node *head) {
    int length = 0;
    Node *temp = head;
    while (temp != NULL) {
        length++;
        temp = temp->next;
    }
    return length;


 ## 单链表的头插法和尾插法有何区别？
单链表的头插法和尾插法是两种不同的插入操作方式，它们在单链表的构建和数据插入过程中有着明显的区别。

1. **头插法**：在头插法中，新元素总是被插入到链表的头部，即新节点成为链表的第一个节点。这种方式在插入操作时，需要将新节点的指针指向原链表的第一个节点，然后将原链表的第一个节点的指针指向新节点。这样，新节点就成为了链表的头节点。头插法在插入时不需要遍历链表，因此插入操作的时间复杂度为O(1)。但是，由于新节点总是插入到头部，这可能会导致链表的头节点频繁地移动，从而影响性能。<a data-index="0" class='citation' href="#citation-1" target="_blank">1</a>

2. **尾插法**：与头插法不同，尾插法将新元素插入到链表的尾部。在尾插法中，首先需要遍历整个链表找到最后一个节点，然后将新节点的指针指向当前的最后一个节点，并将最后一个节点的指针指向新节点。这样，新节点就成为了链表的最后一个节点。尾插法的插入操作时间复杂度为O(n)，其中n是链表的长度，因为需要遍历整个链表来找到最后一个节点。然而，尾插法在插入时不需要频繁地移动头节点，因此在某些情况下可能更加高效。<a data-index="1" class='citation' href="#citation-2" target="_blank">2</a>

总结来说，头插法和尾插法的主要区别在于插入位置的不同，头插法在头部插入，而尾插法在尾部插入。头插法的插入操作更快，但可能影响性能；尾插法则需要遍历链表，但对头节点的影响较小。选择哪种方法取决于具体的应用场景和性能需求。<a data-index="2" class='citation' href="#citation-3" target="_blank">3</a>

 ## 如何使用头插法和尾插法实现单链表的插入操作？
头插法和尾插法是两种常见的单链表插入操作方式，它们分别在链表的头部和尾部进行插入。以下是这两种方法的实现步骤：

### 头插法

1. **创建新节点**：首先，需要创建一个新的节点，该节点将包含要插入的数据。
2. **更新新节点指针**：将新节点的`next`指针指向当前链表的头节点。
3. **更新头节点**：将链表的头节点更新为新节点，这样新节点就成为了链表的第一个元素。
4. **特殊情况处理**：如果链表为空（即头节点为`null`），则新节点同时成为头节点和尾节点。

### 尾插法

1. **创建新节点**：与头插法相同，首先创建一个包含要插入数据的新节点。
2. **寻找尾节点**：遍历链表，找到最后一个节点，即`next`指针为`null`的节点。
3. **更新尾节点指针**：将找到的尾节点的`next`指针指向新节点。
4. **更新尾节点**：如果链表为空，新节点将成为新的尾节点。

这两种方法各有优缺点。头插法在插入时不需要遍历整个链表，适用于频繁在头部插入的场景，但可能会导致链表的尾部访问效率降低。尾插法则适用于需要在尾部频繁插入的场景，但每次插入都需要遍历整个链表，可能会影响效率。

在实际应用中，选择哪种方法取决于具体的需求和场景。如果需要频繁在链表头部进行操作，头插法可能更为合适；如果操作主要集中在链表尾部，尾插法则可能更加高效。<a data-index="3" class='citation' href="#citation-1" target="_blank">1</a>

 ## 单链表的删除操作如何实现？
单链表的删除操作通常涉及以下几个步骤：

1. **确定要删除的节点**：首先，需要确定要删除的节点。这通常通过遍历链表来实现，直到找到目标节点。如果链表中存在头节点，删除操作可能需要特别处理头节点的情况。

2. **更新前驱节点的指针**：在找到要删除的节点后，需要更新其前驱节点的指针，使其指向要删除节点的下一个节点。这一步是删除操作的关键，因为它确保了链表的连续性。

3. **释放要删除节点的内存**：如果使用的是动态分配的内存，删除节点后需要释放其占用的内存，以避免内存泄漏。

4. **处理特殊情况**：如果删除的是头节点，需要更新链表的头指针指向新的头节点。如果链表为空，删除操作可能不需要执行任何操作。

具体的实现方式会根据编程语言和链表的具体实现细节有所不同。例如，在C语言中，删除操作可能涉及到指针的直接操作，而在Python中，可能涉及到对象的引用计数和垃圾回收机制。

请注意，上述步骤是单链表删除操作的一般性描述，具体的实现细节可能会根据具体的编程环境和需求有所变化。<a data-index="4" class='citation' href="#citation-1" target="_blank">1</a>

 ## 单链表的最大值和最小值如何确定？
单链表是一种线性数据结构，由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。要确定单链表的最大值和最小值，可以采用以下步骤：

1. **初始化**：首先，需要两个变量来存储遍历过程中找到的最大值和最小值。可以假设链表的第一个节点的值是初始的最大值和最小值。

2. **遍历链表**：从链表的头节点开始，逐个访问链表中的每个节点。在访问每个节点时，比较当前节点的值与已存储的最大值和最小值。

3. **更新最大值和最小值**：如果当前节点的值大于已存储的最大值，则更新最大值；如果当前节点的值小于已存储的最小值，则更新最小值。

4. **结束遍历**：当访问完链表的最后一个节点后，结束遍历。此时，存储的最大值和最小值即为链表的最大值和最小值。

这种方法的时间复杂度为O(n)，其中n是链表的长度，因为需要遍历整个链表来确定最大值和最小值。这种方法不需要额外的存储空间，空间复杂度为O(1)。<a data-index="5" class='citation' href="#citation-1" target="_blank">1</a>

 ## 单链表的长度如何计算？
单链表的长度可以通过遍历链表中的每个节点来计算。具体方法是从链表的头节点开始，逐个访问链表中的每个节点，每访问一个节点，计数器就增加1，直到遍历到链表的尾节点，此时计数器的值即为链表的长度。这种方法简单直观，但需要遍历整个链表，时间复杂度为O(n)，其中n是链表的长度。<a data-index="6" class='citation' href="#citation-1" target="_blank">1</a>