面试一

代码鲁棒性 (输入参数检查等) 贯穿所有代码当中，不会特别强调.

1赋值运算符函数

注意：

1. 返回值类型为该类型引用（链式赋值），返回*this

2. 传入参数常量引用

3. 释放自身已有空间

4. 判断是不是自身赋值

例：

[cpp] view plaincopy
MyString&MyString::operator=( const MyString& str ){
  if ( this == &str )
   return *this;

  delete[] m_pData;
  m_pData = NULL:

  m_pData = new char[strlen(str.m_pData) + 1];
  strcpy( m_pData,str.m_pData );

  return *this;
}

不足：若内存不足，new 申请内存时抛出异常，则 m_pData 已经被 delete，此时其为一个空指针，非常容易导致程序奔溃。在赋值运算符函数内部抛异常，CMyString 实例不再保持有效的状态，违背异常安全性原则.

改进:1. 先 new 再 delete 2. 创建临时实例，交换临时实例和原来的实例：

[cpp] view plaincopy
MyString&MyString::operator=( const MyString& str ){
  if ( &str!= this ){
   MyString strTemp( str );

   char* pTemp = strTemp.m_pData;
   strTemp.m_pData = m_pData;
   m_pData = pTemp;
  }

  return *this;
}

3. 二维数组中的查找：二维数组，每一行，从左到右递增。每一列，从上到下递增。输入一个二维数组和一个整数，判断数组中是否含有该整数

思路：选取数组右上角数字，等于->结束。大于->剔除这一列。小于->剔除这一行。这样每比较一次剔除一列或一行，缩小范围，直到找到要查找的数字 or 查找范围为空

例：

[cpp] viewplain copy
bool Find( int* matrix, int rows, int cols, int number ){
  bool found = false;

  if ( NULL != matrix&& rows > 0 && cols > 0 ){
   int row = 0;
   int col = cols - 1;

   while ( row < rows && col >= 0 ){
   if ( number == matrix[row * cols + col]){
   found = true;
   return found;
   }
   else if ( matrix[row * cols + col] >number )
   --col;
   else
   ++row;
   }
  }

  return found;
}

二维数组在内存中占据连续的空间。在内存中从上到下存储各行元素，每行从左到右顺序存储

4. 替换空格

1. 在原串上操作 --> 保证原串后面有足够的空间 --> 从后往前替换

2.开辟新空间 --> 直接替换

两种思路都需遍历原串一次获取空格个数 --> O(N)

相关题目:两个排序数组 A1，A2。A1 后有足够空间容纳 A2，将 A2 中数字插入 A1 中使所有数字依旧有序

思路：遍历两个数组各一次得到两数组长度，三个指针，一个指针指向lengthA1+lengthA2-1，其余两个分别指向 A1 与 A2 末尾。依次比较，将合适数字放到第一个指针所指位置

合并两个数组 (字符串) 时，如果从前往后赋值每个数字 or 字符需要重复移动数字 or 字符多次 --> 从后往前复制，减少移动次数，提高效率

5. 从尾到头打印链表

1. 栈

2. 递归

7. 用两个栈实现队列

思路：栈 S1 和 S2，入「队列」入栈 S1。出「队列」，若 S2 有元素 S2.pop( )，否则，将 S1 中元素压入栈 S2

相关题目：

1. 求链表中间结点

思路：两个指针，p1，p2。p1 一次走一步，p2 一次走两步。当 p2 指向链表最后一个结点时，p1 正好指向链表中间节点

2. 判断链表是否带环

思路：快慢指针，相遇->带环。快指针到链表尾->不带环

当我们用一个指针遍历链表不能解决问题时，可以尝试两个指针来遍历链表。可以让其中一个指针走的快些 (如一次走两步)，或者让它先在链表上走若干步

16. 反转链表

[cpp] view plaincopy
ListNode*ReverseList( ListNode* pHead )
{
  // 链表为空和链表只有一个结点在这个语句进行处理
  if (NULL == pHead|| NULL == pHead->next)
   return pHead;

  ListNode* pPrev = NULL;
  ListNode* pCur = pHead;
  ListNode* pReverseHead = NULL;

  while (NULL != pCur){
   ListNode* pNext = pCur->next;

   if (NULL == pNext)
   pReverseHead = pCur;

   pCur->next = pPrev;

   pPrev = pCur;
   pCur = pNext;
  }

  return pReverseHead;
}

17. 合并两个排序的链表

：

