面试必须要懂的函数

//#define STL
#ifdef STL


#include <cassert>
#include <iostream>


using namespace std;


char *strcpy(char *dest, const char *src)
{
char *t = dest;
if(dest == src)
return dest;
assert(dest != NULL && src != NULL);
while(*dest++ = *src++)
;
return t;
}


char *strncpy(char *dest, const char *src, int count)
{
char *t = dest;
assert(dest != NULL && src != NULL);
while(count-- && (*dest++ = *src++))
;
return t;
}


int strcmp(const char *str1, const char *str2)
{
assert(str1 != NULL && str2 != NULL);
while(*str1 && *str2 && *str1++ == *str2++)
;
return *str1 - *str2;
}


int strncmp(const char *str1, const char *str2, int n)
{
assert(str1 != NULL && str2 != NULL);
while(n-- && *str1 != '\0' && *str2 != '\0' && *str1++ == *str2++)
;
return *str1 - *str2;
}


char *strcat(char *dest, const char *src)
{
char *t = dest;
assert(dest != NULL && src != NULL);
while(*dest)
dest++;
while(*dest++ = *src++)
;
return t;
}


char *strncat(char *dest, const char *src, int n)
{
char *t = dest;
assert(dest != NULL && src != NULL);
while(*dest != '\0')
dest++;
while(n-- && src != '\0')
*dest++ = *src++;
*dest = '\0';
return t;
}


int strlen(char *src)
{
int count = 0;
assert(src != NULL);
while(*src++ != '\0')
count++;
return count;
}


char *strstr2(const char *str, const char *strSearch)
{
assert(str != NULL && strSearch != NULL);
while(*str != '\0')
{
int i = 0;
while(*str != '\0' && *strSearch != '\0' && *str++ == *strSearch++)
i++;
if(strSearch == '\0')
return (char *)str - i;
str++;
}
return NULL;
}


void *memcpy(void *dest, const void *src, unsigned int count)
{
char *pdest = (char *)dest;
char *psrc = (char *)src;
assert(dest != NULL && src != NULL);
while(count--)
*pdest++ = *psrc++;
return dest;
}


void *memccpy(void *dest, const void *src, int c, unsigned int count)
{
char *pdest = (char *)dest;
char * psrc = (char *)src;
assert(dest != NULL && src != NULL);
for( ; count--; pdest++, psrc++)
{
*pdest = *psrc;
if(*psrc == c)
return psrc + 1;
}
return NULL;
}


int memcmp(const void *s1, const void *s2, unsigned int count)
{
char *ps1 = (char *)s1;
char *ps2 = (char *)s2;
assert(s1 != NULL && s2 != NULL);
while(count-- && *ps1++ == *ps2++)
;
return *ps1 - *ps2;
}


void *memset(void *dest, int c, unsigned int count)
{
char *pdest = (char *)dest;
assert(dest != NULL);
while(count--)
*pdest++ = (char)c;
return dest;
}


/*
要处理src与dest有重叠的情况，不是从尾部开始复制就行了
一种是dest与src在src后面且彼此之间的距离小于count，这种情况从尾部开始复制
其它情况从dest头部开始复制
*/
void *memmove(void *dest, const void *src, unsigned int count)
{
char *pdest = (char *)dest;
char *psrc = (char *)src;
if(pdest - count < src)
{
for( ; count; count--)
*(pdest + count - 1) = (*psrc + count - 1);
}
else
while(count--)
*pdest++ = *psrc;
return dest;
}


#endif


//#define ALPH_INT_CONVERT
#ifdef ALPH_INT_CONVERT


#include <iostream>
#include <cassert>
#include <limits>


using namespace std;


int atoi(const char *s)
{
assert(s != NULL);
while(isspace(*s))
s++;
int minus = 1;
if(*s == '-')
{
minus = -1;
s++;
}
if(*s == '+')
s++;
assert(isdigit(*s));
int number = 0;
while(isdigit(*s))
{
number *= 10;
number += *s - '0';
s++;
assert(number < numeric_limits<int>::max() / 10);
}
number *= minus;
return number;
}


char *itoa(int num, char *s, int radix)
{
char factor[] = "0123456789abcdefghijklmnopqrstuvwxyz";
unsigned unum = num;
char *t = s;
int first = 0;
if(num < 0 && radix == 10)
{
*s++ = '-';
unum = -num;
first++;
}
do
{
int i = unum % radix;
char x= factor[i];
*s = x;
unum /= radix;
s++;
}while(unum != 0);
reverse(t + first, s - 1);
return t;
}


int main()
{
string s = " -045684";
cout << atoi(s.c_str()) << endl;
int number = 0xff;
char st[100] = "";
cout << itoa(number, st, 16) << endl;
system("pause");
return 0;
}


#endif


//#define KMP
#ifdef KMP


#include <iostream>
#include <string>
#include <vector>


using namespace std;
/*对于next[]数组的定义如下：


　1) next[j] = -1  j = 0


　2) next[j] = max(k): 0<k<j   P[0...k-1]=P[j-k,j-1]


　3) next[j] = 0  其他
 按照递推的思想：


   根据定义next[0]=-1，假设next[j]=k, 即s[0...k-1]==s[j-k,j-1]


   1)若s[j]==s[k]，则有P[0..k]==P[j-k,j]，很显然，next[j+1]=next[j]+1=k+1;


   2)若P[j]!=P[k]，则可以把其看做模式匹配的问题，即匹配失败的时候，k值如何移动，显然k=next[k]。
   
 */


void getNext(const string &s, vector<int> &next)
{
next.clear();
next.assign(s.length(), 0);
next[0] = -1; //next[]定义中的第一种情况 next[j] = -1  j = 0
int j = 0, k = -1;
while(j < s.length() - 1)
{
if(k == -1) //k已回退到起点(next[]定义中的第三种情况next[j] = 0  其他)
{
next[j + 1] = 0;
j++;
k = 0;
}
else if(s[j] == s[k])//匹配的情况下s[j] == s[k]
{
next[j + 1] = k + 1;
j++, k++;
}
else
k = next[k];//匹配不成功，k回退
}
}


int kmpMatch(const string &s, const string &find)
{
vector<int> next;
getNext(find, next);
for(int i = 0, j = 0; i < s.length(); )
{
if( j >= (int)find.length())//已找到
return i - j;
if(j == -1) //当j == -1时，s[i]已经于find[0]比较过了，所以要i++否则会陷入死循环
j = 0, i++;
else if(s[i] == find[j])//匹配，继续比较下一个
j++, i++;
else //不匹配，j回退
j = next[j];
}
return -1;
}


int main()
{
string s = "dbbdabcabbababba";
string f = "ababb";
cout << kmpMatch(s, f) << endl;
system("pause");
return 0;
}


#endif