来接分，顺便留下你的算法【求任意长度的两个正整数数组中 重复数字的个数】
假设有两个整数数组A、B，已知这两个数组长度任意，并且每个数组中的数字都是惟一的。
要求用较快的算法求解A和B中重复的数字个数。
[解决办法]
先排序,再比较.
[解决办法]
帮顶一下
[解决办法]
var n1 = new[] { 1,2,3,4,5,6,7,8,9,10 };
var n2 = new[] { 0,2,4,6,8 };
var count=0;
foreach (var i in n1.Intersect(n2))
count++;
Console.Write(count);
Console.ReadLine();
[解决办法]
用一个 HashSet 装入数组 A 的值，然后再循环 B，判断 B 中的数字是否在 HashSet 中，若在，则加入重复数字的列表，这是否会快一些呢？
[解决办法]
- C# code
看看我写得对不对int[] Array1={1,2,3,4,5,6}int[] Array2={11,2,3,4,5,6,7,8}int len1=Array1.lengthint len2=Array2.lengthlist<int> a=new list<int>for (int i=0,i<len1,i++){ a.add(Array1(i))} for (int j=0,j<len2,j++) { if (!a.Contains(Array2(j))) { a.add(Array2(j)) } }int len3=a.lengthreturn len1+len2-len3
[解决办法]
仔细看下啊。
[解决办法]
考虑七楼的建议，另外如果数组元素范围不是太大的话也可以直接用数组
开一个和元素范围一样大的数组（用位数组就可以），先遍历一个数组，在元素出现的位置标为1,再遍历第二个数组，如果元素相应的位置是1则说明重复
[解决办法]
[解决办法]
- C# code
int[m] m1= new int{a1,a2,...,am};int[n] m2= new int{b1,b2,...,bn};int iEqualCount = 0 ;for(int i =0;i<m;i++){int iValue = m1[i];for(int j=0;j<n;j++){if(ivalue==m2[j])iEqualCount ++;}}
[解决办法]
把二个数组合成一个数组,然后排序,然后比较A[i]和A[i+1]是否相同,这样就行了.
[解决办法]
JF
[解决办法]
- C# code
using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
namespace DemoInrtArray
{
class Program
{
static void Main(string[] args)
{
int count = 0;
int[] aArray = new int[] { 1, 2, 3, 45, 6, 7, 890 };
int[] bArray = new int[] { 10, 20, 3, 6, 890, 100, 30, 1 };
int lenA = aArray.Length;
int lenB = bArray.Length;
List <int> cpArray = new List <int>();
if (lenA > lenB)
{
foreach (int a in aArray)
{
cpArray.Add(a);
}
foreach (int b in bArray)
{
if (cpArray.Contains(b))
{
count++;
cpArray.Remove(b);
}
}
}
else
{
foreach (int b in bArray)
{
cpArray.Add(b);
}
foreach (int a in aArray)
{
if (cpArray.Contains(a))
{
count++;
cpArray.Remove(a);
}
}
}
Console.Write(count);
Console.ReadLine();
}
}
}
考虑到Contains的方法实际上也是遍历进行判断，所以Remove了一下。
感觉应该有比List合适的集合，这方面接触的不多。如果2个数组大小很小的话以上代码可能只会降低效率，不过既然是长度不定的话，我还是这么写了
有什么需要改进的地方请指出
[解决办法]
14楼的算法
- C# code
using System;using System.Collections.Generic;using System.Text;using System.Collections;namespace DemoInrtArray{ class Program { static void Main(string[] args) { int count = 0; int[] aArray = new int[] { 1, 2, 3, 45, 6, 7, 890 }; int[] bArray = new int[] { 10, 20, 3, 6, 890, 100, 30, 1 }; int maxLength = aArray.Length + bArray.Length; int[] cArray = new int[maxLength]; aArray.CopyTo(cArray, 0); bArray.CopyTo(cArray, aArray.Length); int temp = 0; for (int i = 0; i < cArray.Length - 1; i++) { for (int j = 0; j < cArray.Length - i - 1; j++) { if (cArray[j] > cArray[j + 1]) { temp = cArray[j]; cArray[j] = cArray[j + 1]; cArray[j + 1] = temp; } } } for (int i = 0; i < cArray.Length; i++) { if (cArray[i] == cArray[i + 1]) { count++; i++; } } Console.Write(count); Console.ReadLine(); } }}
[解决办法]
[解决办法]
我的算法不好。。接分。。。。。
[解决办法]
楼上的都不错。
[解决办法]
直接想循环遍历了
[解决办法]
先占楼，等下补算法
[解决办法]
jf
[解决办法]
怎么获得积分呀，下载不了东西呀
[解决办法]
我在想前几天一个使用map的程序
[解决办法]
.
[解决办法]
是不是可以使用类似STL的泛型算法来解决。
假设 roster1 和 roster2 是两个存放名字的 list 对象，可使用 find_first_of 统计有多少个名字同时出现在这两个列表中：
// program for illustration purposes only:
// there are much faster ways to solve this problem
size_t cnt = 0;
list<string>::iterator it = roster1.begin();
// look in roster1 for any name also in roster2
while ((it = find_first_of(it, roster1.end(),
roster2.begin(), roster2.end()))
!= roster1.end()) {
++cnt;
// we got a match, increment it to look in the rest of roster1
++it;
}
cout << "Found " << cnt
<< " names on both rosters" << endl;
[解决办法]
up
[解决办法]
算法真厉害
[解决办法]
额 直接想的两个循环....不知道那个快
[解决办法]
[解决办法]
这个问题的最佳解决方案的原则就是先排序，然后比较就ＯＫ啦！
[解决办法]
楼主说用算法，而不是c#的特性。只能是两层循环吧
int Count=0;
for (int i=0;i<a.lenght;i++)
{
for(int j=0;j<b.lenght;j++)
{
if(a[i]==b[j])
{
Count+=1;
//最好是移除它这样下次就不用在循环了可以减少循环次数。
b.remove(b[i])
}
}
}
[解决办法]
先把数组值赋值给List泛型，再排序，再相互比较
[解决办法]
路过
[解决办法]
并且每个数组中的数字都是惟一的。
就不要排序了吧 排序还要消耗资源
[解决办法]
围观...
[解决办法]
int[] Array1={1,2,3,4,5,6}；
int[] Array2={11,2,3,4,5,6,7,8}；
int num = 0;
int len1=Array1.length；
int len2=Array2.length；
string test = string.empty；
for (int i=0,i<len2,i++)
{
test += Array2[i];
}
for(int i=0;i<len1,i++)
{
if(Array1[i].tostring().index(text)> 0)
num++;
}
[解决办法]
改成indexof
[解决办法]
学习，接分！
[解决办法]
O(n+m)算法。
[解决办法]
我觉得：
1.楼主要的是算法，而不是方法、涵数，所以6楼的答案不是最佳。
2.大家都没有考虑到数组长度的问题，如果A、B数组的长度有几十万，几百万呢？
3.很多人说先排序，但有没有想过排序工作本身也消耗资源。
4.用list和数组拼接的方法，如果数据量过大，系统不但要承受几百万次的循环，还要产生一个几百万条记录的list
5.所以我觉得34楼这样的答案比较接近楼主的要求。其实就是简单的两次循环，关键在于，34楼有想到“最好是移除它这样下次就不用在循环了可以减少循环次数”。
因为楼主有强调：“每个数组中的数字都是惟一的”，所以当在B数组找到相同的数字后，完全可以把其删除，下一次的遍历就不会判断到，B数组在判断的过程中会越来越少，b.lenght会越来越小，实际循环次数将会比其它方法的要少。当数据量达到百万级的时候，效果就非常明显了。
[解决办法]
hash表应该快
[解决办法]
Intersect()，Contains()，这些都是方法，不是算法，你们把工作全扔给了引擎。
14楼的想法也是无视的数组长度和排序所耗资源。
16楼也有删除重复记录，缩小数组，减少循环的思路，而且还争对AB数组大小来做不同的循环。美中不除还是用到了list，如果A有500万条，B有500万条，恭喜你，获得了一个1000万条的list。
[解决办法]
有 code=C/C++ 的不？？
关注。
[解决办法]
djqualls
[解决办法]
up
[解决办法]
用１位来表示一个数，当该数在数组中时该位位置1，否则为0．
如果是两层循环的话，代价太高．
[解决办法]
[解决办法]
用六楼的方法吧,一是.net自带,二是带码量少,如果不是数据量巨大,会有很大性能上的影响,作为编码人员来说,能少写一行是一行,只要微软提供了,就用现成的,开发周期更重要.
[解决办法]
当然,如果是研究人员或教学人员,不赶项目,多动动脑子考虑一下也是可以的
[解决办法]
学习一下，不太熟悉
[解决办法]
使用双套循环不如将数组1放入二叉树 在遍历数组二。复杂度虽然一样，但是实际的查询效率会高很多。另外对原始数组是否排序没有要求。
CODE：
- C# code
//建立二叉树 public class Node { public int data; public Node left; public Node right; public Node() { data = -1; } //添加Node public void AddNode(int value) { if (data == -1) { data = value; return; } if (value < data) { if (left == null) { left = new Node(); } left.AddNode(value); } else { if (right == null) { right = new Node(); } right.AddNode(value); } } //在二叉数里查询Node是否存在 public bool SelectNode(int value) { //总共查询次数 Form1.totalCount++; if (value == data) { return true; } else { if (value < data) { if (left == null) { return false; } return left.SelectNode(value); } else { if (right == null) { return false; } return right.SelectNode(value); } } } } // 程序主体 ------------ private void button2_Click(object sender, EventArgs e) { int[] a = { 9, 3, 2, 1, 7, 5, 8, 4, 6 }; int[] b = { 6, 3, 0, 11 ,1,13,2}; Node n = new Node(); for (int i = 0; i < a.Length; i++) { n.AddNode(a[i]); } int count = 0; for (int j = 0; j < b.Length; j++) { if (n.SelectNode(b[j])) { count++; } } //显示相同个数 MessageBox.Show(count.ToString()); }
[解决办法]
jf
[解决办法]
[解决办法]
其实简单和复杂并不是看现有代码的量和效率吧
比如6#说的Intersect.Count()方法，其实我们并没有考虑这个方法内部的代码是如何进行的啊，如果根据版本升级来考虑问题，那我们自己也可以写个带有2个数组参数的方法，然后直接调用这个自己的方法那不是只有一步？
[解决办法]
up
[解决办法]
我感觉可以用背包那种方法做
任意数组
所以长度是能比较的
我的设想大概是这样
foreach（int i in 长数组）{
....//正体为递归中用i和短数组逐个比较，如果相同count++；
//最后输出count
}
[解决办法]
jf
[解决办法]
说道效率的话，如果在建立这个数组的时候就考虑到是有序数组，那比较多效率会高很多
[解决办法]
看看,学习一下啦
[解决办法]
var n1 = new[] { 1,2,3,4,5,6,7,8,9,10 };
var n2 = new[] { 0,2,4,6,8 };
Console.Write(n1.Intersect(n2).Count());
水么？
[解决办法]
最笨的方法：先排好序，在挨个比较！
[解决办法]
这是一道算法复杂性的问题吧，咋个都在讨论.Net的机制问题去了呢
[解决办法]
var n1 = new[] { 1,2,3,4,5,6,7,8,9,10 };
var n2 = new[] { 0,2,4,6,8 };
Console.Write(n1.Intersect(n2).Count());
这叫算法??
完全没有移植性了..
[解决办法]
jiefen
[解决办法]
Mark
Study
[解决办法]
[解决办法]
我的思路，不成熟，大家探讨。
单纯讨论算法，既然lz要效率最高的，那就用空间换时间
已知两个数组和每个数组的长度，已知数组没有重复的数字
假设
A[]={1,2,3,4,5,6,7,8,9,10}
A.Length=10
B[]={2,0,8,4,6}
B.Length=5
1.比较两个数组长度，选其中较短的一个数组，建立其有序数组
C[]={0,2,4,6,8}
2.遍历较长的数组数据，和C中的数据比较，如果找到计数器++，从C中删除这个数据；如果没找到继续下一个
既然C已经是有序数组，每次比较就无需从头索引了，按照数组中间位置取值比大小的方法，效率应该是可以高很多
[解决办法]
[解决办法]
来顶一下啊
[解决办法]
楼上的大部分人是高级语言用的太多了吧？
这是一道算法题！
应该先排序 为 Nlog(N）复杂度
然后依次对第二个数组中的数用二分查找
二分查找的min会逐渐往后移
复杂度应该也是 Nlog(N）
所以此算法的复杂度为 Nlog(N）
[解决办法]
先排序，后删除重复的个数，最后比较，折半查找
[解决办法]
合并数组，然后像画点一样， 填另外一个同样大小的空数组。
为空的个数就是重复的个数
[解决办法]
假设有两个整数数组A、B，已知这两个数组长度任意，并且每个数组中的数字都是惟一的。
要求用较快的算法求解A和B中重复的数字个数。
每组每个数字都是唯一的。
[解决办法]
int[m] m1= new int{a1,a2,...,am};
int[n] m2= new int{b1,b2,...,bn};
int iEqualCount = 0 ;
for(int i =0;i<m;i++)
{
int iValue = m1[i];
for(int j=0;j<n;j++)
{
if(ivalue==m2[j])
iEqualCount ++;
}
}
[解决办法]
[解决办法]
顶一下
[解决办法]
学习
[解决办法]
用linq一条就可以搞定，但不知道效率如何；
[解决办法]
用Hashtable, 遍历小数组建立此table作为键值,然后遍历大数组,在hashtable中找到对应键.加1.
2.0环境下这是最省力效率也不算低的方法了.
[解决办法]
截分
[解决办法]
.0000000000000000000000000000
[解决办法]
[解决办法]
不错
[解决办法]
来找找最好的方法，自己一时想不到
[解决办法]
两个数组一起排序~ 重复的删掉.然后减去他们的总和什么的 大致就可以出来了.
[解决办法]
[解决办法]
[解决办法]
jf
[解决办法]
mark
[解决办法]
[解决办法]
Mark
[解决办法]
using System;
using System.Collections.Generic;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
public void calculate()
{
int[] arr1 = new int[5] { 1, 2, 7, 4, 5 };
int[] arr2 = new int[3] { 1, 2, 3 };
int count = 0;
for (int i = 0; i < arr1.Length; i++)
{
for (int j = 0; j < arr2.Length; j++)
{
if (arr1[i] == arr2[j])
{
count++;
}
}
}
Console.WriteLine("arr1 中与 arr2 相等的数有 " + count+" 个");
}
static void Main(string[] args)
{
Program pro = new Program();
pro.calculate();
Console.ReadLine();
}
}
}
[解决办法]
数字的唯一性不就是0-9嘛~
两个数组，从小到大排序，然后再分别对比，最快
[解决办法]
diingidng
[解决办法]
来看看。。。。
软件开发交流群 58773512 欢迎加入！！！！！
[解决办法]
接分