查找配对方法的时间复杂度

Question

我必须编写代码采取具有奇数个元素的排序双阵列，查找对值与它们之间的最短距离，并返回剩余的值，这被认为是'奇怪的'。以下是我写的代码，它的工作原理和返回正确的值。

是否有人可以帮助我找到了算法的时间复杂度我用？我尝试过，但它真的很混乱。

public static Double findPairs(Double[] data, int i, int j, int k, int count) { 

    Double oddNumber = -1.; 

    if ((k < data.length) && (diff(data[i], data[j]) <= diff(data[j], data[k]))) { 
     data[i] = (-1.); 
     data[j] = (-1.); 
     if (k == data.length - 1) { 
      for (int c = 0; c < data.length; c++) { 
       if (data[c] != -1.) { 
        i = c; 
        break; 
       } 
      } 
      if (i != k) { 
       for (int c = 0; c < data.length; c++) { 
        if ((c > i) && (data[c] != -1.)) { 
         j = c; 
         break; 
        } 
       } 
       findPairs(data, i, j, k, count + 1);      
      } 
     } 
     else { 
      for (int c = 0; c < data.length; c++) { 
       if (data[c] != -1.) { 
        i = c; 
        break; 
       } 
      }  
      for (int c = 0; c < data.length; c++) { 
       if ((c > i) && (data[c] != -1.)) { 
        j = c; 
        break; 
       } 
      }  
      for (int c = 0; c < data.length; c++) { 
       if ((c > j) && (data[c] != -1.)) { 
        k = c; 
        break; 
       } 
      } 
      findPairs(data, i, j, k, count + 1); 
     } 
    } 
    else if ((k < data.length) && (diff(data[i], data[j]) > diff(data[j], data[k]))) { 
     if (k == data.length - 1) { 
      data[j] = (-1.); 
      data[k] = (-1.); 
     } 
     else { 
      i = j; j = k; 
      for (int c = 0; c < data.length; c++) { 
       if ((c > j) && (data[c] != -1.)) { 
        k = c; 
        break; 
       } 
      } 
      findPairs(data, i, j, k, count); 
     } 
    }  
    for (int c = 0; c < data.length; c++) { 
     if (data[c] != -1) { 
      oddNumber = data[c]; 
     } 
    } 
    return oddNumber; 
} 

算法：从数组的第一个，第二个和第三个元素开始。比较第一和第二要素与第二和第三要素之间的差异。如果第一差小于或等于后者，使前两个元素到（-1）。否则，对第二，第三和第四个元素也要这样做。继续这个过程。每当第一差值大于第二差值时，使相对元件（-1），从阵列的开头搜索不在（-1）的元素。重复这个过程，从你找到的前三个元素开始。当第二差值小于第一，保持三的第一个元素放在一边，连下三检查。这样做直到你到达数组的末尾。

Answer 1

您说过算法并编写代码的方式，在最坏的情况下，您可以迭代越来越多的列表，因为算法从找到一对到下一个将设置为-1 。所以看起来最糟糕的运行时间是O（n^2）。