字串操作彙總（不斷新增中）

1、從字串A中找到匹配字串B的第一個子串的位置，以下的程式碼經測試比Plauger的stl（VC7）中的
::std::string::find要快30%左右
// 仿函式版本
template < class Character = char, class Size = int >
struct StringFinder
{
 typedef Size size_t;
 typedef Character char_t;
 size_t operator()( const char_t* lpszSource, const char_t* lpszSearch )
 {
  // maybe the processing of the following line can delay to the caller
  if ( ( NULL == lpszSource ) || ( NULL == lpszSearch ) ) return -1;
  const char_t& cSource = *lpszSource;
  const char_t& cSearch = *lpszSearch;
  for ( ; ; )
  {
   if ( 0 == *lpszSearch )
   {
    return ( lpszSource - ( lpszSearch - &cSearch ) - &cSource );
   }
   if ( 0 == *lpszSource ) return -1;
   if ( *lpszSource != *lpszSearch )
   {
    lpszSource -= lpszSearch - &cSearch - 1;
    lpszSearch = &cSearch;
    continue;
   }
   ++ lpszSource;
   ++ lpszSearch;
  }
  return -1;
 }
};
// 函式版本
template < class char_t, class size_t >
size_t StringFind( const char_t* lpszSource, const char_t* lpszSearch )
{
 // maybe the processing of the following line can delay to the caller
 if ( ( NULL == lpszSource ) || ( NULL == lpszSearch ) ) return -1;
 const char_t& cSource = *lpszSource;
 const char_t& cSearch = *lpszSearch;
 for ( ; ; )
 {
  if ( 0 == *lpszSearch )
  {
   return ( lpszSource - ( lpszSearch - &cSearch ) - &cSource );
  }
  if ( 0 == *lpszSource ) return -1;
  if ( *lpszSource != *lpszSearch )
  {
   lpszSource -= lpszSearch - &cSearch - 1;
   lpszSearch = &cSearch;
   continue;
  }
  ++ lpszSource;
  ++ lpszSearch;
 }
 return -1;
}

2、字串比較，同strcmp的功能，以下為仿函式版本。
struct StringCmp
{
 int operator()( const char* lpszStr1, const char* lpszStr2 )
 {
  if ( NULL == lpszStr1 )
  {
   if ( NULL == lpszStr2 ) return 0;
   return -1;
  }
  if ( NULL == lpszStr2 ) return 1;

  for ( ; ( 0 != ( ( *lpszStr1 ) & ( *lpszStr2 ) ) ); ++ lpszStr1, ++ lpszStr2 )
  {
   if ( *lpszStr1 < *lpszStr2 ) return -1;
   if ( *lpszStr1 > *lpszStr2 ) return 1;
  }
  if ( 0 != *lpszStr2 ) return -1;
  if ( 0 != *lpszStr1 ) return 1;
  return 0;
 }
};

3、快速排序演算法（做了優化處理的），當元素總數不超過給定的閾值（threshold）時，採用插入排序，如果這個
做筆試題的話，個人認為難度偏大，因為其中程式部分可能技巧性比較強，需要很細心。俺也是花了很長時間上機
除錯，我認為可能冒泡、插入排序更適合筆試。做完此題後，我還參讀了Plauger's stl(VC7)中::std::sort
的原始碼，不同的是，其閾值預設為32，並且在超過閾值時也作了優化，小於或等於則都用了插入排序，呵呵。。。

struct NullType;

template < class T, class Iterator = T*, class Pr = NullType, class Diff = __int64, Diff threshold = 9 >
struct Sorter;

template < class T, class Iterator, class Diff, Diff threshold >
struct Sorter< T, Iterator, NullType, Diff, threshold >// sort by operator <
{
 typedef T type;
 typedef T& reference;
 typedef const T& const_reference;
 typedef T* pointer;
 typedef Iterator iterator;

 void operator()( iterator begin, iterator end )// sort in field [begin, end)
 {
  QuickSort( begin, end );
 }

 void InsertionSort( iterator begin, iterator end )// sort in field [begin, end)
 {
  type swap_temp;
  for ( iterator i = begin + 1; i < end; ++ i )
  {
   for ( iterator j = i; ( j > begin ) && ( *j < *( j - 1 )  ); -- j )
   {
    swap_temp = *j;
    j[0] = j[-1];
    j[-1] = swap_temp;
   }
  }
 }

