面试题总结 4

1.38头牛中选出3头跑得最快的，使用一个每次只能供6头比赛的场地，要求用最快的方法.
答：9次
2.将二叉树的两个孩子换位置，即左变右，右变左。不能用递规（变态！）

递归的版本：

void change( BTree * pTree ) 
{ 
    if( NULL == pTree ) 
        return; 
    BTree * pTemp = pTree.left; 
    pTree-> left = pTree-> right; 
    pTree-> right= pTemp; 
    change( pTree-> left ); 
    change( pTree-> right ); 
} 
＝＝＝＝＝＝＝＝＝＝＝＝＝使用队列＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

    算法思想：

    1、根结点入队列，即放入列尾。

    2、从队列中取出一个结点，即从队列头部取出一个元素。

    3、将取出来的结点的左右儿子交换，然后依次放入队列尾部。

    4、如果队列不为空，循环执行第2、3步。
    迭代版的如下，使用了队列 
    void change(BTree * pTree ) 
{ 
    if( NULL == pTree ) 
        return; 
    queue <BTree*> qu; 
    qu.push(pTree); 
    BTree*pTree2 = null; 
    while(!qu.empty()
    { 
        pTree2= qu.front( ); 
        qu.pop(); 
        BTree * pTemp = pTree2-> left; 
        pTree2-> left = pTree2-> right; 
        pTree2-> right= pTemp; 
        if(pTree2-> left!=null) 
            qu.push(pTree2-> left); 
        if(pTree2-> right!=null) 
            qu.push(pTree2-> right);    
    }    

} 

3.序列分组交换协议（SPX）
是 Novell 早期传输层协议，为 Novell NetWare 网络提供分组发送服务。
SPX 基于 Xerox 序列分组协议（SPP：Sequenced Packet Protocol）。SPX 运行在 IPX 上，主要为
Novell NetWare（NetWare 5.0 之前）系统实现客户机/服务器上应用程序的通信服务，例如BTRIEVE
（ISAM 管理器）。SPX 与 TCP 实现同等功能。最新版本的 NetWar 运行在 TCP/IP 上。

4.属于数据链路层功能的是描述网络拓扑结构流控制

5.IEEE802.3u标准是100兆比特每秒以太网的标准。100Base-T技术中可采用3类传输介质，即100Base-T4、100Base-TX和100Base-FX，它采用4B/5B编码方式是指快速以太网

6.如果要将两计算机通过双绞线直接连接，正确的线序是

1–3、2–6、3–1、4–4、5–5、6–2、7–7、8–8

7.路由器作为网络互连设备，必须具备以下哪些特点
1.至少支持两个网络接口
2.协议至少要实现到网络层
3.具有存储转发和寻径的功能

8.路由器的作用有
异种网络互联
子网间的速率适配
隔离网络，防止网络风暴，指定访问规则（防火墙）
路由（寻径）：路由表建立、刷新、查找

9.两个数 int a, int b,不用中间变量交换两个值的C++代码

1、加减法：该方法可以交换整型和浮点型数值的变量，但在处理浮点型的时候有可能出现精度的损失
a = a + b;
b = a - b;
a = a - b;
2、异或法：可以完成对整型变量的交换，对于浮点型变量它无法完成交换。
a = a^b;
b = a^b;
a = a^b;
3、乘除法：可以处理整型和浮点型变量，但在处理浮点型变量时也存在精度损失问题。而且乘除法比加减法要多一条约束：b必不为0。
a = a * b
b = a / b
a = a / b

10.memcpy(),memset(),memmove()

    void * memcpy ( void * destination, const void * source, size_t num );

Linux下的
    void *memcpy(void *dest, const void *src, size_t count)
{
    char *tmp = dest;
    const char *s = src;
    while (count--)
        *tmp++ = *s++;
    return dest;
}

void *(memset) (void *s,int c,size_t n)  
{  
    const unsigned char uc = c;  
    unsigned char *su;  
    for(su = s;0 < n;++su,--n)  
        *su = uc;  
    return s;  
}


void *memmove(void *dest,const void *src,size_t count)
{
    void *ret=dest;
    if(dest == NULL || src == NULL)
        return;
    //这里来判别dest和src是否是指向同一字符串中不同位置，
    //如果是指向同一字符串，但是dest在src前面，则可以从前往后逐个赋值
    //如果是指向同一字符串，但是dest在src后面，且dest>=src+count,那么仍然从前往后赋值
    if(dest<=src||dest>=src+count)
    {
        while(count--)
            *dest++=*src++;
    }

    //如果是指向同一字符串，但是dest在src后面，且dest<=src+count,那么从后往前赋值
    else
    {
        dest+=count-1;
        src+=count-1;
        while(count--)
            *dest--=*src--;
    }
    return ret;
}

11.string 类型的重写已知类String的原型为：

class String
{
public:
    String(const char *str = NULL);// 普通构造函数
    String(const String &other); //拷贝构造函数
    ~ String(void); //析构函数
    String & operator =(const String &other);//赋值函数
private:
    char *m_data;// 用于保存字符串
};
请编写String的上述4个函数。
    //普通构造函数
    String::String(const char *str)
{
    if(str==NULL)
    {
        m_data = new char[1]; // 对空字符串自动申请存放结束标志'\0'的//加分点：对m_data加NULL 判断
        *m_data = '\0';
    }
    else
    {
        int length = strlen(str);
        m_data = new char[length+1]; // 若能加 NULL 判断则更好
        strcpy(m_data, str);
    }
}
// String的析构函数
String::~String(void)
{
    delete[] m_data; // 或delete m_data;
}
//拷贝构造函数
String::String(const String &other) // 输入参数为const型
{
    int length = strlen(other.m_data);
    m_data = new char[length+1]; //对m_data加NULL 判断
    strcpy(m_data, other.m_data);
}
//赋值函数
String & String::operator =(const String &other) // 输入参数为const
    型
{
    if(this == &other) //检查自赋值
        return *this;
    delete[] m_data; //释放原有的内存资源
    int length = strlen( other.m_data );
    m_data = new char[length+1]; //对m_data加NULL 判断
    strcpy( m_data, other.m_data );
    return *this; //返回本对象的引用
}

12.声明一个空类的话 占一个字节数
类中的函数并不占字节数
类和结构体一样，内部对齐

 class A
{
    void Go();//这个不占字节数
    int x;
};

sizeof(A) = 4 ...

感觉上是在类内部加上一个变量，然后类的大小就变成了里面变量的大小