[cpp] view plaincopy
ListNode*Merge( ListNode* pHead1, ListNoe* pHead2 ) {
  if (NULL == pHead1)
   return pHead2;
  else if (NULL == pHead2)
   return pHead1;

  ListNode* pMergedHead = NULL;

  if (pHead1->val< pHead2->val){
   pMergeHead = pHead1;
   pMergeHead->next = Merge( pHead1->next, pHead2 );
  }
  else{
   pMergeHead = pHead2;
   pMergeHead->next = Merge( pHead1, pHead2->next );
  }

  return pMergedHead;
}

21. 包含 min 函数的栈定义一个可以使 min, push, pop 都为 O(1) 的栈

思路：借用辅助栈，每次数据栈元素入栈时，将所有入栈元素中最小值入辅助栈 (保证辅助栈和数据栈->同入同出)

：

[cpp] view plain copy
void Push( const int&data ){
   dataS.push( data );

if (0 == minS.size() || data < minS.top( ))
  minS.push( data );
else
  minS.push( minS.top( ) );
}

void Pop( ){
assert( dataS.size( )> 0 &&minS.size( ) > 0 );

dataS.pop( );
minS.pop( );
}

const T& Min( ) const {
assert( dataS.size( )> 0 &&minS.size( ) > 0 );

return minS.top( );
}

23. 从上往下打印二叉树 (层序遍历二叉树)

借助队列

：

[cpp] view plaincopy
voidLevelPrint( Node* pRoot ){
  if (NULL == pRtoot)
   return;

  queue<Node*> queueNode;
  queueNode.push( pRoot );

  while (0 !=queueNode.size( )) {
   Node* pNode = queueNode.front( );
   queueNode.pop( );

   Visit( pNode );

   if (NULL !=pNode->pLeft)
   queueNode.push(pNode->pLeft);

   if (NULL !=pNode->pRight)
   queueNode.push(pNode->pRight);
  }
}

29. 数组中出现次数超过一半的数字

思路：如果有一个数字出现次数超过数组元素总个数的一半，则它出现次数比其他数字出现的次数总和还要多。

[cpp] viewplain copy
bool g_inputInvalid= false;

bool CheckInvalidArr( int* arr, int len ){
  g_inputInvalid = false;

  if (NULL == arr|| len <= 0)
   g_inputInvalid = true;

  return g_inputInvalid;
}

bool CheckMoreThanHalf( int* arr, int len, int number ){
  int times = 0;

  for (int i = 0; i < len; ++i)
   if (number== arr[i])
   ++times;

  bool isMoreThanHalf= true;
  if (times* 2 <= len){
   g_inputInvalid = true;
   isMoreThanHalf = false;
  }

  return isMoreThanHalf;
}

int MoreThanHalfNum( int* arr, int len ){
  // 如果只返回0存在二义性，是无效参数返回0还是0出现次数超过一半呢？
  // 定义一个函数和一个全局变量，即可区分这两种情况
  if (CheckInvalidArray(arr, len ))
   return 0;

  int result = arr[0];
  int times = 1;

  for (int i = 1; i < len; ++i){
   if (0 == times){
   result = arr[i];
   times = 1;
   }
   else if (result== arr[i])
   ++times;
   else
   --times;
  }

  // 此时result中保存的数字并不一定是数组中出现次数超过数组长度一半的数字，需要验证
  // 11234
  if (!CheckMoreThanHalf(arr, len, result ))
   result = 0;

  return result;
}

37. 两个链表的第一个公共结点

思路：

1. 借助栈，两个链表都从后往前遍历，直到找到最后一个相同结点

2. 遍历两个链表一次，得到链表长度，len1，len2。假设 len1 为 5，len2 为 4。则在链表 1 上先走 (len1 - len2) 步，接着同时开始走，第一个相同节点

38. 数字在排序数组中出现的次数

思路：

因为是排序数组，找到第一个 k 和最后一个 k 即可知道 k 出现的次数 O(log n) 二分

：

[cpp] viewplain copy
int GetFirstK( int* arr, int len, int k, int start, int end ){
  // 这段区间内没找到k，返回-1
  if (start >end)
   return -1;

  int midIndex =(start + end) / 2;
  int midData =arr[midIndex];

  if (k ==midData){
   if ((midIndex> 0 &&k != arr[midIndex - 1])
   || 0 == midIndex)
   return midIndex;
   else
   end = midIndex - 1;
  }
  else if (midData >k)
   end = midIndex - 1;
  else
   start = midIndex + 1;

  return GetFirstK(arr, len, k, start, end );
}

int GetLastK( int* arr, int len, int k, int start, int end ){
  if (start >end)
   return -1;

  int midIndex =(start + end) / 2;
  int midData =arr[midIndex];

  if (k ==midData){
   if ((midIndex< len - 1 &&k != arr[midIndex + 1])
   || len - 1 == midIndex)
   return midIndex;
   else
   start = midIndex + 1;
  }
  else if (midData >k)
   end = midIndex - 1;
  else
   start = midIndex + 1;

  return GetLastK(arr, len, k, start, end );
}

