blocks|key|620121|text|我可以知道输入和期望输出数列吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|620122|根据你的代码，如果我没记错的话，我觉得级数应该是差1。|620123|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Can I know the Input and Expected output number series ?
 
According to your code i feel the series should be a difference of 1,If i'm not wrong.

blocks|key|620150|text|所以你有一个由n个元素组成的数组，它以整数i开始，包含从i到i%2Bn的所有整数，对吗？例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|620151|arr+=+[1,2,3,4,5]|code-block|syntax|javascript|620152|因此，数组中所有数字的和应该是从i到i%2Bn的数字之和。|620153|例如：sum(arr)+=+1%2B2%2B3%2B4%2B5+=+15|offset|length|style|CODE|620154|数字1到n的和的公式是n(n%2B1)/2|620155|所以你可以有一个for循环：|620156|int+counter+=+0;

for(Integer+i+:+integers)
++++counter+%2B=+i|620157|来获取数组中的数字总和。|620158|如果数组从1开始，则检查counter变量是否等于n(n%2B1)/2，其中n是数组的长度。|620159|如果您的数组不是从1开始的，例如arr+=+[78,+79,+80,+81]，那么您需要稍微调整一下这种方法，但我相信您可以解决这个问题。|620160|entityMap^0|0|0|0|3|P|0|B|8|0|0|0|0|C|7|P|8|10|1|0|G|M|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|15|8|@$K|16|L|17|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|18|8|@$K|19|L|1A|M|N]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1D|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1E|8|@$K|1F|L|1G|M|N]|$K|1H|L|1I|M|N]|$K|1J|L|1K|M|N]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1L|8|@$K|1M|L|1N|M|N]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|11|$]]

So you have an array of n elements which starts with an integer i and contains all integers from i to i+n is that right? Eg:

<pre><code>arr = [1,2,3,4,5]
</code></pre>

So, the sum of all numbers in the array should be the sum of numbers from i to i+n.

Eg: <code>sum(arr) = 1+2+3+4+5 = 15</code>

The formula for the sum of numbers 1 to n is <code>n(n+1)/2</code>

So you can have a for loop as:

<pre><code>int counter = 0;

for(Integer i : integers)
 counter += i
</code></pre>

To get the sum of numbers in your array.

If your array starts at one, you check whether the <code>counter</code> variable equals <code>n(n+1)/2</code>, where <code>n</code> is the length of your array.

If your array doesn't start at one, for example <code>arr = [78, 79, 80, 81]</code> then you need to tweak this approach a little, but I'm sure you can figure it.

blocks|key|3819289|text|对数组进行排序需要使用O(n*log(n))。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3819290|如果您将数组的所有元素添加到HashSet+(O(n))运行时，然后检查0和ar.length+-+1+(或任何相关范围)之间的每个数字，然后检查HashSet是否包含该数字，可以做得更好。这将占用O(n)时间。|3819291|entityMap^0|B|B|0|E|7|M|6|10|1|12|D|21|7|2R|4|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|I|$]]

Sorting the array would take <code>O(n*log(n))</code>. 

You can do better if you add all the elements of the array to a <code>HashSet</code> <code>(O(n))</code> running time, and then check for each number between <code>0</code> and <code>ar.length - 1</code> (or whatever the relevant range is) whether the <code>HashSet</code> contains that number. This would take <code>O(n)</code> time.

blocks|key|38730|text|您可以执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|38731|Set<Integer>+mySet+=+new+TreeSet<Integer>(Arrays.asList(ar));
int+min+=+mySet.first();

for+(int+i+=+0;+i+<+mySet.size();+i%2B%2B)+{
++++int+number+=+min+%2B+i;
++++if+(!mySet.contains(number))+{
++++++++System.out.println+("Missing:+"+%2B+number);
++++++++i--;
++++}
}|code-block|syntax|javascript|38732|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can do:

<pre><code>Set&lt;Integer&gt; mySet = new TreeSet&lt;Integer&gt;(Arrays.asList(ar));
int min = mySet.first();

for (int i = 0; i &lt; mySet.size(); i++) {
 int number = min + i;
 if (!mySet.contains(number)) {
 System.out.println ("Missing: " + number);
 i--;
 }
}
</code></pre>

blocks|key|620195|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|620196|任何比这更快或更好的代码，请建议。|blockquote|620197|620198|620199|+no+没有这回事-如果每个元素都必须被访问，你就不能改进O(n)算法。|offset|length|style|BOLD|CODE|620200|entityMap^0|0|0|0|0|0|4|T|4|0^^$0|@$1|2|3|-4|4|5|6|O|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|P|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|Q|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|R|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|S|7|@$H|T|I|U|J|K]|$H|V|I|W|J|L]]|8|@]|9|$]]|$1|M|3|-4|4|5|6|X|7|@]|8|@]|9|$]]]|N|$]]