 void QuickSort( iterator begin, iterator end )// sort in field [begin, end)
 {
  Diff diff = end - begin;
  // optimize speed with InsertionSort if the number of elements is not more than threshold
  if ( threshold >= diff )
  {
   InsertionSort( begin, end );
   return;
  }

  // find pivot
  iterator pivot = begin + ( diff >> 1 );

  // swap pivot with the element before end
  type swap_temp;
  swap_temp = end[-1];
  end[-1] = *pivot;
  pivot[0] = swap_temp;

  // partition
  iterator right_first = Partition( begin, end - 2, end[-1] );

  // restore pivot to primary position
  if ( right_first < ( end - 1 ) )
  {
   swap_temp = right_first[0];
   right_first[0] = end[-1];
   end[-1] = swap_temp;
  }

  if ( ( right_first - begin ) > 2 )
   QuickSort( begin, right_first );// sort in field [begin, right_first)
  if ( ( end - right_first ) > 3 )
   QuickSort( right_first + 1, end );// sort in field [right_first + 1, end )
 }
private:
 iterator Partition( iterator first, iterator last, const_reference pivot )
 {
  iterator last_temp = last;
  type swap_temp;
  for ( ; first < last; )
  {
   if ( *last < pivot )
   {
    if ( *first < pivot )
    {
     ++ first;
     continue;
    }
    swap_temp = *first;
    first[0] = *last;
    last[0] = swap_temp;
    ++ first;
    -- last;
   }
   else
   {
    if ( *first < pivot )
    {
     ++ first;
     -- last;
     continue;
    }
    -- last;
    continue;
   }
  }
  // calculate the first position of right part
  for ( ; ( !( pivot < *last ) )&& ( last <= last_temp ); ++ last ) {}
  return last;
 }
};

template < class T, class Iterator, class Pr, class Diff, Diff threshold >
struct Sorter< T, Iterator, Pr, Diff, threshold >// sort by Pr
{
 // Just change it1 < it 2 to Pr( it1, it2 )
};

4、判斷字串是否為迴環串，類似於"abcdcba"（？），這個可能挺簡單，但是好像很多大公司出的
筆試題似乎都很簡單，不知其考察點在於什麼。。。
template < class Character = char >
struct IsCircleString
{
 typedef Character char_t;
 bool operator()( const char_t* pStr )
 {
  const char_t* pLast = pStr;
  for ( ; 0 != *pLast; ++ pLast ) {}
  if ( ( ( pLast - pStr ) & 0x1 ) == 0 ) return false;//偶數即返回false
  -- pLast;
  for ( ; pStr < pLast; ++ pStr, -- pLast )
  {
   if ( *pStr != *pLast ) return false;
  }
  return true;
 }
};

