爪哇2博客
爪哇2博客

从总和等于给定数的数组中查找所有元素对

如果您想练习数据结构和算法程序,可以通过 数据结构和算法面试题.

问题:

给定一个数组,我们需要找到总和等于数字X的所有对。
例如:

1
2
3
4
 
数组[]={ -40, -5, 1, 3, 6, 7, 8, 20 };
元素 谁的 等于 15 :  7, 8 -5, 20
 

解决方案:

解决方案1:

您可以检查每对数字,并找到等于X的总和。
爪哇代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
上市 静态的 虚空 findPairsWithSumEqualsToXBruteForce(整型 rr[], 整型 X) {
    如果 (rr.长度 < 2)
        返回;
 
    系统..打印(“使用蛮力法求和的对等于15:”);
    对于 (整型 i = 0; i < rr.长度; i++) {
        对于 (整型 j = i + 1; j < rr.长度; j++) {
            整型 临时总和 = rr[i] + rr[j];
 
            如果 (临时总和 == X) {
                系统..打印(rr[i] + + rr[j]);
            }
        }
    }
}
 

 Solution 2:

  • 对数组排序
  • 我们将维护两个索引,一个索引在开头(l = 0),另一个在结尾(r = n-1)
  • 重复直到 <  r
  • 检查arr [l] + rr [r]是否等于X
  • 如果是,则打印该对并执行l ++,r–
  • 如果arr [l] + rr [r]小于X,这意味着如果我们想找到与X接近的和,请执行r–
  • 如果arr [l] + rr [r]大于X,这意味着如果我们想找到和X接近的和,请执行l ++
爪哇代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
上市 静态的 虚空 findPairsEqualsToX(整型 rr[], 整型 X) {
 
    整型 n = rr.长度;
    如果 (n < 2)
        返回;
    数组.分类(rr);
    系统..打印(“总和等于15的那对:”);
    //左右索引变量
    整型 l = 0, r = n - 1;
 
     (l < r) {
        整型 当前总和 = rr[l] + rr[r];
        如果 (当前总和 == X) {
            系统..打印(rr[l] + + rr[r]);
            l++;
            r-;
        } 其他 如果 (rr[l] + rr[r] < X)
            l++;
        其他
            r-;
    }
}
 

时间复杂度:O(NLogN)

解决方案3:

使用散列

  • 将数组元素放入HashMap中,并将元素作为键,并将其索引作为值。
  • 遍历数组arr []
  • 如果HashMap中存在X-arr [i],请检查arr [i]。
  • 如果是,我们已经找到该对并打印。
爪哇代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
上市 静态的 虚空 findPairsEqualsToXUsingHashing(整型 rr[], 整型 X) {
    哈希图<整数, 整数> elementIndexMap = 哈希图<整数, 整数>();
    系统..打印(“总和等于15的那对:”);
    对于 (整型 i = 0; i < rr.长度; i++) {
        elementIndexMap.(rr[i], i);
    }
    对于 (整型 i = 0; i < rr.长度; i++) {
        //为了避免使用相同的元素,我们使用了elementIndexMap.get(X-arr [i])!= i
        //元素两次
        如果 (elementIndexMap.得到(X - rr[i]) != 空值 && elementIndexMap.得到(X - rr[i]) != i) //
        {
            系统..打印(rr[i] + + (X - rr[i]));
        }
    }
}
 

时间复杂度:O(NLogN)空间复杂度:O(N)

爪哇程序查找所有总和等于给定数字的对:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
组织.Arpit.爪哇2blog;
 
进口 爪哇.实用程序.数组;
进口 爪哇.实用程序.哈希图;
 