<blockquote>
 Any code faster or better than this, please suggest.
</blockquote>

No there is no such thing - you cannot improve on an <code>O(n)</code> algorithm if every element must be visited.

blocks|key|612515|text|你的方法很好，但我添加了更多的东西，因为缺少了不止一个数字。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|612516|eg+:+ar={1,2,4,6,10}+//+Sorted+Array

private+static+void+identifyMissingValues(Integer[]+ar)+{
++++for+(int+i+=+0;+i+<+(ar.length+-+1);+i%2B%2B)+{
++++++++int+next+=+ar[i+%2B+1];
++++++++int+current+=+ar[i];
++++++++if+((next+-+current)+>+1)+{
++++++++++++for+(int+ind+=+1;+ind+<+next+-+current;+ind%2B%2B)
++++++++++++++++System.out.println("Missing+Value+:+"+%2B+(current+%2B+ind));
++++++++}
++++}
}|code-block|syntax|javascript|612517|输出结果是，|612518|Missing+Value+:+3
Missing+Value+:+5
Missing+Value+:+7
Missing+Value+:+8
Missing+Value+:+9|612519|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Your approach is good, but I added something more for more than one numbers are missing..

<pre><code>eg : ar={1,2,4,6,10} // Sorted Array

private static void identifyMissingValues(Integer[] ar) {
 for (int i = 0; i &lt; (ar.length - 1); i++) {
 int next = ar[i + 1];
 int current = ar[i];
 if ((next - current) &gt; 1) {
 for (int ind = 1; ind &lt; next - current; ind++)
 System.out.println("Missing Value : " + (current + ind));
 }
 }
}
</code></pre>

Output is,

<pre><code>Missing Value : 3
Missing Value : 5
Missing Value : 7
Missing Value : 8
Missing Value : 9
</code></pre>

blocks|key|612521|text|Integer+[]+list+=+new+Integer[]{1,+12,+85,+6,+10};


Integer+previous+=+null;


Arrays.sort(list);

System.out.println(list);


for(int+index+=+0;+index+<+list.length;+index%2B%2B){


+++if(previous+==+null){
+++++++previous+=+(Integer)+list[index];
+++++++continue;
+++}

++++Integer+next+=+previous+%2B+1;
++++if(((Integer)+list[index]+-+previous)+>+1){

++++++++System.out.println("Missing+value+"+%2B+next);
++++++++index--;

++++}
++++previous+=+next;


}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|612522|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>Integer [] list = new Integer[]{1, 12, 85, 6, 10};


Integer previous = null;


Arrays.sort(list);

System.out.println(list);


for(int index = 0; index &lt; list.length; index++){


 if(previous == null){
 previous = (Integer) list[index];
 continue;
 }

 Integer next = previous + 1;
 if(((Integer) list[index] - previous) &gt; 1){

 System.out.println("Missing value " + next);
 index--;

 }
 previous = next;


}
</code></pre>

blocks|key|620227|text|使用BitSet而不是排序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|620228|++++int[]+ar+=+{7,+2,+6,+8,+10,+4,+3,+2};
++++int+min+=+IntStream.of(ar).min().getAsInt();
++++BitSet+b+=+new+BitSet();
++++for+(int+i+:+ar)
++++++++b.set(i+-+min);
++++int+i+=+0;
++++while+((i+=+b.nextClearBit(i+%2B+1))+<+b.length())
++++++++System.out.println(i+%2B+min);|code-block|syntax|javascript|620229|结果|620230|5
9|620231|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Use BitSet instead of sorting.

<pre><code> int[] ar = {7, 2, 6, 8, 10, 4, 3, 2};
 int min = IntStream.of(ar).min().getAsInt();
 BitSet b = new BitSet();
 for (int i : ar)
 b.set(i - min);
 int i = 0;
 while ((i = b.nextClearBit(i + 1)) &lt; b.length())
 System.out.println(i + min);
</code></pre>

result

<pre><code>5
9
</code></pre>

Written this code, would like to get better approach using any algorithm to find missing numbers from an sorted or unsorted array. If its an unsorted array, i would sort and execute the following.

<pre><code>private static void identifyMissingValues(Integer[] ar) {

 for(int i = 0; i &lt; (ar.length - 1); i++) {

 int next = ar[i + 1];
 int current = ar[i];
 if((next - current) &gt; 1) {
 System.out.println("Missing Value : " + (current + 1));
 }
 }
 }
</code></pre>

Any code faster or better than this, please suggest.

Finding missing number(s) from an array

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

写了这段代码，想得到更好的方法，使用任何算法从排序或未排序的数组中查找丢失的数字。如果它是一个未排序的数组，我将排序并执行以下命令。private static void identifyMissingValues(Integer[] ar) { for(int i = 0; i < (ar.length...

问从数组中查找缺少的数字
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从数组中查找缺少的数字EN