2016腾讯春招模拟笔试

虽然不知道为什么腾讯还有模拟笔试，然而还是乖乖做了，发现选择题考得比较基础，编程题也不像腾讯的难度啊。根据草稿纸上的内容整理了一下考到的知识点。

1、64位linux系统下，short,int ,long 占的字节。

 理论上来讲 我觉得数据类型的字节数应该是由CPU决定的，但是实际上主要由编译器决定(占多少位由编译器在编译期间说了算)。

常用数据类型对应字节数
  可用如sizeof（char),sizeof(char*)等得出

 32位编译器：

      char ：1个字节
      char*（即指针变量）: 4个字节（32位的寻址空间是2^32, 即32个bit，也就是4个字节。同理64位编译器）
      short int : 2个字节
      int：  4个字节
      unsigned int : 4个字节
      float:  4个字节
      double:   8个字节
      long:   4个字节
      long long:  8个字节
      unsigned long:  4个字节

  64位编译器：

      char ：1个字节
      char*(即指针变量): 8个字节
      short int : 2个字节
      int：  4个字节
      unsigned int : 4个字节
      float:  4个字节
      double:   8个字节
      long:   8个字节
      long long:  8个字节
      unsigned long:  8个字节

2、红黑树，AVL树比较

红黑树的定义 
　　正如在CLRS中定义的那样（译者： CLRS指的是一本著名的算法书Introduction to Algorithms，中文名应该叫算法导论，CLRS是该书作者Cormen, Leiserson, Rivest and Stein的首字母缩写），一棵红黑树是指一棵满足下述性质的二叉搜索树（BST, binary search tree）： 
　　1. 每个结点或者为黑色或者为红色。 
　　2. 根结点为黑色。 
　　3. 每个叶结点(实际上就是NULL指针)都是黑色的。 
　　4. 如果一个结点是红色的，那么它的两个子节点都是黑色的（也就是说，不能有两个相邻的红色结点）。 
　　5. 对于每个结点，从该结点到其所有子孙叶结点的路径中所包含的黑色结点数量必须相同。 
　　数据项只能存储在内部结点中（internal node）。我们所指的"叶结点"在其父结点中可能仅仅用一个NULL指针表示，但是将它也看作一个实际的结点有助于描述红黑树的插入与删除算法，叶结点一律为黑色。 
　　定理：一棵拥有n个内部结点的红黑树的树高h<=2log(n+1) 

红黑树并不追求“完全平衡”——它只要求部分地达到平衡要求，降低了对旋转的要求，从而提高了性能。

红黑树能够以O(log2 n) 的时间复杂度进行搜索、插入、删除操作。此外，由于它的设计，任何不平衡都会在三次旋转之内解决。当然，还有一些更好的，但实现起来更复杂的数据结构 能够做到一步旋转之内达到平衡，但红黑树能够给我们一个比较“便宜”的解决方案。红黑树的算法时间复杂度和AVL相同，但统计性能比AVL树更高。

 

AVL树是最先发明的自平衡二叉查 找树。在AVL树中任何节点的两个儿子子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O(log n)。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者 G.M. Adelson-Velsky 和 E.M. Landis，他们在 1962 年的论文 "An algorithm for the organization of information" 中发表了它。

 

引入二叉树的目的是为了提高二叉树的搜索的效率,减少树的平均搜索长度.为此,就必须每向二叉树插入一个结点时调整树的结构,使得二叉树搜索保持平衡,从而可能降低树的高度,减少的平均树的搜索长度. 

AVL树的定义: 
一棵AVL树满足以下的条件: 
1>它的左子树和右子树都是AVL树 
2>左子树和右子树的高度差不能超过1 
从条件1可能看出是个递归定义,如GNU一样. 

性质: 
1>一棵n个结点的AVL树的其高度保持在0(log2(n)),不会超过3/2log2(n+1) 
2>一棵n个结点的AVL树的平均搜索长度保持在0(log2(n)). 
3>一棵n个结点的AVL树删除一个结点做平衡化旋转所需要的时间为0(log2(n)). 

