struct A{//8
A();
~A();
int m1;
int m2;
}a;
A::A(){};
A::~A(){};
B();
~B();
int m1;
char m2;
static char m3;
}b;
B::B(){};
B::~B(){};
C();
virtual ~C();
int m1;
int m2;
}c;
C::C(){};
C::~C(){};
sizeof(a)=sizeof(m1)+sizeof(m2)=4+4
sizeof(b) = sizeof(m1)+sizeof(m2) =4+1 但是，static不算，并且内存对齐，也就是必须是占内存最多的那个量的倍数，即sizeof（m1）的倍数，即2*4=8>5，所以选8
sizeof（c）=sizeof（*）+sizeof（m1）+sizeof（m2）=4+4+4 虚函数存在代表一个指针用，所以用sizeof（*），指针大小是4.
ps：都要内存对齐，但是第一个第三个已经对齐了。
2.求有权树任两节点间最长路径的时间复杂度
****************************************************************************************************************************************
用dp的思想，求出子孩子的，然后根据子孩子的求父亲的。以此类推。ps:树中最长的路径的两个端点中其中必然有一个是叶子（除了只有根的树）
3.求两个20x20的方阵放在100x100方阵中重合的概率
****************************************************************************************************************************************
x1,x2,y1,y2取值范围均[10,90]
p(|x1-x2|<20)=p(-20<x1-x2<20)=7/16
同理p(|y1-y2|<20)=7/16
原=p(|x1-x2|<20)*p(|y1-y2|<20)=49/256(运用的是几何概型)
4.给出后序遍历 求可能的先序遍历
****************************************************************************************************************************************
解法就是递归分出根的左、右孩子之后，将左边（或者右边）的字符串当成需要解决的字符串重新调用自身。
5.据说有一道和poj1088类似的题目
****************************************************************************************************************************************
有人用了个优先队列+dp就过了。想想也是，只能从高处向下。。。
有人写的dfs+dp。我感觉比我的想法多了暴搜这一层。
还有的呢，跟我第一想法有相似之处。但是呢，在找的时候用了分治。就是不是用数据记录，而是每次都递归。
http://www.cnblogs.com/linpeidong2009/archive/2012/03/18/2404737.html
6.Define an integer as a point in a one-dimensional space. Give an array that contains N points, return the first minimal window which contains at least ground(N/2) points.
****************************************************************************************************************************************
7.死锁的四个条件
****************************************************************************************************************************************
循环等待条件（circular wait) 互斥（mutual exclusion) 不可抢占（no preemption) 请求与保持（hold and wait)
8.深浅拷贝
****************************************************************************************************************************************
在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。
深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。
9.寻找第k大数
****************************************************************************************************************************************
10.抽象类能定义abstract table吗？
****************************************************************************************************************************************
表示不清楚。抽象类不能定义对象吧。。。
11. Windows 7 下 the size of short int pointer,long int pointer on 32-bits computer and 64-bits computer
****************************************************************************************************************************************
这题的陷阱1：都是指针
陷阱2：32和64位上字长上有变化的是:long 和指针从原来的32变为了64
因此答案如下： 4bytes，4bytes，8bytes，8bytes
12.并发控制
****************************************************************************************************************************************
读脏数据 不可复读 丢失修改
13.死锁的四个条件
****************************************************************************************************************************************
将中文对应为英文：循环等待条件（circular wait) 互斥（mutual exclusion) 不可抢占（no preemption) 请求与保持（hold and wait)
4.1、互斥使用（资源独占）
一个资源每次只能给一个进程使用
4.2、不可强占（不可剥夺）
资源申请者不能强行的从资源占有者手中夺取资源，资源只能由占有者自愿释放
4.3、请求和保持（部分分配，占有申请）
一个进程在申请新的资源的同时保持对原有资源的占有（只有这样才是动态申请，动态分配）
4.4、循环等待
存在一个进程等待队列
{P1 , P2 , … , Pn},
其中P1等待P2占有的资源，P2等待P3占有的资源，…，Pn等待P1占有的资源，形成一个进程等待环路
14.ping 是基于什么协议的？
****************************************************************************************************************************************
ICMP(ICMP是（Internet Control Message Protocol）Internet控制报文协议。它是TCP/IP协议族的一个子协议，用于在IP主机、路由器之间传递控制消息。控制消息是指网络通不通、主机是否可达、路由是否可用等网络本身的消息。这些控制消息虽然并不传输用户数据，但是对于用户数据的传递起着重要的作用。)
15.堆排序
****************************************************************************************************************************************
//堆是从1开始的。
#define MAX 100//数据元素的最大个数
typedef struct
{
int r[MAX];
int length;
}SqList;//定义一个线性表用于存放数据元素
void HeapAdjust(SqList &L,int s,int m)
{//已知L.r[s...m]中记录除L.r[s]外均满足堆的定义，本函数用于使L.r[s...m]成为一个大顶堆
int j;
int e=L.r[s];
for(j=2*s;j<=m;j*=2)
{
if(j<M&&L.R[J]<L.R[J+1]) ++j;
if(e>=L.r[j]) break;
L.r[s]=L.r[j];
s=j;
}
L.r[s]=e;
}
void HeapSort(SqList &L)
{//对顺序表L进行堆排序
int i,e;
for(i=L.length/2;i>0;i--)
HeapAdjust(L,i,L.length);
for(i=L.length;i>1;i--)
{//将大顶堆的顶记录和最后一个记录相互交换
e=L.r[1];
L.r[1]=L.r[i];
L.r[i]=e;
HeapAdjust(L,1,i-1);
}
}
16.快排
****************************************************************************************************************************************
非递归实现快排
#include <iostream>
using namespace std;
int partition(int *a, int l, int h)
{
int x = a[l];
int i = l;
int j = h+1;
int temp;
while (i<j)
{
while (a[++i]<x&&i<h);
while(a[--j]>x);
if (i<j)
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
a[l] = a[j];
a[j] = x;
return j;
}
void qsort(int *a, int l, int h)
{
if (l>=h)
return;
int *s = new int[h-l+1];
int p = 0;
s[p++] = l;
s[p++] = h;
int low,high,q;
while (p>0)
{
high = s[--p];
low = s[--p];
if (low>=high)
break;
q = partition(a, low, high);
if (q-low > high-q)
{
s[p++] = low;
s[p++] = q-1;
if (high > q)
{
s[p++] = q+1;
s[p++] = high;
}
}
else
{
s[p++] = q+1;
s[p++] = high;
if (q > low)
{
s[p++] = low;
s[p++] = q-1;
}
}
}
delete []s;
}
17.
****************************************************************************************************************************************
UTF-8 3个字符表示汉语
UTF-16 2个字符表示汉语，且有两个字符表示是大尾还是小尾。
UTF-7 貌似用7位元表示ASCII码，这个不懂。。。
18.SPFA
****************************************************************************************************************************************
int spfa()
{
int vis[N];
int dis[N];
memset(vis,0,sizeof(vis));
for(int i=1;i<=n;i++)
dis[i]=inf;
queue<int>myqueue;
while(!myqueue.empty())myqueue.pop();
vis[1]=1;
dis[1]=0;
myqueue.push(1);
while(!myqueue.empty())
{
int top=myqueue.front();
vis[top]=0;
myqueue.pop();
for(int i=0;i<edge[top].size();i++)
{
int v=edge[top][i].v;
int len=edge[top][i].len;
if(dis[v]>dis[top]+len)
{
dis[v]=dis[top]+len;
if(!vis[v])
{
vis[v]=1;
myqueue.push(v);
}
}
}
}
return dis[n];
}
19.求素数
****************************************************************************************************************************************
#include <cstdio>
#include <cstring>
#define maxn 30
int N = 1000;
int prime[maxn],plen;
bool flag[maxn];
void mkprime() {
memset(flag, -1, sizeof(flag));
plen = 0;
for (int i = 2; i < N; i++) {
if (flag[i]) {
prime[plen++] = i;
}
for (int j = 0; (j < plen) && (i * prime[j] < N); j++) {
flag[i * prime[j]] = 0;
if (i % prime[j] == 0) {
break;
}
}
}
}
#include <cmath>
#include <algorithm>
int factor[100],len_pfactor,pfactor[1111] ,
cpfactor[1111];
typedef long long LL;
void findpFactor(LL n) {
int i, te, cnt;
te = (int) sqrt(n * 1.0);
for (i = 0, len_pfactor = 0; (i < plen) && (prime[i] <= te); i++) {
if (n % prime[i] == 0) {
cnt = 0;
while (n % prime[i] == 0) {
cnt++;
n /= prime[i];
}
pfactor[len_pfactor] = prime[i];//有谁
cpfactor[len_pfactor++] = cnt;//有几个
}
}
if (n > 1) {
pfactor[len_pfactor] = n;
cpfactor[len_pfactor++] = 1;
}
}
int len_factor = 0;
void dfs(int k, LL now) {//这个dfs好神
if (k == len_pfactor) {
factor[len_factor++] = now;
return;
}
int i;
for (i = 0; i < cpfactor[k]; i++) {
now = now * pfactor[k];
dfs(k + 1, now);
}
for (i = 0; i < cpfactor[k]; i++) {
now = now / pfactor[k];
}
dfs(k + 1, now);
}
int main(){
mkprime();
findpFactor(100);
dfs(0,1) ; for(int i = 0; i < len_factor;i ++) printf("%d\n", factor[i]);
return 0;
}
20.最小生成树
****************************************************************************************************************************************
void Prim(int u)
{
int i,j,k;
double min;
for(i=1;i<=n;i++)
if(i!=u)
lowcost[i]=weight[1][i];
visit[1]=true;
for(i=1;i<n;i++) //最小生成树有n-1条边
{
min=maxm;
for(j=1;j<=n;j++)
if(lowcost[j]<min && !visit[j]){
min=lowcost[j];
k=j; //记录哪个点与当前最小生成树的距离最小
}
sum+=min;
visit[k]=true;
for(j=1;j<=n;j++)
if(lowcost[j]>weight[k][j] && !visit[j])
lowcost[j]=weight[k][j];
}
}
21.static
****************************************************************************************************************************************
百科：http://baike.baidu.com/view/536145.htm
22.引用和指针
****************************************************************************************************************************************
http://www.cnblogs.com/skynet/archive/2010/09/22/1832911.html
//ps:这人将指针和引用讲到了反编译。。。笔试回来看吧。。。
int main(){
int i = 10;
const int* p = &i;//表示不能通过指针p间接修改，但是可以通过i修改
int* const p = &i;//表示p的指向不能变，可以通过p间接修改；必须初始化
const int& p = i;//表示不能通过引用p间接修改，但是可以通过i修改
//int& const p = &i; 引用开始必须初始化，而且矢志不渝；所以，这个是不需要的。
*p = 11;
return 0;
}
//总结：有一个规则可以很好的区分const是修饰指针，
//还是修饰指针指向的数据——画一条垂直穿过指针声明的星号（*），
//如果const出现在线的左边，指针指向的数据为常量；如果const出现在右边，
//指针本身为常量。而引用本身与天俱来就是常量，即不可以改变指向。
如何求一堆数的gcd。。
C++面向对象继承、封装、多态相关代码分析
541
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
