21、写一段代码判断机器的字节序。

字节序有两种方法：
大端法：高位字节存放在内存低地址端，低位字节存放在内存的高地址端；
小端法：低位字节存放在内存低地址端，高位字节存放在内存的高地址端；
其中网络字节序采用的是大端法，而主机字节序则根据CPU的不同所采用的方法不一样，可以通过写一段代码来查看自己主机的字节序。
判断主机字节序的方法也有两种：
一是使用联合体，代码如下：

typedef union{
    unsigned short value;
    unsigned char bytes[2];
}Test;
int check(void)
{
    Test test;
    test.value = 0x1234;
    if (test.bytes[0] == 0x12 && test.bytes[1] == 0x34)
    {
        return 1;//大端
    }
    else if(test.bytes[0] == 0x34& test.bytes[1] == 0x12)
    {
        return 0;//小端
    }
    else
        return -1;//此种情况表示不能使用该种方法识别字节序，比如short不是两个字节
}
//二是使用强制转换，代码如下：
bool check(void)
{
    unsigned short flag = 0x4321;
    if ( *(unsigned char*)&flag == 0x21)
        return true;//小端
    else
        return false;//大端
}

22、placement new的使用

//用于在已经分配好的内存上，再进行二次分配，实现如下：
//假设有类X，成员函数Do()，代码如下：
int main()
{
    char *buf = new char[sizeof(X)];
    X *x = new (buf) X;
    x->Do();
    x->~X(); //一定要主动调用析构函数去析构
    delete []buf;
    return 0;
}

23、socket编程需调用那些函数？

发送和接收过程：
tcp：socket(),bind(),listen(),accept(),read(),write()
udp:socket(),bind(),recvfrom(),sendto(),close

24、二叉树的部分实现代码

//定义二叉树结构
typedef struct Node{
    int data;
    struct Node* left;
    struct Node* right;
}NODE;
//递归建立二叉树
void create(NODE* &Head)
{
    Head = (NODE*)malloc(sizeof(NODE));
    scanf(“%d”, &Head->data);
    if (Head)
    {
        create(Head->left);
        create(Head->right);
    }
}
//先序遍历
void Preorder(NODE *T)
{
    if (T)
    {
        printf(“%d\n”, T->data);
        Preorder(T->left);
        Preorder(T->right);
    }
}

//TODO:将一个数组按序填充到二叉树中，使之成为二叉有序树，方法是先
给跟节点赋值，再把小的放跟节点左边，大的放跟节点右边。

25、写代码实现旋转字符串，例如：abcdefg->efgabcd

void ReversionString(char* s, int from, int to)
{
    while(from < to)
    {
        char tmp = s[from];
        s[from++] = s[to];
        s[to--] = tmp;
    }
}
void RotationString(char* s, int len, int m)
{
    m = m%len;//TODO:考虑m比len大的情况
    ReversionString(s, 0, m-1);
    ReversionString(s, m, len-1);
    ReversionString(s, 0, len-1);
}
//思路：要旋转的两部分先分别反转，然后整体反转，就实现了旋转字符串。

26、给定两个分别由字符串组成的字符串A和字符串B，字符串B的长度比字符串A短。请问如何最快地判断字符串B中所有字符是否都包含在字符串A里。假设所有字符都是大小字母。

bool stringContains(string &A, string &B)
{
    int hase = 0;
    for(int i=0;I < a.length();i++)
    {
        hash |= (1<<(a[i]-‘A’));//整数代替hasttable
    }
    for(int i=0;i<b.length();i++)
    {
        if ((hash & (1<<(b[i]-‘A’))) == 0)
        {
            return false;
        }
    }
    return true;
}

27、字符串转换成整数，输入字符串”123”， 输出整数123

int strToInt(const char* str)
{
    static const int max_int = (int)((unsigned)~0>>1);
    static const int min_int = -(int)((unsigned)~0>>1)-1;
    unsigned int n = 0;
    if (str == NULL)
        return 0;
    while(isspace(*str)) //c库函数，检查字符是否为空格
        ++str;
    int sign = 1;
    if (*str == ‘+’ || *str == ‘-‘) //检查正负
    {
        if (*str == ‘-‘)
        {
            sign = -1;
        }   
        ++str;
    }
    while(isdigit(*str))
    {
        int c = *str-‘0’;
        if (sign >0 && (n > max_int/10 || (n == max_int/10 && c > max_int%10)))
        {
            n = max_ing;
            break;
        }
        else if( sign < 0 && (n > (unsigned)min_int/10 || (n == (unsigned)min_int/10 && c > (unsigned)min_int%10)))
        {
            n = min_int;
            break;
        }
        n = n*10 + c;
        ++str;
    }
    return sign >0 ? n:-n;
}

28、判断一个字符串是否是回文的，即一个顺着读和反着读都是一样的字符串，例如：madam

bool IsPalindrone(const char* s, int n)
{
    if (s == NULL || n < 1)
        return false;
    char* first, *second;
    int m = (n/2-1) > 0?(n/2-1):0;
    first = s+m;
    second = s+n-1-m;
    while(first >= s)
    {
        if (*first-- != *second++)
         return false;
    }
    return true;
}

29、int a=(int)(((int*)0)+4)；问a的值是多少？

(int*)0定义一个指向0地址的整形指针，指针+4就是偏移到第四个整形地址的开头，那么该地址强制转换为int就是16(32位机器上)。

30、两个大整数相加，输入两个保存整数的字符串，输出他们的和的字符串

(1)先将两个字符串逆序保存到整形数组中
(2)整形数组同下标相加，放到第三个整形数组
(3)对第三个整形数组C[]，如果C[i]>10，那么C[i] = C[i]-10,C[i+1] = C[i+1]+1;
(4)将第三个数组转换为字符串，输出。