int GetTimesOfK( int* arr, int len, int k ){
  int times = 0;

  if (NULL != arr&& len > 0 ){
   int first = GetFirstK( arr, len, k, 0, len - 1 );
   int last = GetLastK( arr, len, k, 0, len - 1 );

   if (first> -1 &&last > -1)
   times = last - first + 1;
  }

  return times;
}

39. 二叉树的深度

[cpp] viewplain copy
int TreeDepth( BinaryTreeNode*pRoot ){
  if (NULL == pRoot)
   return 0;

  int depthLeft =TreeDepth( pRoot->left );
  int depthRight =TreeDepth( pRoot->right );

  return (depthleft> depthRight) ? (depthLeft + 1) : (depthRight + 1);
}

相关题目：判断一棵树是不是平衡二叉树。左右子树的深度相差不超过 1.

1. 需要重复遍历多次的解法

：

[cpp] viewplain copy
bool IsBalanced( BinaryTreeNode*pRoot ){
  if (NULL == pRoot)
   return true;

  int depthLeft =TreeDepth( pRoot->left );
  int depthRight =TreeDepth( pRoot->right );
  int diff = left -right;

  if (diff> 1 ||diff < -1)
   return false;

  return IsBalanced(pRoot->left ) && IsBalanced( pRoot->right );
}

后序遍历，每个节点只遍历一次

：

[cpp] viewplain copy
bool IsBalanced( BinaryTreeNode*pRoot, int* pDepth ){
  if (NULL == pRoot){
   *pDepth = 0;
   return true;
  }

  int left;
  int right;

  if (IsBalanced(pRoot->left, &left ) && IsBalanced( pRoot->tight, &right)){
   int diff = left - right;
   if (diff>= -1 &&diff <= 1){
   *pDepth = left > right ? (left + 1) : (right + 1);
   return true;
   }
  }

  return false;
}

bool IsBlanced( BinaryTreeNode*pRoot ){
  int depth = 0;

  return IsBlanced(pRoot, &depth );
}

42. 翻转单词顺序 vs 左旋转字符串

输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。标点符号和普通字母一样处理。--> "Iam a student." 变为 "student. a am I"

思路：

1. 翻转句子中所有的字符。此时不但翻转了句子中单词的顺序，连单词内的字符的顺序也翻转了

2. 翻转每个单词中字符的顺序

：

[cpp] viewplain copy
void Reverse( char* pBegin, char* pEnd ){
  if (NULL == pBegin|| NULL == pEnd)
   return;

  while (pBegin <pEnd){
   char temp = *pBegin;
   *pBegin = *pEnd;
   *pEnd = temp;

   ++pBegin;
   --pEnd;
  }
}

char* ReverseSentence( char* pData ){
  if (NULL == pData)
   return NULL;

  char* pBegin = pData;
  char* pEnd = pData;

  while ('\0' != *pEnd)
   ++pEnd;

  --pEnd;

  // 翻转整个句子
  Reverse( pBegin, pEnd );

  // 翻转句子中每个单词
  pBegin = pEnd = pData;
  while ('\0' != *pBegin){
   if (' ' == *pBegin){
   ++pBegin;
   ++pEnd;
   }
   else if (' ' == *pEnd|| '\0' == *pEnd){
   Reverse( pBegin, --pEnd );
   pBegin = ++pEnd;
   }
   else
   ++pEnd;
  }

  return pData;
}

相关题目：字符串左旋/右旋是把字符串前面的若干个字符转移到字符串的尾部。「abcdefg」和数字 2 --> "cdefgab"

思路：将要左旋的字符串和剩余字符串分别翻转，再翻转整个字符串

：

[cpp] viewplain copy
char* LeftRotateString( char* pStr, int n ){
  if (NULL != pStr){
   int nLength = strlen( pStr );
   if (nLength> 0 &&n > 0 &&n < nLength){
   char* pFirstStart = pStr;
   char* pFirstEnd = pStr + n - 1;
   char* pSecondStart = pStr + n;
   char* pSecondEnd = pStr + nLength - 1;

   Reverse( pFirstStart, pFirstEnd );
   Reverse( pSecondStart, pSecondEnd );
   Reverse( pFirstStart, pSecondEnd );
   }
  }
}

50. 树中两个结点的最低公共祖先

1. 二叉搜索树

：

