单链表头节点后插入元素及遍历单链表

在单链表中，如果我们想在头节点之后插入新元素，通常会采用以下步骤：

1. **创建新节点**：首先，我们需要创建一个新的节点，并将其数据成员赋值为待插入的数据。

2. **指针更新**：将新节点的`next`指针指向当前的头节点，因为我们要让它成为新的头节点。

3. **头节点更新**：如果链表为空（即原来的头节点`null`），则将新节点设置为新的头节点。若链表非空，则只需修改新节点的`next`指针即可。

遍历单链表的常见方法是使用迭代或递归：

**迭代法**：

def iterate_list(head):
    current = head
    while current is not None:
        # 处理当前节点
        print(current.data)
        current = current.next

在这个函数里，我们从头节点开始，依次访问每个节点直到链表结束。

**递归法**（虽然不是最佳实践，但在某些特定场景下可以使用）：

def recursive_list(head):
    if head is not None:
        # 处理头节点
        print(head.data)
        # 递归处理剩余部分
        recursive_list(head.next)

这里，我们会先打印头节点，然后对下一个节点继续递归调用自身。

相关问题

用 while 循环实现单链表头节点后插入元素

在使用while循环实现单链表头部插入元素时，首先需要创建一个新的节点，并将它设置为当前链表的头结点。假设我们有一个指向当前头结点的指针`current`，以及新插入值`value`，步骤如下：

1. 创建新的节点`newNode`，并将其`next`属性设为`null`，因为我们要把它插入到链表的开头。
2. 如果链表为空（即`current`为`null`），那么直接让`newNode`成为新的头结点，即`head = newNode`。
3. 否则，进入while循环：
a. 将`current`指针更新为`current.next`，以便遍历到下一个结点。
b. 当`current`变为`null`时，说明已经到达了链表的末尾，这时将`newNode`设为`current`的前驱，即`current = newNode`。
4. 然后跳出循环，新节点成为了新的头结点。

这里是伪代码示例：

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

def insert_at_head(head, value):
    if head is None:
        newNode = Node(value)
        head = newNode
    else:
        newNode = Node(value)
        current = head
        while current.next is not None:
            current = current.next
        current.next = newNode
    return head

4、用结构体和指针实现单链表的应用，具体包含：建立单链表、在单链表中查找指定元素、在单链表中插入指定元素、删除单链表某个元素。

首先我们需要定义单链表的结构体，包含一个数据域和一个指向下一个节点的指针：

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

接下来我们可以定义一些操作函数，来实现单链表的应用。

1. 建立单链表

Node* createLinkedList(int arr[], int n) {
    Node *head = (Node*)malloc(sizeof(Node));
    head->next = NULL;
    Node *tail = head;
    for (int i = 0; i < n; i++) {
        Node *newNode = (Node*)malloc(sizeof(Node));
        newNode->data = arr[i];
        newNode->next = NULL;
        tail->next = newNode;
        tail = newNode;
    }
    return head;
}

该函数接受一个整型数组和数组长度，返回一个指向单链表头节点的指针。它首先创建一个空的头节点，然后遍历数组，创建新节点，将其插入到链表末尾。

2. 在单链表中查找指定元素

Node* findNode(Node *head, int target) {
    Node *p = head->next;
    while (p) {
        if (p->data == target) {
            return p;
        }
        p = p->next;
    }
    return NULL;
}

该函数接受一个指向单链表头节点的指针和一个目标值，返回指向目标节点的指针。它从头节点开始遍历链表，逐个比较节点的值，直到找到目标节点或遍历完整个链表。

3. 在单链表中插入指定元素

void insertNode(Node *head, int target, int value) {
    Node *p = head->next;
    while (p) {
        if (p->data == target) {
            Node *newNode = (Node*)malloc(sizeof(Node));
            newNode->data = value;
            newNode->next = p->next;
            p->next = newNode;
            return;
        }
        p = p->next;
    }
}

该函数接受一个指向单链表头节点的指针、一个目标值和一个待插入的值，将新节点插入到目标节点后面。它从头节点开始遍历链表，逐个比较节点的值，找到目标节点后，创建新节点，并将其插入到目标节点后面。

4. 删除单链表某个元素

void deleteNode(Node *head, int target) {
    Node *p = head->next;
    Node *prev = head;
    while (p) {
        if (p->data == target) {
            prev->next = p->next;
            free(p);
            return;
        }
        prev = p;
        p = p->next;
    }
}

该函数接受一个指向单链表头节点的指针和一个目标值，删除指定节点。它从头节点开始遍历链表，逐个比较节点的值，找到目标节点后，将其从链表中删除，并释放内存。