cc

import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;

class cutstr
{
private final static String firststr = "hello|haha|byebye|go|run|happy|love|";

public static void main(String[] args)
{
List<String> Res = new ArrayList<String>(); //the Result
String tmpStr = new String();

for(int k = 0; k < firststr.length(); k++)
{
char c = firststr.charAt(k);
tmpStr += c;

if(c == '|')
{
Res.add(tmpStr);
tmpStr = new String();
}
}

//在控制台输出分离后的字串
/* 第一种方法：传统数组方式 */
System.out.println("The First:");
for(int i = 0; i < Res.size(); i++)
{
System.out.println(Res.get(i));
}

/* 第二种方法：泛型方式 */
System.out.println("The Second:");
for(Iterator<String> it = Res.iterator(); it.hasNext(); )
{
String s = it.next();
System.out.println(s);
}

/* 第三种方法：泛型中的改进式 */
System.out.println("The Third:");
for(String str : Res)
{
System.out.println(str);
}
}
}

第一题的方法，这不是一个好办法，无非是一个解决办法而已
std::list<int> unite(const std::list<int>& A, const std::list<int>& B)
{
std::map<int, bool> temp;
for(std::list<int>::const_iterator iter = A.begin(); iter != A.end(); iter ++){
if(temp.find(*iter) == temp.end()) temp[*iter] = true;
}
for(std::list<int>::const_iterator iter = B.begin(); iter != B.end(); iter ++){
if(temp.find(*iter) == temp.end()) temp[*iter] = true;
}
std::list<int> ret;
for(std::map<int, bool>::const_iterator iter = temp.begin(); iter != temp.end(); iter++){
ret.push_back(iter->first);
}
return ret;
}

第二题的方法
int delta[86400]; //定义每秒钟人数的变化数
memset(delta, 0, sizeof(delta)); //初始化
//打开文件
while(!feof(....)){
int online_tm, int offline_tm; //
//读入上线时间和下限时间
delta[online_tm]++;
delta[offline_tm]--;
}
int result[86400];
int begin_total; //0:00的在线数，需要初始化
int totla = begin_total;
for(int i = 0; i < 86400; i++){
result[i] = total;
total += delta[i];
}

//到这儿result 就是你要的

对于求交集的问题,我的算法是:
假设
A 元素个数为 NA
B 元素个数为 NB
NA > NB
对集合B快速排序,然后遍历集合A的元素在集合B中用2分查找
复杂度:NB*log(NB) + NA*log(NB)
如果两个都排序,光排序的时间就大于这个了

我表达的不太清晰,一天有24*3600秒
每个ID在日志中的数据格式如下:12 200 即该用户在今天的第12秒到200秒在线
日志文件中大概有2亿个这种记录,问题是求在一天中的第N 秒的在先人数

对于第二个题目写了个awk程序
~>cat luntan
#!/usr/bin/awk
{
a[$1]++;
a[$2 +1]--;
}
END{
s=0;
for(;i<=24*3600;i++)
{
s += a[i];
print "at second "i " total ID = " s;
}
}
测试的话可以手动或用脚本生成日志文件
~>awk -f luntan logfile
or
~>echo 2 20 |awk -f luntan

在win32和32位编译器的环境下，结构体（struct和class）中的数据域是按声明的先后顺序，“向上生长”的。就是说若结构体A中按先后声明了两个域a、b，则存放b的地址大与存放a的地址！注意，有些编译器为了提高在32位系统中对内存的访问速度，所以使用了内存对齐技术--结构体中的各个域是按4字节对齐的！

我们假设楼主提供的题目如下：
#include <stdlib.h>
#include <stdio.h>
class a {
short m_a1;
short m_a2;
public:
a() {
m_a1 = 1;
m_a2 = 2;
}
void fun() {
printf("%d,%d", m_a1, m_a2);
}
};

class b{
int m_a3;
b() {
m_a3 = 3;
}
public:
void fun() {
printf("%d", m_a3);
}
};

int main() {
printf("sizeof a, b = %d %d\n", sizeof(a), sizeof(b));
a a;
b *pb;
pb = (b*)(&a);
pb -> fun();
}

就是说，a的大小是8字节，b的大小是4字节！
而b::fun()就是按int的格式输出结构体中的前四个字节！所以输出1！

但是，若没有使用内存对齐技术！上面的问题就麻烦了！
a和b 的大小都是4字节！

a a+2
1 2 -> (2 << 16) | 1

所以应该输出：

131073

结果是1
pb=(b*)(&A); 将A的地址传给了pb,并强制转化为b类的地址
pb->fun(); 调用b 的fun()方法,不过此时ma_3,是a类的ma_1,所以输出1

你可以改一下程序运行就知道了
#include <stdio.h>
class a
{
char m_a1;
char m_a2;
public:
a(){m_a1=1;m_a2=2;}
void fun(){printf("%d,%d",m_a1,m_a2);}
};
class b
{
char m_a3;
public:
b(){m_a3=3;}
void fun(){printf("%dggggg",m_a3);}//可以看出是调用了该方法
};
void main()
{
a A;
b *pb;
pb=(b*)(&A);
pb->fun();
}