上市 FindPairEqualToGivenNumberMain {
 
    上市 静态的 虚空 主要([] args) {
        整型 数组[] = { -40, -5, 1, 3, 6, 7, 8, 20 };
        findPairsWithSumEqualsToXBruteForce(数组, 15);
        findPairsEqualsToX(数组, 15);
        findPairsEqualsToXUsingHashing(数组, 15);
    }
 
    上市 静态的 虚空 findPairsWithSumEqualsToXBruteForce(整型 rr[], 整型 X) {
        如果 (rr.长度 < 2)
            返回;
 
        系统..打印(“使用蛮力法,其和最接近15的那对:”);
        对于 (整型 i = 0; i < rr.长度; i++) {
            对于 (整型 j = i + 1; j < rr.长度; j++) {
                整型 临时总和 = rr[i] + rr[j];
 
                如果 (临时总和 == X) {
                    系统..打印(rr[i] + + rr[j]);
                }
            }
        }
    }
 
    上市 静态的 虚空 findPairsEqualsToX(整型 rr[], 整型 X) {
 
        整型 n = rr.长度;
        如果 (n < 2)
            返回;
        数组.分类(rr);
        系统..打印(“总和最接近15的那对:”);
        //左右索引变量
        整型 l = 0, r = n - 1;
 
         (l < r) {
            整型 当前总和 = rr[l] + rr[r];
            如果 (当前总和 == X) {
                系统..打印(rr[l] + + rr[r]);
                l++;
                r-;
            } 其他 如果 (rr[l] + rr[r] < X)
                l++;
            其他
                r-;
        }
    }
 
    上市 静态的 虚空 findPairsEqualsToXUsingHashing(整型 rr[], 整型 X) {
        哈希图<整数, 整数> elementIndexMap = 哈希图<整数, 整数>();
        系统..打印(“总和最接近15的那对:”);
        对于 (整型 i = 0; i < rr.长度; i++) {
            elementIndexMap.(rr[i], i);
        }
        对于 (整型 i = 0; i < rr.长度; i++) {
            //为了避免使用相同的元素,我们使用了elementIndexMap.get(X-arr [i])!= i
            //元素两次
            如果 (elementIndexMap.得到(X - rr[i]) != 空值 && elementIndexMap.得到(X - rr[i]) != i) //
            {
                系统..打印(rr[i] + + (X - rr[i]));
            }
        }
    }
}
 

当您运行上述程序时,将获得以下输出:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
  谁的 最近的 15 使用 蛮力 方法:
-5 20
7 8
谁的 最近的 15 :
-5 20
7 8
谁的 最近的 15 :
-5 20
7 8
8 7
20 -5
 


导入联系人

您可能还喜欢:

分享这个

作者

关注作者

相关文章

  • 3月28日

    对0、1和2的数组进行排序

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。在这篇文章中,我们将看到如何对0、1和2s的数组进行排序。我们已经看到了有关对数组中的0s和1s进行排序的文章。问题给定一个包含零的数组,[…]

  • 3月04

    通过跳转检查是否有可能到达给定数组的末尾

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。问题给定一个具有正整数作为元素的数组,该数组指示可以从数组中任何位置进行跳转的最大长度。检查是否可以[…]

  • 2月17日

    检查数组元素是否连续

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。在这篇文章中,我们将看到如何检查数组元素是否连续。问题给定一个数组,我们需要检查数组是否包含连续的元素。例如:输入:array [] = {5,3,4,[…]

  • 11月1日

    在数组中找到局部最小值

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。在这篇文章中,我们将看到如何在数组中找到局部最小值。问题如果一个元素小于其相邻元素,则它是局部最小值。 整型 [] rr = {10,5,3,[…]

  • 10月22日

    爪哇中的滑动窗口最大值

    在这篇文章中,我们将看到有关Java问题中滑动窗口最大值的问题给定一个整数数组和一个整数k,请从所有大小为K的连续子数组中找到max的元素。例如:Input:int [] rr = {2 ,6,-1,2,4,1,-6,5} 整型 k = 3输出:[[]的每个子数组分别为6,6,4,4,4,5,5…]

  • 10月20日

    计算排序数组中每个元素的出现次数(或频率)

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。在这篇文章中,我们将看到如何计算已排序数组中每个元素的出现次数(或出现频率)问题给定一个包含重复项的整数排序数组。找出每个[…]

发表评论

您的电子邮件地址不会被公开。 必需的地方已做标记 *

订阅我们的新闻

获取质量教程到您的收件箱。现在订阅。


成为朋友

©2020 爪哇2博客