请求协助分析归并排序优化版本的时间复杂度

我编写了一款可能更优的归并排序版本，现寻求专业人士协助进行时间复杂度分析。

我的思路是：数组通常存在部分有序的情况，与其将数组拆分为大小为1的子数组再合并，不如直接合并这些部分有序的子数组。例如数组[1,4,2,3]，直接合并[1,4]和[2,3]即可。

该算法首先扫描整个数组以获取部分有序段的位置，将这些段的起止位置存入栈中，反复扫描数组并利用这些位置进行合并，最后合并剩余未处理的部分。

我自己的时间复杂度分析为：最优情况（数组已完全有序）下为O(n)，最坏情况（数组逆序）下为O(nlogn)。

function merge_across(arr) {
  let stack = getSortedSectionsStack(arr);
  let tempStack = [];
  while(stack.length > 3) {
    let end2 = stack.pop();
    let start2 = stack.pop();
    let end = stack.pop();
    let start = stack.pop();
    merge_two_sections(start, end, start2, end2, arr);
    tempStack.push(end2);
    tempStack.push(start);
    if(stack.length == 0) {
      while(tempStack.length > 3) {
        stack.push(tempStack.pop());
        stack.push(tempStack.pop());
        stack.push(tempStack.pop());
        stack.push(tempStack.pop());
      }
    }
  }
  let start = 0;
  let end = find_end_of_sort(start, arr);
  let start2 = end + 1;
  let end2 = find_end_of_sort(start2, arr);
  if(start2 < arr.length) {
    merge_two_sections(start, end, start2, end2, arr);
  }
  return arr;
}

function merge_two_sections(start, end, start2, end2, arr) {
  let merged_section = new Array(end2 - start + 1);
  let merge_index = 0;
  let original_start = start;
  while(start <= end && start2 <= end2) {
    if(arr[start] < arr[start2]) {
      merged_section[merge_index] = arr[start];
      start++;
    }
    else if(arr[start2] <= arr[start]) {
      merged_section[merge_index] = arr[start2];
      start2++;
    }
    merge_index++;
  }
  while(start <= end) {
    merged_section[merge_index] = arr[start];
    start++;
    merge_index++;
  }
  while(start2 <= end2) {
    merged_section[merge_index] = arr[start2];
    start2++;
    merge_index++;
  }
  for(let i = 0; i < merged_section.length; i++) {
    arr[original_start] = merged_section[i];
    original_start++;
  }
}

function find_end_of_sort(start, arr) {
  while(start < arr.length - 1 && arr[start] < arr[start + 1]) {
    start++;
  }
  return start;
}

内容的提问来源于stack exchange，提问作者user13204465