算法:找加数

题目:已知按序排列的整数数组,输入任意数number,当数组中某两数之和等于number时,打印出两个数。

要求:复杂度为o(n)

解法:

数组已是有序排列,且两个加数一定满足条件:较小加数<= (number/2) <= 较大加数;那么只需要找出该数组的较小加数和较大加数分界index,分别从两边取值逐个匹配即可。

若两数之和>number,说明较小加数还要再小,向数组的较小值方向移位取值与原较大值重新匹配。

若两数之和<number,说明较大加数还要再大,向数组的较大值方向移位取值与原较小值重新匹配。

 1 public void seachAdden(int number, int[] arry) {
 2         int midIndex = 0; // 较大加数和较小加数的分界
 3         boolean result = false;
 4         for (int i = 0; i < arry.length; i++) { // 定位midIndex的值
 5             if (arry[i] > (number / 2)) {
 6                 midIndex = i - 1; // 如果数组的第一个数就已经大于用户输入的数字,则midIndex为-1
 7                 break;
 8             } else if (i < arry.length - 1 && (arry[i + 1] + arry[i] == number)) {
 9                 if (arry[i + 1] == arry[i]) {
10                     // 匹配成功
11                     printResult(i,i+1,arry,number);
12                     result = true;
13                 }
14             }
15         }
16         if (midIndex != -1) {
17             int smallerIndex = midIndex; // 记录较小加数在数组中的下标
18             int biggerIndex = midIndex + 1; // 记录较大加数在数组中的下标
19             do {// 开始匹配
20                 if (arry[smallerIndex] + arry[biggerIndex] > number) {
21                     smallerIndex--;
22                 } else if (arry[smallerIndex] + arry[biggerIndex] < number) {
23                     biggerIndex++;
24                 } else {
25                     // 匹配成功
26                     printResult(smallerIndex,biggerIndex,arry,number);
27                     result = true;
28
29                     if (smallerIndex - 1 >= 0
30                             && arry[smallerIndex] == arry[smallerIndex - 1]) {
31                         smallerIndex--;
32                         printResult(smallerIndex,biggerIndex,arry,number);
33                     }
34                     if (biggerIndex + 1 <= arry.length - 1
35                             && arry[biggerIndex] == arry[biggerIndex + 1]) {
36                         biggerIndex++;
37                         printResult(smallerIndex,biggerIndex,arry,number);
38                     }
39                     smallerIndex--;
40                     biggerIndex++;
41                 }
42             } while ((smallerIndex >= 0) && (biggerIndex <= arry.length - 1));
43         }
44         if (result == false) {
45             System.out.println("无匹配");
46         }
47     }
48
49     public void printResult(int i, int j,int[]arry,int number){
50         System.out.println("arry[" + i + "] 和 arry[" + j
51                 + "] 匹配,即  " + arry[i] + " + " + arry[j]
52                 + " = " + number);
53     }

举例:

时间: 2024-08-06 16:06:11

算法:找加数的相关文章

[算法]找出数组当中的中枢元素

给定一个整型数组,找出pivot,使得对于任意i < pivot,a[i] <=a[pivot],对于i > pivot,a[i]>=a[pivot],只能用一个额外的数组,和少量空间. 思路 1.使用一个数组t记录,t[i]记录的是a[0]~a[i]的最大值 int *t = new int[n]; for(int i = 0, max = ~0; i < n; ++i){ if(a[i] > max){ max = a[i]; } t[i] = max; } 2.从

数组a[n]中存放1-n中的n-1个数,给出算法找出重复的那一个数

问题描述: 数组a[n]中存放1-n中的n-1个数,给出算法找出重复的那一个数. 算法一: 对数组a[n]进行冒泡排序,如果冒泡所得的最值和前一个最值相等,则该最值为重复的数. 分析: 该算法时间复杂度最坏的情况为O(n的2次方),在空间开销上只需要一个额外的交换空间. 如何将时间开销减小呢?下面给出另外一种算法 算法二: 给定另外一个数组b[n],将a[n]中的数作为数组b的索引,然后遍历b[n],如果未访问过,则标记:如果已经访问过,则该索引就为重复的数. 分析: 该算法时间复杂度能够达到最

