Algorithm 时间复杂度小于3Sum

在LeetCode上调用的问题询问：

---

给定一个

n

整数数组

nums

和一个

target

，用

0查找索引三元组
i，j，k
的数量一个非常简单的确定方法是n^2算法，即查看循环

外部（for）循环最多迭代n次（技术上是n-2次，但无论如何）。内部循环取决于left和right的值。
left至少为1，right最多为len=n（从技术上讲是len-1，但不管怎样），内部循环仅在
left
时执行，因此在最坏的情况下，内部循环最多迭代n次

外部循环最多迭代n次。对于外循环的每次迭代，内循环最多迭代n次。算法是O（n^2）。这个算法也是O（n^3），因为O（n^2）=O（n^3）

另一个不在固定时间内运行的语句是：

Arrays.sort(nums);

假设有一个有效的排序算法，该操作在O（nlog n）中运行，即在O（n^2）中运行，因此它不会影响最终的时间复杂度

进行时间复杂性分析时的技巧。忘记算法应该做什么，只看循环以及它们可能运行的程度。
确定这一点的一个非常简单的方法是n^2算法是看循环

public class Solution {
    int count; //constant operation

    public int threeSumSmaller(int[] nums, int target) {
        count = 0; //constant operation
        Arrays.sort(nums); //sorting is generally considered O(nlogn)
        int len = nums.length; //constant operation

        for(int i=0; i<len-2; i++) { //O(n) operation
            int left = i+1, right = len-1; //two constant operations
            while(left < right) { //O(n) operation
                if(nums[i] + nums[left] + nums[right] < target) { //constant operation
                    count += right-left; //constant operation
                    left++; //constant operation
                } else { 
                    right--; //constant operation
                }
            }
        }
        return count; //constant operation
    }
}

外部（for）循环最多迭代n次（技术上是n-2次，但无论如何）。内部循环取决于left和right的值。
left至少为1，right最多为len=n（从技术上讲是len-1，但不管怎样），内部循环仅在
left
时执行，因此在最坏的情况下，内部循环最多迭代n次

外部循环最多迭代n次。对于外循环的每次迭代，内循环最多迭代n次。算法是O（n^2）。这个算法也是O（n^3），因为O（n^2）=O（n^3）

另一个不在固定时间内运行的语句是：

Arrays.sort(nums);

假设有一个有效的排序算法，该操作在O（nlog n）中运行，即在O（n^2）中运行，因此它不会影响最终的时间复杂度

进行时间复杂性分析时的技巧。忘记算法应该做什么，只看循环以及它们可能运行的程度。
公共类解决方案{
public class Solution {
    int count; //constant operation

    public int threeSumSmaller(int[] nums, int target) {
        count = 0; //constant operation
        Arrays.sort(nums); //sorting is generally considered O(nlogn)
        int len = nums.length; //constant operation

        for(int i=0; i<len-2; i++) { //O(n) operation
            int left = i+1, right = len-1; //two constant operations
            while(left < right) { //O(n) operation
                if(nums[i] + nums[left] + nums[right] < target) { //constant operation
                    count += right-left; //constant operation
                    left++; //constant operation
                } else { 
                    right--; //constant operation
                }
            }
        }
        return count; //constant operation
    }
}

int count；//常量操作
公共整数（整数[]nums，整数目标）{
count=0；//常量操作
Arrays.sort（nums）；//排序通常被认为是O（nlogn）
int len=nums.length；//常量操作
对于（int i=0；i
公共类解决方案{
int count；//常量操作
公共整数（整数[]nums，整数目标）{
count=0；//常量操作
Arrays.sort（nums）；//排序通常被认为是O（nlogn）
int len=nums.length；//常量操作
对于（int i=0；这很有帮助。因此，具体来说，内环的最坏情况是n步，因为
j
会一直向右移动以搜索足够小的值，或者
k
会一直向左移动，不断找到有效的和。而且，
j
和
k
永远不会交叉，所以它也只能是
n
>外部循环中每个
i
的步骤。正如我所说，我甚至没有看代码的逻辑，我只看了循环保护和相关语句。我认为for循环迭代n次的原因是显而易见的。我跟踪内部循环的方式如下：left依赖于i，i至少为0，从不小于，所以left至少为1。right始终最多为len-1。当外循环迭代时，左循环增加，而左循环从不减少（微不足道）因此，内部循环将一直运行到left>=right，这在最多n次迭代中发生。这很有帮助。因此，具体来说，内部循环的最坏情况是n个步骤，因为
j
将一直向右移动以搜索足够小的值，或者
k
将一直向左移动，不断找到有效的和。此外，
j
 而且
k
永远不会交叉，所以对于外部循环中的每个
i
，它只能是
n
步。正如我所说的，我甚至根本没有看代码的逻辑，我只看循环保护和相关语句。我想为什么for循环迭代n次是显而易见的。我跟踪内部循环的方式如下：left依赖于i，i至少为0，而且永远不会小于，所以left至少为1。right始终最多为len-1。当外部循环迭代时，left增加，而它永远不会减少（微不足道），因此内部循环将一直运行到left>=right，这最多在n次迭代中发生。[1，2，3，7]目标：11给我1。答案应该是2.1，2，3 1，2，7[1,2,3,7]目标：11给了我1。答案应该是2.1,2,31,2,7