两道面试题,麻烦看下,分数不够再加.........................................

[zhoudengpan102]

1.有两个 升序数组(元素个数不定)
数组A: [1,3,5,7,,9,11]
数组B: [2,4,6,8,10,11,13]
两个数组按升序合并,剔除掉重复项
输出结果: [1,2,3,4,5,6,7,8,9,10,11,13]
2.有一个集合,里面有N个数组(数组个数元素不定),组合出所有可能出现的数.
假设有三个数组: 数组A: 12 15 19 16
数组B: 21 64 48
数组C: 48 87 26
结果: 122148 122187 122426....................

C# 或者 JAVA 实现 第二题 递归实现(循环好象很难实现)

[zhoudengpan102]

有时间的话,能不能帮我做下, 能否贴下代码?

[zhoudengpan102]

1楼的第一题有点投机取巧,能否有更好的方法!!

[周公]

这两道题都是考算法的。
第一道题可以二分法来插入。
第二道题用循环能实现，但是感觉太笨了。

[masterkill]

第二题：一棵树，深度=某具有最多元素个数的数组元素个数+1，每个数组都是树的“从根到子节点的一个遍历过程”，即要求遍历这棵树，列出所有节点，那么组合出的数的个数就=每层节点数的乘积
我不会C#,不过觉得肯定有对Tree的封装，应该每个节点是一个对象

[zhoudengpan102]

8楼的思路是好的,不知道怎么实现,能否有时间帮我做做.谢谢了.

[masterkill]

[Quote=引用 9 楼 zhoudengpan102 的回复:]
8楼的思路是好的,不知道怎么实现,能否有时间帮我做做.谢谢了.
[/Quote]
我会用C++，汇编和Pasic，C#我刚学，没几天，来这也是学习的，实在帮不了你
别着急，肯定有人写的，还早

[sunny3106]

第一题明显的归并排序，注意下相等的情况就行了
第二题没怎么看明白，这个出现的数是什么数呢？是说数组吗，相当于三个数组归并后的子集？

[liuyeede]

第一题：
你自己研究一下，改成C#的。
我是在网上找的：
两种归并排序算法的实现：二路归并排序和基本归并排序（虚拟消除递归的二路归并排序）

#define ARRAY_SIZE 1024

int B[1024]; //使用一个全局变量，避免归并排序中每次都重新申请和释放空间造成的开销

template <typename T>
void Merge(T A[], int l, int m, int h)
{
int i = l;
int j = m+1;
int k = 0;

while(i<=m&&j<=h)
{
if(A[i]<A[j])
{
B[k++] = A[i];
i++;
}
else
{
B[k++] = A[j];
j++;
}
}

while(i<=m)
{
B[k++] = A[i++];
}

while(j<=h)
{
B[k++] = A[j++];
}

for(i=l; i<=h; i++)
{
A[i] = B[i-l];
}
}

//二路归并排序的实现

template <typename T>
void MergeSort(T a[], int l, int h)
{
int m = (h+l)/2;
if(l>=h)
{
return;
}

if(l+1==h)
{
if(a[l]>a[h])
{
std::swap(a[l], a[h]);
}

return;
}

MergeSort(a, l, m);
MergeSort(a, m+1, h);
Merge(a, l, m, h);
}

//将a经过步长s归并到b中，n表示数组的大小
template <typename T>
void Merge2(T a[], T b[], int s, int n)
{
int m = 0;

//从头至尾按照步长s进行相邻数据的合并
for(int i=0; i<n; i+=2*s)
{
int j = i; //合并的第一组数的起始位置
int k = i+s; //合并的第二组数的起始位置
int jE = i+s; //合并的第一组数的起始位置
int kE = i+2*s; //合并的第二组数的起始位置

while((j<jE)&&(k<kE)&&j<n && k<n)
{
if(a[j]<a[k])
{
b[m++] = a[j];
j++;
}
else
{
b[m++] = a[k];
k++;
}
}

while((j<jE)&&(j<n))
{
b[m++] = a[j++];
}

while((k<kE)&&(k<n))
{
b[m++] = a[k++];
}
}
}

//基本归并排序，虚拟消除递归
template <typename T>
void MergeSort2(T a[], int n)
{
int s = 1; //merge 的步长
T* b = new T[n];

while(s<n)
{
Merge2(a, b, s, n); //由a合并到b
s += s;

Merge2(b, a, s, n); //由b合并到a
s += s;
}

delete[] b;
}

//使用如下代码在VS2005中可以对两种归并排序进行性能比较，

//基本归并排序的时间性能稍微好一点，基本归并排序直接对数据按步长Merge，

//而二路归并排序需要将数据先不断的分层，到为一个或者两个元素时再进行Merge

void main()
{
int * p = new int[ARRAY_SIZE];
int i = 0;

for(i=0; i<ARRAY_SIZE; i++)
{
*(p+i) = rand()%ARRAY_SIZE;
}
MergeSort(p, 0, ARRAY_SIZE-1);


for(i=0; i<ARRAY_SIZE; i++)
{
*(p+i) = rand()%ARRAY_SIZE;
}
MergeSort2(p, ARRAY_SIZE);


delete[] p;
}