高效的算法找出中间所有A[i] = i的下标

给定一个排好升序的数组A[1].A[2].--.A[n],其元素的值都两两不相等.请设计一高效的算法找出中间所有A[i] = i的下标.并分析其复杂度. 解析:首先分析一下这个数组,假设其中某个位置的A[i] = i,那么可以肯定的值,之前的A[x] > x,之后的A[x] < x.还有一个显而易见的性质就是中间的A[i]=i一定是连续存在的,不可能跨区域存在,因为这个数组是升序的. 我给出的方法是二分查找,具体的做法是:我们假设一个新数组B,其元素是A[i] - i的值,这样的话,B[i]

FOJ 2232 匈牙利算法找二分图最大匹配

题目链接 简单理解匈牙利算法 简单理解二分图 尽量让每一个随从击败一个对手且随从全部存活,关键是为每一个随从找对手(递归过程),"腾". #include<iostream> #include<cstdio> #include<cstring> using namespace std; int used[110]; int g[110][110]; //建立随从和对手的对战关系 int ee[110]; int n; struct people{ i

dijkstra 算法 找图的最短路 单源最短路

基本思路是    一个path数组存路径  一个distance数组存距离   distance[k]表示 k结点到指定的初始结点的最短路   还要个collect数组收集已经被操作过的点 先初始化distance 把目标结点的子结点的距离放进去,其他的初始化为无穷大,  每次找d中未被收集到collection中的最小值,这是最重要的,有这步才能证明最后得到的是最短路,这步是贪心思想,每次找距离最小的未在collection里的结点来,保证最后得到的最小路径,这是被证明的,这步也保证了遍历所有

算法——找出缺失的整数

一.前言 最近智商持续掉线,隐约有种提前犯了阿兹海默症的感觉,偶像剧看多了就是容易智商持续掉线,前一整子关注了个算法的公众号,今天也终于捡着一篇能看懂的了,感觉非常的涨姿势,整篇看下来觉得自己有了很大的提升,仿佛就差一点就看懂了. 以下是原文的链接,为了防止链接被破坏,为了维护涨过的姿势还找得到的和平,阿婆,可爱又迷人的反派角色这里决定开个随笔整理一下文章内容和评论里面的代码,等. 原文请戳这里 http://blog.jobbole.com/106521/ 二.请看正文 第一题:请听题,要把大

【转】已知一个数出现的次数严格超过了一半,请用O(n)的复杂度的算法找出这个数

原文转自:http://blog.csdn.net/zhq651/article/details/7930284 方法1:既然过半,那么用这个数与其他数配对的话,剩余的数字一定还是过半的这个数字.因此可以通过不断删除不同的2个数,直到没有不同的2个数,那么这个数就是要找的数.证明:最坏情况下,只有这个数同别的数配对,并且被删除,剩下的仍旧是这个数,因此得证. 转自:http://www.cnblogs.com/python27/archive/2011/12/15/2289534.html 例:

算法-找出其他出现偶数次的数组中出现1次,2次,3次的数

#include <cstdio> #include <cstring> #include <algorithm> #include <map> #include <iostream> #include<vector> #include<string> #include<set> #include<unordered_set> #include<queue> #include<ma

写一个查找算法找出数组中相同的元素

1 import java.util.ArrayList; 2 3 public class Test { 4 5 // 原始数据data.假设data数组中的数据元素已经按照某种顺序排好. 6 // 但是,该数组中的数据元素重复出现. 7 // 我们的目的是查找.解析data数组中重复出现的某元素. 8 // 比如,在这个data数组中,元素'C'在数组位置2,3重复出现两次. 9 // 注意!有些元素没有重复出现,比如元素'B'. 10 private String[] data = { "