#include 
#include 
#include 
using namespace std;
//reverse the string 's1' except the substring 'token'.
const char* reverse(const char* s1, const char* token)
{
	assert(s1 && token);
	stack stack1;
	const char* ptoken = token, *head = s1, *rear = s1;
	while (*head != '\0')
	{
		while(*head!= '\0' && *ptoken == *head)
		{
			ptoken++;
			head++;
		}
		if(*ptoken == '\0')//contain the token
		{
			const char* p;
			for(p=head-1;p>=rear;p--)
				stack1.push(*p);

			ptoken = token;
			rear = head;
		}
		else
		{
			stack1.push(*rear);
			head=++rear;
			ptoken = token;
		}
	}
	char * return_v = new char[strlen(s1)+1];
	int i=0;
	while(!stack1.empty())
	{
		return_v[i++] = stack1.top();
		stack1.pop();
	}
	return_v[i]='\0';
	return return_v;
}
int main(int argc, char* argv[])
{
	
	cout<

雅虎筆試題(字串操作)  給定字串A和B,輸出A和B中的共有最大子串。
  比如A="aocdfe"   B="pmcdfa"   則輸出"cdf"   

#include  
  #include  
  #include  
   
  char   *commanstring(char   shortstring[],   char   longstring[])  
  {  
  int   i,   j;  
   
  char   *substring=malloc(256);  
   
  if(strstr(longstring,   shortstring)!=NULL)                             //如果……，那麼返回shortstring  
  return   shortstring;      
   
  for(i=strlen(shortstring)-1;i>0;   i--)                                   //否則，開始迴圈計算  
  {  
  for(j=0;   j<=strlen(shortstring)-i;   j++){  
  memcpy(substring,   &shortstring[j],   i);  
  substring[i]='\0';  
  if(strstr(longstring,   substring)!=NULL)  
  return   substring;  
  }  
  }  
  return   NULL;  
  }  
   
   
  main()  
  {  
  char   *str1=malloc(256);  
  char   *str2=malloc(256);  
  char   *comman=NULL;  
   
  gets(str1);  
  gets(str2);  
   
  if(strlen(str1)>strlen(str2))                                                   //將短的字串放前面  
  comman=commanstring(str2,   str1);  
  else  
  comman=commanstring(str1,   str2);  
   
  printf("the   longest   comman   string   is:   %s\n",   comman);  
  }

早一點的ms筆試：字串倒序輸出

#include
#include
using namespace std;
void convert(char *str,int len)
{
 assert(str!=NULL);
 char *p1=str;
 char *p2=str+len-1;

 while(p2>p1){
  *p2^=*p1;
  *p1^=*p2;
  *p2^=*p1;
  p1++;
  --p2;
 }
 
}

int main(){
char str[]="The quick brown fox jumps over a lazy dog";
cout << str<convert(str,strlen(str));
cout << str<char *p=str;
char *q=p;
 
while(*p!='\0'){
 ++p;
 if(*p==' ' || *p=='\0'){
  convert(q,p-q);
  cout << str<  q=p+1;
 }
}
 
cout << str<

system("pause");
}

程式設計師面試題精選(07)－翻轉句子中單詞的順序
題目：輸入一個英文句子，翻轉句子中單詞的順序，但單詞內字元的順序不變。句子中單詞以空格符隔開。為簡單起見，標點符號和普通字母一樣處理。
例如輸入“I am a student.”，則輸出“student. a am I”。
分析：由於編寫字串相關程式碼能夠反映程式設計師的程式設計能力和程式設計習慣，與字串相關的問題一直是程式設計師筆試、面試題的熱門題目。本題也曾多次受到包括微軟在內的大量公司的青睞。
由於本題需要翻轉句子，我們先顛倒句子中的所有字元。這時，不但翻轉了句子中單詞的順序，而且單詞內字元也被翻轉了。我們再顛倒每個單詞內的字元。由於單詞內的字元被翻轉兩次，因此順序仍然和輸入時的順序保持一致。
還是以上面的輸入為例子。翻轉“I am a student.”中所有字元得到“.tneduts a ma I”，再翻轉每個單詞中字元的順序得到“students. a am I”，正是符合要求的輸出。
參考程式碼：
///////////////////////////////////////////////////////////////////////
// Reverse a string between two pointers
// Input: pBegin - the begin pointer in a string
//        pEnd   - the end pointer in a string
///////////////////////////////////////////////////////////////////////
void Reverse(char *pBegin, char *pEnd)
{
      if(pBegin == NULL || pEnd == NULL)
            return;
      while(pBegin < pEnd)
      {
            char temp = *pBegin;
            *pBegin = *pEnd;
            *pEnd = temp;
            pBegin ++, pEnd --;
      }
}
///////////////////////////////////////////////////////////////////////
// Reverse the word order in a sentence, but maintain the character
// order inside a word
// Input: pData - the sentence to be reversed
///////////////////////////////////////////////////////////////////////
char* ReverseSentence(char *pData)
{
      if(pData == NULL)
            return NULL;

      char *pBegin = pData;
      char *pEnd = pData;
      while(*pEnd != '\0')
            pEnd ++;
      pEnd--;

      // Reverse the whole sentence
      Reverse(pBegin, pEnd);

      // Reverse every word in the sentence
      pBegin = pEnd = pData;
      while(*pBegin != '\0')
      {
            if(*pBegin == ' ')
            {
                  pBegin ++;
                  pEnd ++;
                  continue;
            }
            // A word is between with pBegin and pEnd, reverse it
            else if(*pEnd == ' ' || *pEnd == '\0')
            {
                  Reverse(pBegin, --pEnd);
                  pBegin = ++pEnd;
            }
            else
            {
                  pEnd ++;
            }
      }
      return pData;
}

程式設計師面試題精選(13)－第一個只出現一次的字元
題目：在一個字串中找到第一個只出現一次的字元。如輸入abaccdeff，則輸出b。 分析：這道題是2006年google的一道筆試題。
看到這道題時，最直觀的想法是從頭開始掃描這個字串中的每個字元。當訪問到某字元時拿這個字元和後面的每個字元相比較，如果在後面沒有發現重複的字元，則該字元就是隻出現一次的字元。如果字串有n個字元，每個字元可能與後面的O(n)個字元相比較，因此這種思路時間複雜度是O(n2)。我們試著去找一個更快的方法。
由於題目與字元出現的次數相關，我們是不是可以統計每個字元在該字串中出現的次數？要達到這個目的，我們需要一個資料容器來存放每個字元的出現次數。在這個資料容器中可以根據字元來查詢它出現的次數，也就是說這個容器的作用是把一個字元對映成一個數字。在常用的資料容器中，雜湊表正是這個用途。
雜湊表是一種比較複雜的資料結構。由於比較複雜，STL中沒有實現雜湊表，因此需要我們自己實現一個。但由於本題的特殊性，我們只需要一個非常簡單的雜湊表就能滿足要求。由於字元（char）是一個長度為8的資料型別，因此總共有可能256 種可能。於是我們建立一個長度為256的陣列，每個字母根據其ASCII碼值作為陣列的下標對應陣列的對應項，而陣列中儲存的是每個字元對應的次數。這樣我們就建立了一個大小為256，以字元ASCII碼為鍵值的雜湊表。
我們第一遍掃描這個陣列時，每碰到一個字元，在雜湊表中找到對應的項並把出現的次數增加一次。這樣在進行第二次掃描時，就能直接從雜湊表中得到每個字元出現的次數了。
參考程式碼如下：
///////////////////////////////////////////////////////////////////////
// Find the first char which appears only once in a string
// Input: pString - the string
// Output: the first not repeating char if the string has, otherwise 0
///////////////////////////////////////////////////////////////////////
char FirstNotRepeatingChar(char* pString)
{
      // invalid input
      if(!pString)
            return 0;

      // get a hash table, and initialize it
      const int tableSize = 256;
      unsigned int hashTable[tableSize];
      for(unsigned int i = 0; i < tableSize; ++ i)
            hashTable = 0;

      // get the how many times each char appears in the string
      char* pHashKey = pString;
      while(*(pHashKey) != '\0')
            hashTable[*(pHashKey++)] ++;

      // find the first char which appears only once in a string
      pHashKey = pString;
      while(*pHashKey != '\0')
      {
            if(hashTable[*pHashKey] == 1)
                  return *pHashKey;

            pHashKey++;
      }

      // if the string is empty
      // or every char in the string appears at least twice
      return 0;
}

程式設計師面試題精選(17)－把字串轉換成整數
題目：輸入一個表示整數的字串，把該字串轉換成整數並輸出。例如輸入字串"345"，則輸出整數345。 分析：這道題儘管不是很難，學過C/C++語言一般都能實現基本功能，但不同程式設計師就這道題寫出的程式碼有很大區別，可以說這道題能夠很好地反應出程式設計師的思維和程式設計習慣，因此已經被包括微軟在內的多家公司用作面試題。建議讀者在往下看之前自己先編寫程式碼，再比較自己寫的程式碼和下面的參考程式碼有哪些不同。
首先我們分析如何完成基本功能，即如何把表示整數的字串正確地轉換成整數。還是以"345"作為例子。當我們掃描到字串的第一個字元'3'時，我們不知道後面還有多少位，僅僅知道這是第一位，因此此時得到的數字是3。當掃描到第二個數字'4'時，此時我們已經知道前面已經一個3了，再在後面加上一個數字4，那前面的3相當於30，因此得到的數字是3*10+4=34。接著我們又掃描到字元'5'，我們已經知道了'5'的前面已經有了34，由於後面要加上一個5，前面的34就相當於340了，因此得到的數字就是34*10+5=345。
分析到這裡，我們不能得出一個轉換的思路：每掃描到一個字元，我們把在之前得到的數字乘以10再加上當前字元表示的數字。這個思路用迴圈不難實現。
由於整數可能不僅僅之含有數字，還有可能以'+'或者'-'開頭，表示整數的正負。因此我們需要把這個字串的第一個字元做特殊處理。如果第一個字元是'+'號，則不需要做任何操作；如果第一個字元是'-'號，則表明這個整數是個負數，在最後的時候我們要把得到的數值變成負數。
接著我們試著處理非法輸入。由於輸入的是指標，在使用指標之前，我們要做的第一件是判斷這個指標是不是為空。如果試著去訪問空指標，將不可避免地導致程式崩潰。另外，輸入的字串中可能含有不是數字的字元。每當碰到這些非法的字元，我們就沒有必要再繼續轉換。最後一個需要考慮的問題是溢位問題。由於輸入的數字是以字串的形式輸入，因此有可能輸入一個很大的數字轉換之後會超過能夠表示的最大的整數而溢位。
現在已經分析的差不多了，開始考慮編寫程式碼。首先我們考慮如何宣告這個函式。由於是把字串轉換成整數，很自然我們想到：
int StrToInt(const char* str);
這樣宣告看起來沒有問題。但當輸入的字串是一個空指標或者含有非法的字元時，應該返回什麼值呢？0怎麼樣？那怎麼區分非法輸入和字串本身就是”0”這兩種情況呢？
接下來我們考慮另外一種思路。我們可以返回一個布林值來指示輸入是否有效，而把轉換後的整數放到引數列表中以引用或者指標的形式傳入。於是我們就可以宣告如下：
bool StrToInt(const char *str, int& num);
這種思路解決了前面的問題。但是這個函式的使用者使用這個函式的時候會覺得不是很方便，因為他不能直接把得到的整數賦值給其他整形變臉，顯得不夠直觀。
前面的第一種宣告就很直觀。如何在保證直觀的前提下當碰到非法輸入的時候通知使用者呢？一種解決方案就是定義一個全域性變數，每當碰到非法輸入的時候，就標記該全域性變數。使用者在呼叫這個函式之後，就可以檢驗該全域性變數來判斷轉換是不是成功。
下面我們寫出完整的實現程式碼。參考程式碼：
enum Status {kValid = 0, kInvalid};
int g_nStatus = kValid;

///////////////////////////////////////////////////////////////////////
// Convert a string into an integer
///////////////////////////////////////////////////////////////////////
int StrToInt(const char* str)
{
      g_nStatus = kInvalid;
      long long num = 0;

      if(str != NULL)
      {
            const char* digit = str;

            // the first char in the string maybe '+' or '-'
            bool minus = false;
            if(*digit == '+')
                  digit ++;
            else if(*digit == '-')
            {
                  digit ++;
                  minus = true;
            }

            // the remaining chars in the string
            while(*digit != '\0')
            {
                  if(*digit >= '0' && *digit <= '9')
                  {
                        num = num * 10 + (*digit - '0');

                        // overflow  
                        if(num > std::numeric_limits<int>::max())
                        {
                              num = 0;
                              break;
                        }

                        digit ++;
                  }
                  // if the char is not a digit, invalid input
                  else
                  {
                        num = 0;
                        break;
                  }
            }

            if(*digit == '\0')
            {
                  g_nStatus = kValid;
                  if(minus)
                        num = 0 - num;
            }
      }

      return static_cast<int>(num);
}

討論：在參考程式碼中，我選用的是第一種宣告方式。不過在面試時，我們可以選用任意一種宣告方式進行實現。但當面試官問我們選擇的理由時，我們要對兩者的優缺點進行評價。第一種宣告方式對使用者而言非常直觀，但使用了全域性變數，不夠優雅；而第二種思路是用返回值來表明輸入是否合法，在很多API中都用這種方法，但該方法宣告的函式使用起來不夠直觀。
最後值得一提的是，在C語言提供的庫函式中，函式atoi能夠把字串轉換整數。它的宣告是int atoi(const char *str)。該函式就是用一個全域性變數來標誌輸入是否合法的。

程式設計師面試題精選(20)－最長公共子串
題目：如果字串一的所有字元按其在字串中的順序出現在另外一個字串二中，則字串一稱之為字串二的子串。注意，並不要求子串（字串一）的字元必須連續出現在字串二中。請編寫一個函式，輸入兩個字串，求它們的最長公共子串，並列印出最長公共子串。 例如：輸入兩個字串BDCABA和ABCBDAB，字串BCBA和BDAB都是是它們的最長公共子串，則輸出它們的長度4，並列印任意一個子串。
分析：求最長公共子串（Longest Common Subsequence, LCS）是一道非常經典的動態規劃題，因此一些重視演算法的公司像MicroStrategy都把它當作面試題。
完整介紹動態規劃將需要很長的篇幅，因此我不打算在此全面討論動態規劃相關的概念，只集中對LCS直接相關內容作討論。如果對動態規劃不是很熟悉，請參考相關演算法書比如演算法討論。
先介紹LCS問題的性質：記Xm={x0, x1,…xm-1}和Yn={y0,y1,…,yn-1}為兩個字串，而Zk={z0,z1,…zk-1}是它們的LCS，則：
1.       如果xm-1=yn-1，那麼zk-1=xm-1=yn-1，並且Zk-1是Xm-1和Yn-1的LCS；
2.       如果xm-1≠yn-1，那麼當zk-1≠xm-1時Z是Xm-1和Y的LCS；
3.       如果xm-1≠yn-1，那麼當zk-1≠yn-1時Z是Yn-1和X的LCS；
下面簡單證明一下這些性質：
1.       如果zk-1≠xm-1，那麼我們可以把xm-1（yn-1）加到Z中得到Z’，這樣就得到X和Y的一個長度為k+1的公共子串Z’。這就與長度為k的Z是X和Y的LCS相矛盾了。因此一定有zk-1=xm-1=yn-1。
既然zk-1=xm-1=yn-1，那如果我們刪除zk-1（xm-1、yn-1）得到的Zk-1，Xm-1和Yn-1，顯然Zk-1是Xm-1和Yn-1的一個公共子串，現在我們證明Zk-1是Xm-1和Yn-1的LCS。用反證法不難證明。假設有Xm-1和Yn-1有一個長度超過k-1的公共子串W，那麼我們把加到W中得到W’，那W’就是X和Y的公共子串，並且長度超過k，這就和已知條件相矛盾了。
2.       還是用反證法證明。假設Z不是Xm-1和Y的LCS，則存在一個長度超過k的W是Xm-1和Y的LCS，那W肯定也X和Y的公共子串，而已知條件中X和Y的公共子串的最大長度為k。矛盾。
3.       證明同2。
有了上面的性質，我們可以得出如下的思路：求兩字串Xm={x0, x1,…xm-1}和Yn={y0,y1,…,yn-1}的LCS，如果xm-1=yn-1，那麼只需求得Xm-1和Yn-1的LCS，並在其後新增xm-1（yn-1）即可；如果xm-1≠yn-1，我們分別求得Xm-1和Y的LCS和Yn-1和X的LCS，並且這兩個LCS中較長的一個為X和Y的LCS。
如果我們記字串Xi和Yj的LCS的長度為c[i,j]，我們可以遞迴地求c[i,j]：
          /      0                               if i<0 or j<0
c[i,j]=          c[i-1,j-1]+1                    if i,j>=0 and xi=xj
         \       max(c[i,j-1],c[i-1,j]           if i,j>=0 and xi≠xj
上面的公式用遞迴函式不難求得。但從前面求Fibonacci第n項(本面試題系列第16題）的分析中我們知道直接遞迴會有很多重複計算，我們用從底向上迴圈求解的思路效率更高。
為了能夠採用迴圈求解的思路，我們用一個矩陣（參考程式碼中的LCS_length）儲存下來當前已經計算好了的c[i,j]，當後面的計算需要這些資料時就可以直接從矩陣讀取。另外，求取c[i,j]可以從c[i-1,j-1] 、c[i,j-1]或者c[i-1,j]三個方向計算得到，相當於在矩陣LCS_length中是從c[i-1,j-1]，c[i,j-1]或者c[i-1,j]的某一個各自移動到c[i,j]，因此在矩陣中有三種不同的移動方向：向左、向上和向左上方，其中只有向左上方移動時才表明找到LCS中的一個字元。於是我們需要用另外一個矩陣（參考程式碼中的LCS_direction）儲存移動的方向。
參考程式碼如下：
#include "string.h"

// directions of LCS generation
enum decreaseDir {kInit = 0, kLeft, kUp, kLeftUp};

/////////////////////////////////////////////////////////////////////////////
// Get the length of two strings' LCSs, and print one of the LCSs
// Input: pStr1         - the first string
//        pStr2         - the second string
// Output: the length of two strings' LCSs
/////////////////////////////////////////////////////////////////////////////
int LCS(char* pStr1, char* pStr2)
{
      if(!pStr1 || !pStr2)
            return 0;

      size_t length1 = strlen(pStr1);
      size_t length2 = strlen(pStr2);
      if(!length1 || !length2)
            return 0;

      size_t i, j;

      // initiate the length matrix
      int **LCS_length;
      LCS_length = (int**)(new int[length1]);
      for(i = 0; i < length1; ++ i)
            LCS_length = (int*)new int[length2];

      for(i = 0; i < length1; ++ i)
            for(j = 0; j < length2; ++ j)
                  LCS_length[j] = 0;

      // initiate the direction matrix
      int **LCS_direction;
      LCS_direction = (int**)(new int[length1]);
      for( i = 0; i < length1; ++ i)
            LCS_direction = (int*)new int[length2];

      for(i = 0; i < length1; ++ i)
            for(j = 0; j < length2; ++ j)
                  LCS_direction[j] = kInit;

      for(i = 0; i < length1; ++ i)
      {
            for(j = 0; j < length2; ++ j)
            {
                  if(i == 0 || j == 0)
                  {
                        if(pStr1 == pStr2[j])
                        {
                              LCS_length[j] = 1;
                              LCS_direction[j] = kLeftUp;
                        }
                        else
                              LCS_length[j] = 0;
                  }
                  // a char of LCS is found,
                  // it comes from the left up entry in the direction matrix
                  else if(pStr1 == pStr2[j])
                  {
                        LCS_length[j] = LCS_length[i - 1][j - 1] + 1;
                        LCS_direction[j] = kLeftUp;
                  }
                  // it comes from the up entry in the direction matrix
                  else if(LCS_length[i - 1][j] > LCS_length[j - 1])
                  {
                        LCS_length[j] = LCS_length[i - 1][j];
                        LCS_direction[j] = kUp;
                  }
                  // it comes from the left entry in the direction matrix
                  else
                  {
                        LCS_length[j] = LCS_length[j - 1];
                        LCS_direction[j] = kLeft;
                  }
            }
      }
      LCS_Print(LCS_direction, pStr1, pStr2, length1 - 1, length2 - 1);

      return LCS_length[length1 - 1][length2 - 1];
}

void LCS_Print(int **LCS_direction,
                    char* pStr1, char* pStr2,
                    size_t row, size_t col)
{
      if(pStr1 == NULL || pStr2 == NULL)
            return;

      size_t length1 = strlen(pStr1);
      size_t length2 = strlen(pStr2);

      if(length1 == 0 || length2 == 0 || !(row < length1 && col < length2))
            return;

      // kLeftUp implies a char in the LCS is found
      if(LCS_direction[row][col] == kLeftUp)
      {
            if(row > 0 && col > 0)
                  LCS_Print(LCS_direction, pStr1, pStr2, row - 1, col - 1);

            // print the char
            printf("%c", pStr1[row]);
      }
      else if(LCS_direction[row][col] == kLeft)
      {
            // move to the left entry in the direction matrix
            if(col > 0)
                  LCS_Print(LCS_direction, pStr1, pStr2, row, col - 1);
      }
      else if(LCS_direction[row][col] == kUp)
      {
            // move to the up entry in the direction matrix
            if(row > 0)
                  LCS_Print(LCS_direction, pStr1, pStr2, row - 1, col);
      }
}
擴充套件：如果題目改成求兩個字串的最長公共子字串，應該怎麼求？子字串的定義和子串的定義類似，但要求是連續分佈在其他字串中。比如輸入兩個字串BDCABA和ABCBDAB的最長公共字串有BD和AB，它們的長度都是2。

程式設計師面試題精選(21)－左旋轉字串
題目：定義字串的左旋轉操作：把字串前面的若干個字元移動到字串的尾部。如把字串abcdef左旋轉2位得到字串cdefab。請實現字串左旋轉的函式。要求時間對長度為n的字串操作的複雜度為O(n)，輔助記憶體為O(1)。
分析：如果不考慮時間和空間複雜度的限制，最簡單的方法莫過於把這道題看成是把字串分成前後兩部分，通過旋轉操作把這兩個部分交換位置。於是我們可以新開闢一塊長度為n+1的輔助空間，把原字串後半部分拷貝到新空間的前半部分，在把原字串的前半部分拷貝到新空間的後半部分。不難看出，這種思路的時間複雜度是O(n)，需要的輔助空間也是O(n)。
接下來的一種思路可能要稍微麻煩一點。我們假設把字串左旋轉m位。於是我們先把第0個字元儲存起來，把第m個字元放到第0個的位置，在把第2m個字元放到第m個的位置…依次類推，一直移動到最後一個可以移動字元，最後在把原來的第0個字元放到剛才移動的位置上。接著把第1個字元儲存起來，把第m+1個元素移動到第1個位置…重複前面處理第0個字元的步驟，直到處理完前面的m個字元。
該思路還是比較容易理解，但當字串的長度n不是m的整數倍的時候，寫程式會有些麻煩，感興趣的朋友可以自己試一下。由於下面還要介紹更好的方法，這種思路的程式碼我就不提供了。
我們還是把字串看成有兩段組成的，記位XY。左旋轉相當於要把字串XY變成YX。我們先在字串上定義一種翻轉的操作，就是翻轉字串中字元的先後順序。把X翻轉後記為XT。顯然有(XT)T=X。
我們首先對X和Y兩段分別進行翻轉操作，這樣就能得到XTYT。接著再對XTYT進行翻轉操作，得到(XTYT)T=(YT)T(XT)T=YX。正好是我們期待的結果。
分析到這裡我們再回到原來的題目。我們要做的僅僅是把字串分成兩段，第一段為前面m個字元，其餘的字元分到第二段。再定義一個翻轉字串的函式，按照前面的步驟翻轉三次就行了。時間複雜度和空間複雜度都合乎要求。
參考程式碼如下：
#include "string.h"
///////////////////////////////////////////////////////////////////////
// Move the first n chars in a string to its end
///////////////////////////////////////////////////////////////////////
char* LeftRotateString(char* pStr, unsigned int n)
{
      if(pStr != NULL)
      {
            int nLength = static_cast<int>(strlen(pStr));
            if(nLength > 0 || n == 0 || n > nLength)
            {
                  char* pFirstStart = pStr;
                  char* pFirstEnd = pStr + n - 1; //pStr+nLength-1;
                  char* pSecondStart = pStr + n;// pStr+nLength;
                  char* pSecondEnd = pStr + nLength - 1;// pStr + n - 1

                  // reverse the first part of the string
                  ReverseString(pFirstStart, pFirstEnd);
                  // reverse the second part of the strint
                  ReverseString(pSecondStart, pSecondEnd);
                  // reverse the whole string
                  ReverseString(pFirstStart, pSecondEnd);
            }
      }

      return pStr;
}

///////////////////////////////////////////////////////////////////////
// Reverse the string between pStart and pEnd
///////////////////////////////////////////////////////////////////////
void ReverseString(char* pStart, char* pEnd)
{
      if(pStart == NULL || pEnd == NULL)
      {
            while(pStart <= pEnd)
            {
                  char temp = *pStart;
                  *pStart = *pEnd;
                  *pEnd = temp;

                  pStart ++;
                  pEnd --;
            }
      }
}

來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/10697500/viewspace-545332/，如需轉載，請註明出處，否則將追究法律責任。