Зацініть ще такий алгоритм.

Нам було б добре розділити той список на дві рівні частини, а потім змінити напрямок зв'язків в одній половині, і пройтися відразу по обом половинам, порівнюючи їхні значення.

Але виникає питання, як нам знайти першу половину списку, якшо ми не знаємо довжини? Можна спершу пройтися по всім ланкам, порахувати їхню кількість, а потім пройтися знову, але лише до половини кількості.

А чи можна це зробити в один прохід? Можна.

let slow = head;
    let fast = head;
    
    //finding middle node
    while(fast !== null && fast.next !== null){
        fast = fast.next.next;
        slow = slow.next;
    }

хіба не це прекольно?

А чог оце є O(n) ? Ми ж виконуємо 1 операцію порівняння відразу для двох елементів списку, а не для кожного окремого елементу.

Може я вже знаю, але мені треба підтвердження?

Ну тобто (довжина)+(кількість одиниць)-1. Довжину можна логарифмом знайти, а от кількість одиниць... гм...

схоже, формули без ітерацій немає.

Задачка така є.
Нехай у нас є два зв'язаних списки довільної довжини. Кожна ланка списку тримає в собі значення якоїсь циферки від 0 до 9, а сам список являє собою певне число, але воно представлене в зворотньому напрямку, тобто, число 123 буде представлене списком
3 -> 2 -> 1

Нам треба додати два таких числа, і повернути результат у вигляді подібного зв'язного списку, наприклад:

3 -> 2 -> 1
+
1 -> 2 -> 3
=
4 -> 4 -> 4

на leetcode це завдання ніби Medium, але не таке вже й складне.

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     val: number
 *     next: ListNode | null
 *     constructor(val?: number, next?: ListNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.next = (next===undefined ? null : next)
 *     }
 * }
 */

function addTwoNumbers(l1: ListNode | null, l2: ListNode | null): ListNode | null {
  const sumHead = new ListNode();
  let currSumNode = sumHead;
  let rest = 0;
  
  let head1 = l1;
  let head2 = l2;
  
  while (head1 || head2) {

    const val1 = head1?.val ?? 0;
    const val2 = head2?.val ?? 0;
    
    const sum = val1 + val2;
    
    currSumNode.val = (sum + rest) % 10 ;
    rest = Math.floor((sum + rest) / 10);
    
    head1 = head1?.next;
    head2 = head2?.next;
    
    if (head1 || head2) {
      const nextSumNode = new ListNode();
      currSumNode.next = nextSumNode;
      currSumNode = nextSumNode;
    } else {
      break;
    }
  }
  
  if (rest) {
    currSumNode.next = new ListNode(rest);
  }
    
  return sumHead;
};

1. Шукаємо індекс останнього максимального елементу масиву, та запам’ятовуємо його. (id_end = max ≤ a(i), де i = 0 ... N-1)
2. Шукаємо індекс першого максимального елементу масиву (id_beg = max < a(i), де i = 0 ... id_end коли значення елемента масиву збігається із значенням масиву з попереднім кроком 1.) або id_beg = max < a(i), де i = 0 ... N-2 у найгіршому випадку, коли — значення менше за попередній максимальний елемент, виключаючи індекс останнього максимального елементу із кроку 1.
3. Тоді за цими індексами беремо значення, висоти перегородки. Шукаємо серед них мінімальне значення, якщо такий є (мається на увазі рівність між цими двома максимальними елементами).
4. Відстань між індексами за модулем, множимо на найменший серед максимальних елементів.

Якось так...

Це як?

Ви хотіли сказати "менший серед двох найбільших"? Бо максимальний може бути лише один. Якщо мова не про локальні максимуми.
Усе одно не зовсім розумію вашу ідею. Я б розв'язував так.
1. Обираємо дві крайні перетинки, обчислюємо, скільки там можна води налити.
2. В циклі:
2.1. Беремо нижчу з двох обраних, шукаємо першу вищу за неї (з початку - праворуч, з кінця - ліворуч). Якщо обидві однакові - шукаємо нові замість обох. Якщо немає куди далі шукати - завершуємо цикл.
2.2. Перевіряємо, скільки води тепер можна налити. Якщо більше - запам'ятовуємо.