Second Largest Number in a linked list in JavaScript

class Node {
    constructor(data) {
        this.data = data;
        this.next = null;
    }
}

class LinkedList {
    constructor() {
        this.head = null;
    }

    addNode(data) {
        const newNode = new Node(data);
        if (!this.head) this.head = newNode;
        else {
            let curr = this.head;
            while (curr.next) curr = curr.next;
            curr.next = newNode;
        }
    }

    secondLargest() {
        if (!this.head || !this.head.next) {
            console.log("Finding the second largest number" +
                " is not possible in this linked list.");
            return;
        }

        let max1 = Number.NEGATIVE_INFINITY;
        let max2 = Number.NEGATIVE_INFINITY;

        let curr = this.head;

        while (curr) {
            if (curr.data > max1) {
                max2 = max1;
                max1 = curr.data;
            } else if (curr.data > max2 &&
                curr.data !== max1) {
                max2 = curr.data;
            }
            curr = curr.next;
        }

        if (max2 === Number.NEGATIVE_INFINITY) {
            console.log
            ("All elements in the linked list are equal.");
        }
        else {
            console.log
            (`The second largest number in the linked list is ${max2}`);
        }
    }
}

const linkedList = new LinkedList();
linkedList.addNode(31);
linkedList.addNode(12);
linkedList.addNode(71);
linkedList.addNode(5);

linkedList.secondLargest();

class Node {
    constructor(data) {
        this.data = data;
        this.next = null;
    }
}

class LinkedList {
    constructor() {
        this.head = null;
    }

    addNode(data) {
        const newNode = new Node(data);
        if (!this.head) {
            this.head = newNode;
        } else {
            let curr = this.head;
            while (curr.next) {
                curr = curr.next;
            }
            curr.next = newNode;
        }
    }

    secondLargestRecursive(node = this.head) {
        if (!node) {
            return {
                max: Number.NEGATIVE_INFINITY,
                secondMax: Number.NEGATIVE_INFINITY
            };
        }

        const remain =
            this.secondLargestRecursive(node.next);

        if (node.data > remain.max) {
            return {
                max: node.data,
                secondMax: remain.max
            };
        } else if (node.data > remain.secondMax) {
            return {
                max: remain.max,
                secondMax: node.data
            };
        } else {
            return remain;
        }
    }
}

const linkedList = new LinkedList();
linkedList.addNode(97);
linkedList.addNode(98);
linkedList.addNode(132);
linkedList.addNode(100);



const { secondMax } =
    linkedList.secondLargestRecursive();

if (secondMax === Number.NEGATIVE_INFINITY) {
    console.log(
        "Finding the second largest number is not possible in this linked list.");
} else {
    console.log(`The second largest number in the linked list is ${secondMax}`);
}