[cpp] view plaincopy
BSTNode*GetLastCommonNode( BSTNode* pRoot, BSTNode* pNode1, BSTNode* pNode2 ){
  if (NULL == pRoot)
   return NULL;
  else if (NULL == pNode1)
   return pNode2;
  else if (NULL == pNode2)
   return pNode1;
  else if (pNode1 ==pNode2)
   return pNode1;

  int val = pRoot->val;
  int val1 = pNode1->val;
  int val2 = pNode2->val;

  if (val1 <val && val2 < val)
   // 注意，递归时，有返回值，调用函数一定要加 return。无返回值则可以只递归调用，做你想做的事情，不用加return
   return GetLastCommonNode( pRoot->left, pNode1, pNode2 );
  else if (val1 >val && val2 > val)
   return GetLastCommonNode( pRoot->right, pNode1, pNode2 );
  else{
   if (val1== val)
   return pNode1;
   else if (val2== va1)
   return pNode2;
   else
   return pRoot;
  }
}

2. 普通树，含指向父节点指针

：

[cpp] viewplain copy
BTreeNode* FindFirstCommonNode( TreeNode* pNode1,TreeNode* pNode2 ){
  if (NULL == pNode1)
   return pNode2;
  else if (NULL == pNode2)
   return pNode1;

  stack<TreeNode*>s1;
  stack<TreeNode*>s2;

  // 注意：入栈第一个结点分别是这两个结点，而不是它们的父结点
  while (NULL != pNode1){
   s1.push( pNode1 );
   pNode1 = pNode1->parent;
  }

  while (NULL != pNode2){
   s2.push( pNode2 );
   pNode2 = pNode2->parent;
  }

  TreeNode* firstCommonNode = NULL;

  // 如果两个结点没在同一颗二叉树中，返回NULL
  if (s1.top( ) !=s2.top( ))
   return NULL;

  while (0 != s1.size( )&& 0 !=s2.size( )){
   if (s1.top() == s2.top( )){
   firstCommonNode = s1.top( );

   s1.pop( );
   s2.pop( );
   }
   else
   break;
  }

  return firstCommonNode;
}

56. 链表中环的入口结点

思路：定义指针 P1，P2。P1 在链表上走环大小步后 P2 开始以相同速度遍历链表，两个指针相遇点即为链表中环的入口结点

[cpp] view plaincopy
// 首先判断单链表是否带环，若带环（此时快慢指针已经相遇），从此刻起计步，直到下次两个指针再相遇，快指针步数减去慢指针步数，即为环的长度
ListNode* EntryNodeOfLoop( ListNode* pHead )
{
     if (NULL == pHead)
     return NULL;

     // 定义快慢指针判断是否有环
   ListNode* pFast = pHead;
   ListNode* pSlow = pHead;

     // 如果有环，通过这两个变量求得环长度
   int fastLength = 0;
   int slowLength = 0;
   int loopLength = 0;

     // 求出环长度后通过这两个结点求出环入口节点
   ListNode* p1 = pHead;
   ListNode* p2 = pHead;

     // 设置个死循环，如果链表不带环，我们在循环里直接退出即可
     while ( 1 ){
     // 在两个指针走之前必须判断pFast和pFast的next是否为空，两个条件都必须判断而且判断顺序不能出错
     // 因为快指针走得快，我们只需要判断快指针而不需要判断慢指针。如果为空，即链表不带环，返回NULL
     // 检测是否带环同时也避免指针越界访问
     if (NULL == pFast || NULL == pFast->next)
     return NULL;

   pFast = pFast->next->next;
   pSlow = pSlow->next;

     // 此时我们再判断两个指针是否相遇，不能在指针还没走的时候判断，因为最开始，两个指针就是相遇的
     if (pFast == pSlow)
     break;
   }

     // 程序运行到此处，两个指针已经相遇，此时我们求环的长度
     while ( 1 ){
   pFast = pFast->next->next;
   fastLength += 2;

   pSlow = pSlow->next;
   ++slowLength;

     if (pFast == pSlow)
     break;
   }

   loopLength = fastLength - slowLength;
     // 环长度已知，此时我们来找环的入口结点
     while ( 1 ){
     // p1先走环的长度步 loopLength
     for ( int i = 0; i < loopLength; ++i )
   p1 = p1->next;

     // 因为这个带环链表入口结点有可能就是第一个结点，所以如果此时p1走了环的长度步后回到了原点(即回到环的入口处(链表的第一个结点))与p2相遇了，则直接返回p1。即为环入口结点
     if ( p1 == p2 )
     return p1;

     //否则p1 p2以相同速度开始走
     while ( 1 ){
   p1 = p1->next;
   p2 = p2->next;

     //同样的，先走后判断
     //此时即找到了环的入口结点
     if ( p1 == p2 )
     return p1;
   }
   }
}

猜你喜欢