面试题

题目：写一个函数，检查一个字符串是不是有效的IP地址,合法的格式应如:192.168.0.1
函数：int is_valid_ip( char* s_ip );
返回值：
      0 ：not IP
      1 ：is IP

同时，写一段测试代码用于测试你的函数。

我的答案：

int is_valid_ip( char *sIP )
{
  int ret = 1;
  int ip[4] = {0,};
  char tmp[2] = 0;
  int num = sscanf( sIP, "%d.%d.%d.%d%1s", &ip[0], &ip[1], &ip[2], &ip[3], tmp );
  if( num == 4 ) {
    for( int i=0; i<4; i++ ) {
      if( ip[i]<0 || ip[i]>255 ) {
      ret = 0;
      break;
      }
    }
  }
  else
  {
    ret = 0;
  }
  return ret;
}

今天又去面试了，MFC的题没做，做算法题，总的来说，比较失败。

1. 解二次方程:a*x*x+b*x+c
int Quadratic( double a,double b,double c,double& x1,double& x2);
返回值：解的个数

2. 最大公约数
DWORD Divisor( DWORD dwFirst, DWORD dwSecond );
返回值：最大公约数

3. 根据蒙特卡洛算法计算圆周率
double PI( DOWRD dwCount/*测试次数*/ )；
返回值：PI

4. 无符号整数乘法，乘数为32bit，结果为64bit
提示：32bit整数分解为16bit相乘
void Multiply( DWORD dwFirst, DWORD dwSecond, DWORD& dwHigh, DWORD& dwLower );

5. 链表排序(从小到大)
节点定义为：
struct Node{
  int nValue;
  struct Node* pNext; 
};
最后一个节点的pNext = NULL.
struct Node* SortChain( struct Node* pHead );
返回值：链表头

解答：

1.
int Quadratic( double a,double b,double c,double& x1,double& x2)
{
  int ret = 0;
  double e = 0.0000001;
  if( a == 0 ){
    if( b == 0 ){
      ret = 0;
    }
    else{
      ret = 1;
      x1 = -c/b;
    }   
  }
  else{
    double B = b*b;
    double C = 4.0*a*c;
    if( B<C+e && B>C-e ){
      ret = 1;
      x1 = -b/2/a;
    }
    else if( B<C ){
      ret = 0;
    }
    else{
      ret = 2;
      x1 = (-b+sqrt(B-C))/2/a;
      x1 = (-b-sqrt(B-C))/2/a;
    }   
  }
  return ret;
}

2.
DWORD Divisor( DWORD dwFirst, DWORD dwSecond )
{
  DWORD a,b,tmp;
  assert( dwFirst!=0 && dwSecond!=0 );
  a = dwFirst;
  b = dwSecond;
  while( b != 0 )
  {
    tmp = a%b;
    a = b;
    b = tmp;
  }
  return a;
}

3.
double PI( DOWRD dwCount/*测试次数*/ )
{
  double R = 32767.0;  
  DWORD count = 0;
  srand( (unsigned)time( NULL ) ); // 这段代码当时没写，因为没有msdn，只记得一个rand()，连32767也是试出来的。
  for( DWORD i=0;i<dwCount;i++ )
  {
    int x = rand();
    int y = rand();
    double r = sqrt( x*x + y*y );   
    if( r<R )
    {
      count++;
    }
  }
  return 4.0*count/dwCount;
}

4.
void Multiply( DWORD dwFirst, DWORD dwSecond, DWORD& dwHigh, DWORD& dwLower )
{
  DWORD ah,al,bh,bl
  ah = dwFirst>>16;
  al = dwFirst&0xffff;
  bh = dwSecond>>16;
  bl = dwSecond&0xffff;
  dwHigh = ah*bh;
  dwLower = al*bl;
  DWORD tmp1 = ah*bl;
  DWORD tmp2 = al*bh;
  dwHigh += tmp1>>16;
  dwHigh += tmp2>>16;
  DWORD tmp3 = (tmp1&0xffff) + (tmp2&0xffff) + (dwLower>>16);
  dwHigh += tmp3>>16;
  dwLower &= 0xffff;
  dwLower |= (tmp3&0xffff)<<16;
}

5.

// 方法2：冒泡排序
struct Node* SortChain( struct Node* pHead )
{
  DWORD dwNum == 0;
  if( pHead = NULL )
  {
    return NULL;
  }
  Node* pChain = pHead;
  dwNum = 1;
  while( pChain->pNext != NULL )
  {
    dwNum++;
    pChain = pChain->pNext;
  }
 
  for( DWORD i=0;i<dwNum-1;i++ )
  {
    pChain = pHead;
    for( DWORD j=i;j<dwNum-1;j++ )
    {
      if( pChain->nValue > pChain->pNext->nValue )
      {
        DWORD tmp = pChain->nValue;
        pChain->nValue = pChain->pNext->nValue;
        pChain->pNext->nValue = tmp;
      }
      pChain = pChain->pNext;
    }
  }
  retur pHead;
}

// 方法2：插入排序
 struct Node* NewSortChain( struct Node *pHead )
{
  struct Node *pNewHead = NULL;    // 新构造的链表
  struct Node *pOldChain = NULL;   // 用于遍历旧的链表
  struct Node *pOldChainNext = NULL;    // 用于临时存放pOldChain的pNext

  pOldChain = pHead;

  while( pOldChain != NULL )
  {
    pOldChainNext = pOldChain->pNext; // 保存pOldChain->pNext
    if( pNewHead == NULL )
    {
      pNewHead = pOldChain;
      pNewHead->pNext = NULL;
    }
    else
    {
      if( pOldChain->nValue <= pNewHead->nValue )
      {
        pOldChain->pNext = pNewHead;
        pNewHead = pOldChain;
      }
      else
      {
        struct Node *pNewChain = pNewHead; // 用于遍历新的链表，寻找插入点
        while( pNewChain != NULL )
        {
          if( pNewChain->pNext == NULL || pOldChain->nValue <= pNewChain->pNext->nValue )
          {
            pOldChain->pNext = pNewChain->pNext;
            pNewChain->pNext = pOldChain;
            break;
          }
          pNewChain = pNewChain->pNext;
        }    
      }
    }
    pOldChain = pOldChainNext;
  } 
  return pNewHead;
}