从1这点来看红黑树是牺牲了严格的高度平衡的优越条件为 代价红黑树能够以O(log2 n)的时间复杂度进行搜索、插入、删除操作。此外，由于它的设计，任何不平衡都会在三次旋转之内解决。当然，还有一些更好的，但实现起来更复杂的数据结构 能够做到一步旋转之内达到平衡，但红黑树能够给我们一个比较“便宜”的解决方案。红黑树的算法时间复杂度和AVL相同，但统计性能比AVL树更高. 

        当然，红黑树并不适应所有应用树的领域。如果数据基本上是静态的，那么让他们待在他们能够插入，并且不影响平衡的地方会具有更好的性能。如果数据完全是静态的，例如，做一个哈希表，性能可能会更好一些。

3、100M的交换机和20个端口，下载1G电影要的时间

       理论上是20口的当前速率加在一起不大于100M，设置时可以平均分配为100/20=5。但实际使用最好根据这款交换机的说明文档进行配置，另外有条件的话，需要进行实际的压力测试，实际的数据在近乎理论值的时候，有可能因交换机背板带宽承受不住等各种原因，导致丢帧等不稳定的情况，甚至质量差的设备可能到不到标称的效果。

4、5台打印机，每个进程要2台，一次只能申请一台，不发生死锁至多允许几个进程参与竞争：4个

5、查找出现次数超过一半的字符

方法1：一边扫描，相当于每次消去2个不同的元素，最后剩下的肯定是要找的元素

方法2：利用哈希表或者数组统计每个字符出现的次数，然后从里面找到出现次数超过一半的

方法3：排序后，取数组的中间元素

#include "stdafx.h"  
#include<iostream>  
#include<map>  
#include<algorithm>  
using namespace std;  
  
int findSingle1(int a[] ,int len)//一遍扫描法  
{  
    int tmp = a[0];  
    int count = 1;  
    for(int i=1;i<len;i++)  
    {  
        if(count == 0)  
        {     
            tmp = a[i];  
            count++;  
            continue;  
        }  
        if(a[i] == tmp)  
            count++;  
        else{  
            count--;  
        }  
    }  
    return tmp;  
}  

int findSingle2(int a[], int len)//hashmap 统计  
{  
    map<int,int> imap;  
    map<int,int>::iterator it ;  
    for(int i=0;i<len;i++)  
    {  
        it = imap.find(a[i]);  
        if(it!=imap.end())  
        {  
            (*it).second++;  
        }else{  
            imap[a[i]] = 1;  
        }  
    }  
  
    it = imap.begin();  
    while(it!=imap.end())  
    {  
        if((*it).second > len/2)  
            return (*it).first;  
        it++;  
    }  
    return -1;  
}  
  
int findSingle3(int a[],int len)//排序后取中间元素  
{  
    sort(a,a+len);  
    return a[len/2];  
}  
int _tmain(int argc, _TCHAR* argv[])  
{  
    int a[] = {1,3,4,8,5,1,2,5,5,5,5,5,5};  
    int len = sizeof(a)/sizeof(int);  
    cout<<findSingle3(a,len)<<endl;  
    getchar();  
    return 0;  
}  

6、大整数乘法

http://blog.csdn.net/tjsinor2008/article/details/5625849

7、递归法写出N位格雷码

n位元格雷码是基于n-1位元格雷码产生的

1. public String[] GrayCode(int n) {  
2.   
3.     // produce 2^n grade codes  
4.     String[] graycode = new String[(int) Math.pow(2, n)];  
5.   
6.     if (n == 1) {  
7.         graycode[0] = "0";  
8.         graycode[1] = "1";  
9.         return graycode;  
10.     }  
11.   
12.     String[] last = GrayCode(n - 1);  
13.   
14.     for (int i = 0; i < last.length; i++) {  
15.         graycode[i] = "0" + last[i];  
16.         graycode[graycode.length - 1 - i] = "1" + last[i];  
17.     }  
18.   
19.     return graycode;  
20. }  

格雷码还有一种实现方式是根据这个公式来的 G(n) =  B(n) XOR B(n+1), 这也是格雷码和二进制码的转换公式。代码如下：

[java]  view plain  copy

1. public void getGrayCode(int bitNum){  
2.     for(int i = 0; i < (int)Math.pow(2, bitNum); i++){  
3.         int grayCode = (i >> 1) ^ i;  
4.         System.out.println(num2Binary(grayCode, bitNum));  
5.     }  
6. }  
7. public String num2Binary(int num, int bitNum){  
8.     String ret = "";  
9.     for(int i = bitNum-1; i >= 0; i--){  
10.         ret += (num >> i) & 1;  
11.     }  
12.     return ret;  
13. }