单链表中偶数位序的元素

可以通过遍历单链表，使用一个计数器记录当前节点位置，然后判断当前节点位置是否为偶数位，如果是则将该节点的值记录下来。具体实现如下：

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

vector<int> evenNodes(ListNode* head) {
    vector<int> res;
    int count = 1;
    while (head) {
        if (count % 2 == 0) {
            res.push_back(head->val);
        }
        count++;
        head = head->next;
    }
    return res;
}

其中，使用一个计数器 count 记录当前节点的位置，初始值为 1，表示第一个节点。每次遍历到一个节点，就将计数器加一。然后判断当前节点位置是否为偶数位，如果是则将该节点的值记录到 res 中。最后返回 res 即可。

时间复杂度为 O(n)，其中 n 为单链表的长度。

相关问题

c语言统计单链表中偶数位序的元素和并输出元素值。

以下是一个示例代码：

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

// 定义链表结构体
typedef struct Node {
    int data;
    struct Node *next;
} Node;

// 创建链表
Node* createLinkedList(int n) {
    Node *head = NULL, *tail = NULL;
    for (int i = 1; i <= n; i++) {
        Node *node = (Node*)malloc(sizeof(Node));
        node->data = i;
        node->next = NULL;
        if (i == 1) {
            head = node;
            tail = node;
        } else {
            tail->next = node;
            tail = node;
        }
    }
    return head;
}

// 统计偶数位序的元素和并输出元素值
void sumEvenNodes(Node *head) {
    int sum = 0;
    int count = 1;
    Node *p = head;
    while (p) {
        if (count % 2 == 0) {
            sum += p->data;
            printf("%d ", p->data);
        }
        count++;
        p = p->next;
    }
    printf("\nThe sum of even nodes is %d\n", sum);
}

int main() {
    int n = 10;
    Node *head = createLinkedList(n);
    sumEvenNodes(head);
    return 0;
}

首先定义了一个链表结构体，包含元素值和指向下一个节点的指针。然后定义了创建链表的函数 `createLinkedList`，它会创建一个包含 `n` 个节点的链表，并返回链表头节点的指针。

接着是统计偶数位序的元素和并输出元素值的函数 `sumEvenNodes`。它使用了一个计数器 `count` 来判断当前节点的序号，如果是偶数位序，就累加元素值到变量 `sum` 中，并输出元素值。最后输出偶数位序的元素和。

在主函数中，我们创建了一个包含 10 个节点的链表，并调用 `sumEvenNodes` 函数来统计偶数位序的元素和并输出元素值。

运行程序，输出如下：

2 4 6 8 10 
The sum of even nodes is 30

统计单链表中偶数位序的元素和并输出元素值。

假设单链表的头节点为head，以下是一种可能的实现：

def sum_even_nodes(head):
    curr = head
    index = 1
    total = 0
    while curr:
        if index % 2 == 0:
            total += curr.val
            print(curr.val)
        curr = curr.next
        index += 1
    return total

解释：

1. 定义当前节点curr为链表头节点head；
2. 定义序号index为1，用于记录当前节点的位置；
3. 定义总和total为0，用于累加偶数位节点的值；
4. 当curr不为空时，执行以下操作：
- 如果当前节点是偶数位（即index % 2 == 0），则将其值累加到总和total中，并输出节点值；
- 将当前节点更新为下一个节点curr.next；
- 将序号index加1，表示当前节点的位置加1；
5. 循环结束后，返回总和total。

注意，上述代码中的val和next是假设单链表节点的属性，具体实现可能会有所不同。