Arrays 查找排序数组中其他两个数之和的数

正如在主题中所说，我必须检查排序数组中是否有一个数字是其他两个数字的总和

在问题的第一部分（对于未排序的数组），我编写了一个解决方案，只需执行3个循环并检查所有组合

现在，我不知道如何构建最有效的算法来实现同样的效果，但是使用排序数组

数字的类型为

int

（负数或正数），任何数字都可以出现一次以上

---

有人能给我一个关于这个逻辑问题的线索吗？

这里我用C：

由n个数字和另一个数字x组成的数组A[]确定S中是否存在两个和正好为x的元素

方法1（使用排序）

算法：

# include <stdio.h>
# define bool int

void quickSort(int *, int, int);

bool hasArrayTwoCandidates(int A[], int arr_size, int sum)
{
    int l, r;

    /* Sort the elements */
    quickSort(A, 0, arr_size-1);

    /* Now look for the two candidates in the sorted 
       array*/
    l = 0;
    r = arr_size-1; 
    while(l < r)
    {
         if(A[l] + A[r] == sum)
              return 1; 
         else if(A[l] + A[r] < sum)
              l++;
         else // A[i] + A[j] > sum
              r--;
    }    
    return 0;
}

/* Driver program to test above function */
int main()
{
    int A[] = {1, 4, 45, 6, 10, -8};
    int n = 16;
    int arr_size = 6;

    if( hasArrayTwoCandidates(A, arr_size, n))
        printf("Array has two elements with sum 16");
    else
        printf("Array doesn't have two elements with sum 16 ");

    getchar();
    return 0;
}

/* FOLLOWING FUNCTIONS ARE ONLY FOR SORTING 
    PURPOSE */
void exchange(int *a, int *b)
{
    int temp;
    temp = *a;
    *a   = *b;
    *b   = temp;
}

int partition(int A[], int si, int ei)
{
    int x = A[ei];
    int i = (si - 1);
    int j;

    for (j = si; j <= ei - 1; j++)
    {
        if(A[j] <= x)
        {
            i++;
            exchange(&A[i], &A[j]);
        }
    }
    exchange (&A[i + 1], &A[ei]);
    return (i + 1);
}

/* Implementation of Quick Sort
A[] --> Array to be sorted
si  --> Starting index
ei  --> Ending index
*/
void quickSort(int A[], int si, int ei)
{
    int pi;    /* Partitioning index */
    if(si < ei)
    {
        pi = partition(A, si, ei);
        quickSort(A, si, pi - 1);
        quickSort(A, pi + 1, ei);
    }
}

Hasarraytwo（A[]，ar_大小，总和） 1） 按非降序对数组排序

2） 初始化两个索引变量以查找排序数组中的候选元素

（a） 首先初始化到最左边的索引：l=0

（b） 初始化第二个最右边的索引：r=ar_size-1

3） 当l （a） 如果（a[l]+a[r]==和），则返回1

（b） 否则如果（A[l]+A[r] （c） 否则r--

4） 整个数组中没有候选项-返回0

示例： 设数组为{1,4,45,6,10，-8}，求和为16

对数组进行排序 A={8,1,4,6,10,45}

初始化l=0，r=5

A[l]+A[r]（-8+45）>16=>减量r。现在r=10

A[l]+A[r]（-8+10）<2=>增量l。现在l=1

A[l]+A[r]（1+10）<16=>增量l。现在l=2

A[l]+A[r]（4+10）<14=>增量l。现在l=3

A[l]+A[r]（6+10）==16=>找到的候选项（返回1）

实施：

# include <stdio.h>
# define bool int

void quickSort(int *, int, int);

bool hasArrayTwoCandidates(int A[], int arr_size, int sum)
{
    int l, r;

    /* Sort the elements */
    quickSort(A, 0, arr_size-1);

    /* Now look for the two candidates in the sorted 
       array*/
    l = 0;
    r = arr_size-1; 
    while(l < r)
    {
         if(A[l] + A[r] == sum)
              return 1; 
         else if(A[l] + A[r] < sum)
              l++;
         else // A[i] + A[j] > sum
              r--;
    }    
    return 0;
}

