C 在数组中查找对的第三高和

如果我们必须找到数组中一对元素的第三高和

例如，给定

int arr[] = { 1, 2, 3, 4 }; 

然后，我们有以下几对：

(1,2) = 3, (1,3) = 4, (1,4) = 5, (2,3) = 5, (2,4) = 6, (3,4) = 7

这里，答案是5，对是（1,4）和（2,3）

数组不必排序，数组中的重复值可以成对出现

我尝试了一个包含两个嵌套循环的算法。时间复杂度是二次的。如何降低复杂性

---

现在，如果我们需要找到第k个最高的对和。我们可以选择minheap或maxheap，首先将对和存储在maxheap/minheap中，然后找到其中第k个最大值。

您可以这样使用：

int varmax1, varmax2, varmax3, varmax4, varmax5, varmax6, i, j, max=0, max2=0, max3=0;
for(i=0; i<3;i++)
{
    for(j=i;j<3;j++)
    {
        sum=arr[i]+arr[j];
        if(sum>max)
        {
            max3=max2;
            max2=max;
            max=sum;
            varmax1 = varmax3;
            varmax2 = varmax4;
            varmax3 = varmax5;
            varmax4 = varmax6;
            varmax5 = i;
            varmax6 = j;
        }
        else if(sum>max2)
        {
            max3=max2;
            max2=sum;
            varmax1 = varmax3;
            varmax2 = varmax4;
            varmax3=i
            varmax4=j

        }
        else if(sum>max3)
        {
            max3=sum;
            varmax1 = arr[i];
            varmax2 = arr[j];
        }
    }
}
printf("elements with 3rd largest sum are %d %d", varmax1, varmax2);

int varmax1，varmax2，varmax3，varmax4，varmax5，varmax6，i，j，max=0，max2=0，max3=0；
对于（i=0；imax2）
{
max3=max2；
max2=总和；
varmax1=varmax3；
varmax2=varmax4；
varmax3=i
varmax4=j
}
否则如果（总和>最大值3）
{
max3=总和；
varmax1=arr[i]；
varmax2=arr[j]；
}
}
}
printf（“第三大总和的元素为%d%d”，varmax1，varmax2）；

首先尝试一种野蛮的方法：

• 使用双循环扫描数组，以查找最大和

  sum1

• 使用双循环重新扫描数组，以找到与

  sum1

  不同的最大和

  sum2

• 第三次重新扫描数组，以找到与

  sum1

  和

  sum2

  不同的最大和

  sum3

• 最后一次重新扫描阵列以打印sum

  sum3

  的所有对

时间复杂度是二次的，但它可以正确处理重复项

然后，您可以通过过滤数组来大幅降低复杂性，如果存在重复项，则只保留最大的3个数字，最多保留2个实例。这可以在线性时间内完成。然后在最多6个元素的集合上运行二次算法。总的复杂性仍然是线性的。

public int thirdHighest（）
public int thirdHighest()
{
    int sum = 0;
    List<int> number = new List<int>();
    int[] array = new int[] { 1, 2, 3, 4, 6, 7 };

    for (int i = 0; i < array.Length; i++)
    {
        for (int j = i + 1; j < array.Length; j++)
        {
            sum = array[i] + array[j];
            if (number.Contains(sum))
            {
            }
            else
            {
                number.Add(sum);
            }
        }
    }

    int[] array1 = new int[number.Count];

    for (int i = 0; i < number.Count; i++)
    {
        array1[i] = number[i];
    }

    Array.Sort<int>(array1);
    Array.Reverse(array1);

    return array1[2];
}

{
整数和=0；
列表编号=新列表（）；
int[]数组=新的int[]{1,2,3,4,6,7}；
for（int i=0；i

公共静态void main（字符串[]args）{ //TODO自动生成的方法存根

    int[] intList = {5,4,7,8,12,16,19,5};



    Set<Integer> intSumList = new HashSet<Integer>();
    List<Integer> intSumList1 = new ArrayList<Integer>();
    for(int i=0;i<intList.length;i++){

        for(int j=(intList.length - 1);j>i;j--)
            {
            //  System.out.println(intList[j]+" --- "+intList[i]);
                intSumList.add((intList[j]+intList[i]));
            }   
        }

    for(int ele : intSumList){
        intSumList1.add(ele);
    }

    Collections.sort(intSumList1);

    for(int ele : intSumList1){
        System.out.println(ele);
    }


    System.out.println("sum is "+intSumList1.get((intSumList1.size()-3)));
    }

int[]intList={5,4,7,8,12,16,19,5}；
Set intSumList=new HashSet（）；
List intSumList1=new ArrayList（）；
对于（int i=0；ii；j--）
{
//System.out.println（intList[j]+“--”+intList[i]）；
添加（（intList[j]+intList[i]）；
}   
}
用于（int元素：intSumList）{
intSumList1.add（ele）；
}
Collections.sort（intSumList1）；
for（int元素：intSumList1）{
系统输出打印项次（ele）；
}
System.out.println（“总和为”+intSumList1.get（（intSumList1.size（）-3））；
}
变量a=[30,4,2,5,6,0,9]；
var first=a[0]；
var second=“”；
var第三=”；
//在O（n）时间内解决它
对于（变量i=1；i第一个）
{ 
第二=第一；
第一个=a[i]；
} 
//找到第二个最大值
如果（a[i]>第二个&&a[i]！=第一个）
{
第三=第二；
秒=a[i]；
}
//找到第三个最大值
else如果（a[i]>第三个&&a[i]！=第一个&&a[i]！=第二个）
第三=a[i]；
}
控制台日志（第一+第二+第三）；
你的问题是？那么你到目前为止尝试了什么？我可以想到蛮力方法，即计算所有可能的对和，然后找到第三高的对。第一步：对数组进行排序（如果尚未排序）。问题是找到第三高和的对。你如何确定var1和var2是正确的一对如果在上一次迭代中使用了
sum>max2
，那么max3的值将是正确的，但是
var1+var2！=max3
因此答案不正确。如果多对具有sum
max
或
max2
是，则这不起作用。没错。为此，我们只需将这些元素保存在其他位置，并最终显示所有这些元素。这会留下一个非常脏的代码来处理，你不这么认为吗？这就是我尝试过的。我想如果有办法提高复杂性的话。@Vikram:你应该重新表述这个问题，包括你尝试过的，你面临的问题。如果集合相对较小，则二次复杂度不是问题。对于大型集合，可以通过跳过外部循环中阈值以下的数字来降低复杂性。只有最大的数字才涉及最大的金额。对数组进行排序会使这变得更容易，但应该不是必需的。如果我需要找到第k个最大的对和，该怎么办？您可以运行
k
重新扫描循环，查找严格小于上一次迭代中找到的最大和。如果使用筛选，可以保留
k+1
最大的元素。问题标记为[c]，而不是[c++]或[java]。嗯。。。问题被标记为
C
，仅仅发布一堆代码很可能对OP没有帮助
var a=[30,4,2,5,6,0,9];
var first=a[0];
var second="";
var third="";
// Solve it in O(n) time
for(var i=1;i<a.length;i++)
{
    //Find first Max
    if(a[i]>first)
    { 
      second=first;
      first=a[i];
    } 
    //Find second Max
    else if(a[i]>second && a[i]!=first )
     {
         third=second;
         second=a[i];
     }
    //Find third Max
    else if(a[i]>third && a[i]!=first && a[i]!=second)
         third=a[i];
}
console.log(first+second+third);