面试

 1.2008.02.28 方正国际 C++

struct Node
{
    int value;
 Node* pLeft;
 Node* pRight;
};

void AppendValue(Node* pRoot, int value)
{
 if ( pRoot )
 {
  if ( pRoot->value > value )
  {
   if ( pRoot->pLeft )
   {
    AppendValue(pRoot->pLeft, value);
   }
   else
   {
    Node* node  = new Node();
    node->value  = value;
    node->pLeft  =
    node->pRight = NULL;
    pRoot->pLeft = node;
   }

  }else
  {
   if ( pRoot->pRight )
   {
    AppendValue(pRoot->pRight, value);
   }
   else
   {
    Node* node    = new Node();
    node->value   = value;
    node->pLeft   =
    node->pRight  = NULL;
    pRoot->pRight = node;
   }
  }
 }
}

void MidTree(Node* pRoot)
{
 if ( pRoot )
 {
  MidTree(pRoot->pLeft);
  std::cout << pRoot->value << " ";
  MidTree(pRoot->pRight);
 }
}

/**
* 创建排序2叉树
*/
Node* CreateSortBinaryTree(int* values, int count)
{
 assert(count > 0);

 Node* pRoot = new Node();
 pRoot->pLeft   =
 pRoot->pRight  = NULL;
 pRoot->value   = values[0];

 for ( int index = 1; index < count; index++ )
 {
  AppendValue(pRoot, values[index]);
 }

 return pRoot;

} 

int ChCmp(char lCh, char rCh)
{
 if ( lCh >= 'A' && lCh <= 'Z' )
 {
  lCh = lCh - 'A' + 'a';
 }

 if ( rCh >= 'A' && rCh <= 'Z' )
 {
  rCh = rCh - 'A' + 'a';
 }

 if ( lCh > rCh )
 {
  return 1;
 }
 else if ( lCh < rCh )
 {
  return -1;
 }

 return 0;

}

/**
* 比较字符串，忽略大小写
*/
int StrCmp(const char* lStr, const char* rStr)
{
 int res = 0;
 while ( *lStr != '/0' && *rStr != '/0')
 {
  res = ChCmp(*lStr, *rStr);

  lStr++;
  rStr++;

  if ( res == 1 || res == -1 )
  {
   break;
  }

 }
 
 if ( res == 0 )
 {
  if ( *lStr != '/0' )
  {
   assert(rStr == '/0');
   res = 1;
  }
  if ( *rStr != '/0' )
  {
   assert(rStr =='/0');
   res = -1;
  }
 }

 return res;

}

/**
* 实现类似vector的类
*/
const int INIT_ALLOC = 3;
template < class Type >
class MyVector
{
public:

 MyVector()
 {
  m_values  = (Type*)::malloc(INIT_ALLOC*sizeof(Type));
  m_size    = 0;
  m_caplity = INIT_ALLOC;
 }

 ~MyVector()
 {
  free(m_values);
  m_values  = NULL;
  m_size    =
  m_caplity = 0;
 }

 void Append(const Type& value)
 {
  m_size += 1;
  Alloc();
  m_values[m_size - 1] = value;
 }

 bool Delete(int index)
 {
  if ( index < m_size && index >=0 )
  {
   if ( m_size > (index + 1) )
       ::memcpy(m_values+index, m_values+index+1, (m_size - index - 1)*sizeof(Type));
   m_size--;
   return true;
  }
  return false;
 }

 void Print()
 {
  std::cout << std::endl;
  for ( int i = 0; i < m_size; i++ )
  {
   std::cout << m_values[i] << " ";
  }
  std::cout << std::endl;
 }

private:
 void  Alloc()
 {
  if ( m_caplity < m_size )
  {
   m_caplity += INIT_ALLOC;
   if ( m_values )
       m_values = (Type*)::realloc(m_values, m_caplity * sizeof(Type));
   else
    m_values = (Type*)::malloc(m_caplity * sizeof(Type));
  }
 }
 int   m_caplity;
 int   m_size;
 Type* m_values;
};