/* Driver program to test above function */
int main()
{
    int A[] = {1, 4, 45, 6, 10, -8};
    int n = 16;
    int arr_size = 6;

    if( hasArrayTwoCandidates(A, arr_size, n))
        printf("Array has two elements with sum 16");
    else
        printf("Array doesn't have two elements with sum 16 ");

    getchar();
    return 0;
}

/* FOLLOWING FUNCTIONS ARE ONLY FOR SORTING 
    PURPOSE */
void exchange(int *a, int *b)
{
    int temp;
    temp = *a;
    *a   = *b;
    *b   = temp;
}

int partition(int A[], int si, int ei)
{
    int x = A[ei];
    int i = (si - 1);
    int j;

    for (j = si; j <= ei - 1; j++)
    {
        if(A[j] <= x)
        {
            i++;
            exchange(&A[i], &A[j]);
        }
    }
    exchange (&A[i + 1], &A[ei]);
    return (i + 1);
}

/* Implementation of Quick Sort
A[] --> Array to be sorted
si  --> Starting index
ei  --> Ending index
*/
void quickSort(int A[], int si, int ei)
{
    int pi;    /* Partitioning index */
    if(si < ei)
    {
        pi = partition(A, si, ei);
        quickSort(A, si, pi - 1);
        quickSort(A, pi + 1, ei);
    }
}

#包括
#定义布尔整数
无效快速排序（int*，int，int）；
bool hasarraytwo（int A[]，int arr_size，int sum）
{
int l，r；
/*对元素进行排序*/
快速排序（A、0、arr_size-1）；
/*现在，在分类表中查找两位候选人
排列*/
l=0；
r=arr_尺寸-1；
while（l和
r--；
}    
返回0；
}
/*用于测试上述功能的驱动程序*/
int main（）
{
inta[]={1,4,45,6,10，-8}；
int n=16；
int arr_size=6；
if（Hasarraytwo（A，arr_大小，n））
printf（“数组有两个和为16的元素”）；
其他的
printf（“数组没有两个和为16的元素”）；
getchar（）；
返回0；
}
/*以下函数仅用于排序
目的*/
无效交换（int*a，int*b）
{
内部温度；
温度=*a；
*a=*b；
*b=温度；
}
整数分区（整数A[]，整数si，整数ei）
{
int x=A[ei]；
int i=（si-1）；
int j；
对于（j=si；j起始指数
ei-->结束索引
*/
无效快速排序（int A[]，int si，int ei）
{
int pi；/*分区索引*/
if（si

这一个在Java中使用哈希集；它是O（n）复杂度

public static void findPair3ProPrint(int[] array, int sum) {
    Set<Integer> hs = new HashSet<Integer>();       
    for (int i : array) {           
        if (hs.contains(sum-i)) {
            System.out.print("(" + i + ", " + (sum-i) + ")" + " ");
        }else{
            hs.add(i);  
        }   
    }
}

公共静态void findPair3ProPrint（int[]数组，int和）{
Set hs=新HashSet（）；
对于（inti:array）{
如果（hs.包含（总和一））{
系统输出打印（“（“+i+”，“+（sum-i）+”）+”；
}否则{
hs.添加（i）；
}   
}
}

一种有效的方法是使用排序，然后进行二进制搜索

假设这两个数字是x和y，x+y=SUM

对于每个x，在数组中搜索元素SUM-x

使用mergesort对数组进行排序

然后对数组a中的每个元素a[i]进行二进制搜索（SUM-x） 该算法应在O（nlgn）中工作

在这里，binaryseacrh返回搜索键的索引（如果找到），否则返回-1。 大小是数组大小

    for(int i=0;i<SIZE;i++)
      {
        int ind=binarysearch(SUM-a[i]);

        if(ind>0)
          printf("sum=%d + %d\n a[%d] + a[%d]\n"
                    ,a[i],a[ind],i,ind);
      }

for（int i=0；i0）
printf（“总和=%d+%d\n a[%d]+a[%d]\n”
，a[i]，a[ind]，i，ind）；
}

什么是“问题的第一部分”？您指的是其他问题吗？非排序数组也是如此。您能提到您使用的语言吗？