[readfuture]

[Quote=引用 1 楼 ljhcy99 的回复:]
1.
Arraylist list = new Arraylist ();
for(int i=0;i <A.length();i++)
{
list.Add(A[i]);
}
for(int j=0;j <B.length();j++)
{
if(!list.contains(B[j]))
{
list.Add(B[j]);
}
}
list.sort();

2，也差不多跟第一题一样，注意下标就可以。循环多一点，也可以用hash实现，
[/Quote]
up

[liuyeede]

这个地址的是C#的算法http://www.cnblogs.com/chencaixia/archive/2008/03/21/1116257.html

[zzxap]

Arraylist list = new Arraylist ();
for(int i=0;i <A.length();i++)
{
list.Add(A[i]);
}
for(int j=0;j <B.length();j++)
{
if(!list.contains(B[j]))
{
list.Add(B[j]);
}
}
list.sort();
强

[liuyeede]

第二题请参考：书遍历算法。
http://http://www.cndw.com/tech/program/2006042152578.asp
http://www.cndw.com/tech/program/2006042152577.asp
http://www.cndw.com/tech/program/2006042152576.asp

[黑哥]

[Quote=引用 1 楼 ljhcy99 的回复:]
1.
Arraylist list = new Arraylist ();
for(int i=0;i <A.length();i++)
{
list.Add(A[i]);
}
for(int j=0;j <B.length();j++)
{
if(!list.contains(B[j]))
{
list.Add(B[j]);
}
}
list.sort();

2，也差不多跟第一题一样，注意下标就可以。循环多一点，也可以用hash实现，
[/Quote]



恩。。

[Teng_s2000]

UP

强烈建议将Arraylist 改成List<T>
Arraylist 涉及装箱拆箱

[青梦奇缘]

第一题你搜下冒泡排序 ， 至于 有一样的元素去除只要稍加处理就OK的！

[刀枪blue]

List<int> list = new List<int>();
            foreach (int a in A)
                list.Add(a);
            foreach (int b in B)
            {
                if (!list.Contains(b))
                    list.Add(b);
            }
            list.Sort();

[zhangdong3691314]

up

[liuyeede]

这帮小子，这是面试题，考得是数据结构。。。。，要是用.net给你打包好的东西去解决这种问题，Too easy！

[jxaa153659]

第一题因为数组是N个元素，所以要提高效率，就不能用普通的排序法。
解答：因为两个数组都是已经排序好的。所以你声明一个集合，然后直接比较两个数组的最小值，把较小的插入集合
然后除去刚才插入的数据（如果刚才两个比较的数据相同则都除去），继续比较两个数组的最小值，把较小的插入集合，以此类推。最后集合的内容就是按从小到大排序的！这样不需要用程序去排序，只需要比较运算即可。毕竟排序的操作还是要花费很多时间和资源，特别是数组足够长的时候。


第二题 如果要得到有多少个这个的组合 其实就是N个数组的长度之积，如果要得到所有的组合数字，其实按道理讲还是循环比较好，比较实在。递归也可以做，递归函数还是比较简单，只需要一个两个参数，一个是数组，一个是组合数字的前缀（比如{48 87 26}，1221）,函数内就循环数组内所有的数字并和前缀连接，然后把这个数字和下一个数组传入递归函数。
以上只是得到了多少个组合，同一个组合内的元素顺序不同得到的数字也是不同的。根据一个组合内元素的数量就可以得到有多少种排序，即数字。
知道了组合的数量，一个组合内的元素数量，就可以算出所有的组合数字，除掉重复的数字，剩下的数字就是题目的答案。所有的组合数字。

楼主可以参考我的说明写出代码。

最后希望我的解答对楼主有作用。

[小雨后阳光]

第一题因为数组是N个元素，所以要提高效率，就不能用普通的排序法。
解答：因为两个数组都是已经排序好的。所以你声明一个集合，然后直接比较两个数组的最小值，把较小的插入集合
然后除去刚才插入的数据（如果刚才两个比较的数据相同则都除去），继续比较两个数组的最小值，把较小的插入集合，以此类推。最后集合的内容就是按从小到大排序的！这样不需要用程序去排序，只需要比较运算即可。毕竟排序的操作还是要花费很多时间和资源，特别是数组足够长的时候。

楼上正解！时间O（N），每次contains总时间是o(N^2)，很低效的，
2。

第二题 如果要得到有多少个这个的组合其实就是N个数组的长度之积，如果要得到所有的组合数字，其实按道理讲还是循环比较好，比较实在。递归也可以做，递归函数还是比较简单，只需要一个两个参数，一个是数组，一个是组合数字的前缀（比如{48 87 26}，1221）,函数内就循环数组内所有的数字并和前缀连接，然后把这个数字和下一个数组传入递归函数。
以上只是得到了多少个组合，同一个组合内的元素顺序不同得到的数字也是不同的。根据一个组合内元素的数量就可以得到有多少种排序，即数字。
知道了组合的数量，一个组合内的元素数量，就可以算出所有的组合数字，除掉重复的数字，剩下的数字就是题目的答案。所有的组合数字。
楼上正解
但应该还要一个hash判断重复出现的数字，就完美了