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();
}