设计一个算法，查找带头结点的非空单链表L中第一个最大结点（最大结点可能有多个），并返回该结点的逻辑序号。

1. 初始化最大结点的逻辑序号为1，最大值为头结点的下一个结点的数据域；
2. 从头结点的下一个结点开始遍历单链表，如果当前结点的数据域大于最大值，则更新最大值和最大结点的逻辑序号；
3. 继续遍历直到链表末尾，返回最大结点的逻辑序号。

代码实现：

int findMaxNodePosition(ListNode* L) {
    int maxPos = 1;
    int maxVal = L->next->val;
    ListNode* p = L->next;
    int pos = 1;
    while (p != nullptr) {
        if (p->val > maxVal) {
            maxVal = p->val;
            maxPos = pos;
        }
        p = p->next;
        pos++;
    }
    return maxPos;
}

相关问题

设计一个算法，查找带头结点的非空单链表l中第一个最大结点（最大结点可能有多个），并返回该结点的逻辑序号。

算法如下：

1. 定义一个变量max记录当前最大值，初始值为l的第一个结点的值，定义一个变量index记录当前最大值的逻辑序号，初始值为1。

2. 从l的第二个结点开始遍历整个链表，如果当前结点的值大于max，则更新max为当前结点的值，同时更新index为当前结点的逻辑序号。

3. 遍历完整个链表后，返回index即可。

代码实现：

int findMaxNode(Node* l) {
int max = l->next->data;
int index = 1;
Node* p = l->next->next;
int i = 2;
while (p != NULL) {
if (p->data > max) {
max = p->data;
index = i;
}
p = p->next;
i++;
}
return index;
}

用C语言设计一个算法，查找带头结点的非空单链表L中第一个最大结点（最大结点可能有多个），并返回该结点的逻辑序号。

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

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

void createList(Node** L) {
    *L = (Node*)malloc(sizeof(Node));
    (*L)->next = NULL;
    Node* p = *L;
    int x;
    while (scanf("%d", &x) != EOF) {
        Node* newNode = (Node*)malloc(sizeof(Node));
        newNode->data = x;
        newNode->next = NULL;
        p->next = newNode;
        p = newNode;
    }
}

int findMax(Node* L) {
    int max = L->next->data;
    int index = 1;
    int maxIndex = 1;
    Node* p = L->next;
    while (p != NULL) {
        if (p->data > max) {
            max = p->data;
            maxIndex = index;
        }
        index++;
        p = p->next;
    }
    return maxIndex;
}

int main() {
    Node* L;
    createList(&L);
    int maxIndex = findMax(L);
    printf("%d", maxIndex);
    return 0;
}